src/game/object.cpp

   1 /*
   2  *
   3  *  Iter Vehemens ad Necem (IVAN)
   4  *  Copyright (C) Timo Kiviluoto
   5  *  Released under the GNU General
   6  *  Public License
   7  *
   8  *  See LICENSING which should be included
   9  *  along with this file for more details
  10  *
  11  */
  12
  13 #include "object.h"
  14 #include "materia.h"
  15 #include "festring.h"
  16 #include "whandler.h"
  17 #include "rawbit.h"
  18 #include "proto.h"
  19 #include "game.h"
  20 #include "bitmap.h"
  21 #include "fesave.h"
  22
  23 v2 RightArmSparkleValidityArray[128];
  24 v2 LeftArmSparkleValidityArray[128];
  25 v2 GroinSparkleValidityArray[169];
  26 v2 RightLegSparkleValidityArray[42];
  27 v2 LeftLegSparkleValidityArray[45];
  28 v2 NormalSparkleValidityArray[256];
  29 v2 PossibleSparkleBuffer[256];
  30
  31 object::object() : entity(0), MainMaterial(0) {}
  32 int object::GetSpecialFlags() const { return ST_NORMAL; }
  33 col16 object::GetOutlineColor(int) const { return TRANSPARENT_COLOR; }
  34 cbitmap*const* object::GetPicture() const { return GraphicData.Picture; }
  35
  36 object::object(const object& Object) : entity(Object), id(Object), VisualEffects(Object.VisualEffects)
  37 {
  38   CopyMaterial(Object.MainMaterial, MainMaterial);
  39   mOnEvents = Object.mOnEvents;
  40 }
  41
  42 object::~object()
  43 {
  44   delete MainMaterial;
  45 }
  46
  47 void object::CopyMaterial(material* const& Source, material*& Dest)
  48 {
  49   if(Source)
  50   {
  51     Dest = Source->Duplicate();
  52     Dest->SetMotherEntity(this);
  53   }
  54   else
  55     Dest = 0;
  56 }
  57
  58 void object::Save(outputfile& SaveFile) const
  59 {
  60   SaveFile << GraphicData << (int)VisualEffects;
  61   SaveFile << MainMaterial;
  62 }
  63
  64 void object::Load(inputfile& SaveFile)
  65 {
  66   SaveFile >> GraphicData >> (int&)VisualEffects;
  67   LoadMaterial(SaveFile, MainMaterial);
  68 }
  69
  70 void object::ObjectInitMaterials(material*& FirstMaterial, material* FirstNewMaterial, sLong FirstDefaultVolume, material*& SecondMaterial, material* SecondNewMaterial, sLong SecondDefaultVolume, truth CallUpdatePictures)
  71 {
  72   InitMaterial(FirstMaterial, FirstNewMaterial, FirstDefaultVolume);
  73   InitMaterial(SecondMaterial, SecondNewMaterial, SecondDefaultVolume);
  74   SignalVolumeAndWeightChange();
  75
  76   if(CallUpdatePictures)
  77     UpdatePictures();
  78 }
  79
  80 void object::InitMaterial(material*& Material, material* NewMaterial, sLong DefaultVolume)
  81 {
  82   Material = NewMaterial;
  83
  84   if(Material)
  85   {
  86     if(Material->HasBe())
  87       Enable();
  88
  89     if(DefaultVolume && !Material->GetVolume())
  90       Material->SetVolume(DefaultVolume);
  91
  92     Material->SetMotherEntity(this);
  93     SignalEmitationIncrease(Material->GetEmitation());
  94   }
  95 }
  96
  97 void object::ChangeMaterial(material*& Material, material* NewMaterial, sLong DefaultVolume, int SpecialFlags)
  98 {
  99   delete SetMaterial(Material, NewMaterial, DefaultVolume, SpecialFlags);
 100 }
 101
 102 material *object::SetMaterial (material *&Material, material *NewMaterial, sLong DefaultVolume, int SpecialFlags) {
 103   material *OldMaterial = Material;
 104   Material = NewMaterial;
 105
 106   if ((!OldMaterial || !OldMaterial->HasBe()) && NewMaterial && NewMaterial->HasBe()) {
 107     Enable();
 108   } else if (OldMaterial && OldMaterial->HasBe() && (!NewMaterial || !NewMaterial->HasBe()) && !CalculateHasBe()) {
 109     Disable();
 110   }
 111   if (NewMaterial) {
 112     if (!NewMaterial->GetVolume()) {
 113       if (OldMaterial) NewMaterial->SetVolume(OldMaterial->GetVolume());
 114       else if (DefaultVolume) NewMaterial->SetVolume(DefaultVolume);
 115       else ABORT("Singularity spawn detected!");
 116     }
 117     NewMaterial->SetMotherEntity(this);
 118     if (!(SpecialFlags & NO_SIGNALS)) SignalEmitationIncrease(NewMaterial->GetEmitation());
 119   }
 120   if (!(SpecialFlags & NO_SIGNALS)) {
 121     if (OldMaterial) SignalEmitationDecrease(OldMaterial->GetEmitation());
 122     SignalVolumeAndWeightChange();
 123     SignalMaterialChange();
 124   }
 125   if (!(SpecialFlags & NO_PIC_UPDATE)) UpdatePictures();
 126   return OldMaterial;
 127 }
 128
 129
 130 void object::UpdatePictures()
 131 {
 132   static cv2 ZeroPos(0, 0);
 133   UpdatePictures(GraphicData, ZeroPos, VisualEffects|GetSpecialFlags(), GetMaxAlpha(), GetGraphicsContainerIndex(), &object::GetBitmapPos);
 134 }
 135
 136 truth object::RandomizeSparklePos(v2& SparklePos, v2 BPos, int& SparkleTime, uLong SeedBase, int SpecialFlags, int GraphicsContainerIndex) const
 137 {
 138   static int SeedModifier = 1;
 139   femath::SaveSeed();
 140   femath::SetSeed(SeedBase + SeedModifier);
 141
 142   if(++SeedModifier > 0x10)
 143     SeedModifier = 1;
 144
 145   v2* ValidityArray;
 146   int ValidityArraySize;
 147
 148   if((SpecialFlags & 0x38) == ST_RIGHT_ARM)
 149   {
 150     ValidityArray = RightArmSparkleValidityArray;
 151     ValidityArraySize = 128;
 152   }
 153   else if((SpecialFlags & 0x38) == ST_LEFT_ARM)
 154   {
 155     ValidityArray = LeftArmSparkleValidityArray;
 156     ValidityArraySize = 128;
 157   }
 158   else if((SpecialFlags & 0x38) == ST_GROIN)
 159   {
 160     ValidityArray = GroinSparkleValidityArray;
 161     ValidityArraySize = 169;
 162   }
 163   else if((SpecialFlags & 0x38) == ST_RIGHT_LEG)
 164   {
 165     ValidityArray = RightLegSparkleValidityArray;
 166     ValidityArraySize = 42;
 167   }
 168   else if((SpecialFlags & 0x38) == ST_LEFT_LEG)
 169   {
 170     ValidityArray = LeftLegSparkleValidityArray;
 171     ValidityArraySize = 45;
 172   }
 173   else
 174   {
 175     ValidityArray = NormalSparkleValidityArray;
 176     ValidityArraySize = 256;
 177   }
 178
 179   SparklePos = igraph::GetRawGraphic(GraphicsContainerIndex)->RandomizeSparklePos(ValidityArray, PossibleSparkleBuffer, BPos, TILE_V2, ValidityArraySize, GetSparkleFlags());
 180
 181   if(SparklePos != ERROR_V2)
 182   {
 183     SparkleTime = RAND() % 241;
 184     femath::LoadSeed();
 185     return true;
 186   }
 187   else
 188   {
 189     femath::LoadSeed();
 190     return false;
 191   }
 192 }
 193
 194 void object::UpdatePictures(graphicdata& GraphicData, v2 Position, int SpecialFlags, alpha MaxAlpha, int GraphicsContainerIndex, bposretriever BitmapPosRetriever) const
 195 {
 196   int AnimationFrames = GetClassAnimationFrames();
 197   v2 SparklePos;
 198   int SparkleTime = 0;
 199   int Seed = 0;
 200   int FlyAmount = GetSpoilLevel();
 201   truth Sparkling = false, FrameNeeded = false, SeedNeeded = false;
 202   v2 BPos = (this->*BitmapPosRetriever)(0);
 203   alpha Alpha;
 204
 205   if(!(SpecialFlags & (ST_FLAMES|ST_LIGHTNING)))
 206   {
 207     if(AllowSparkling())
 208     {
 209       int SparkleFlags = GetSparkleFlags();
 210
 211       if(SparkleFlags
 212    && RandomizeSparklePos(SparklePos, BPos, SparkleTime,
 213         BPos.X + BPos.Y + GetMaterialColorA(0),
 214         SpecialFlags, GraphicsContainerIndex))
 215       {
 216   Sparkling = true;
 217
 218   if(AnimationFrames <= 256)
 219     AnimationFrames = 256;
 220       }
 221     }
 222
 223     if(FlyAmount)
 224     {
 225       SeedNeeded = true;
 226       FrameNeeded = true;
 227
 228       if(AnimationFrames <= 32)
 229   AnimationFrames = 32;
 230     }
 231   }
 232   else if(SpecialFlags & ST_FLAMES)
 233   {
 234     SeedNeeded = true;
 235     FrameNeeded = true;
 236
 237     if(AnimationFrames <= 16)
 238       AnimationFrames = 16;
 239   }
 240   else if(SpecialFlags & ST_LIGHTNING)
 241   {
 242     SeedNeeded = true;
 243
 244     if(AnimationFrames <= 128)
 245       AnimationFrames = 128;
 246   }
 247
 248   if(SeedNeeded)
 249   {
 250     static int SeedModifier = 1;
 251     Seed = BPos.X + BPos.Y + GetMaterialColorA(0) + SeedModifier + 0x42;
 252
 253     if(++SeedModifier > 0x10)
 254       SeedModifier = 1;
 255   }
 256
 257   int WobbleMask = 0, WobbleData = GetWobbleData();
 258
 259   if(WobbleData & WOBBLE)
 260   {
 261     int Speed = (WobbleData & WOBBLE_SPEED_RANGE) >> WOBBLE_SPEED_SHIFT;
 262     int Freq = (WobbleData & WOBBLE_FREQ_RANGE) >> WOBBLE_FREQ_SHIFT;
 263     int WobbleFrames = 512 >> (Freq + Speed);
 264     WobbleMask = 7 >> Freq << (6 - Speed);
 265
 266     if(AnimationFrames <= WobbleFrames)
 267       AnimationFrames = WobbleFrames;
 268   }
 269
 270   ModifyAnimationFrames(AnimationFrames);
 271   int c;
 272   int OldAnimationFrames = GraphicData.AnimationFrames;
 273
 274   for(c = 0; c < OldAnimationFrames; ++c)
 275     igraph::RemoveUser(GraphicData.GraphicIterator[c]);
 276
 277   if(OldAnimationFrames != AnimationFrames)
 278   {
 279     if(OldAnimationFrames)
 280     {
 281       delete [] GraphicData.Picture;
 282       delete [] GraphicData.GraphicIterator;
 283     }
 284
 285     GraphicData.Picture = new bitmap*[AnimationFrames];
 286     GraphicData.GraphicIterator = new tilemap::iterator[AnimationFrames];
 287   }
 288
 289   GraphicData.AnimationFrames = AnimationFrames;
 290
 291   if(!AllowRegularColors())
 292     SpecialFlags |= ST_DISALLOW_R_COLORS;
 293
 294   graphicid GI;
 295   GI.BaseAlpha = MaxAlpha;
 296   GI.FileIndex = GraphicsContainerIndex;
 297   GI.SpecialFlags = SpecialFlags;
 298   GI.Seed = Seed;
 299   GI.FlyAmount = FlyAmount;
 300   GI.Position = Position;
 301   GI.RustData[0] = GetRustDataA();
 302   GI.RustData[1] = GetRustDataB();
 303   GI.RustData[2] = GetRustDataC();
 304   GI.RustData[3] = GetRustDataD();
 305   GI.WobbleData = WobbleData;
 306
 307   for(c = 0; c < AnimationFrames; ++c)
 308   {
 309     GI.Color[0] = GetMaterialColorA(c);
 310     GI.Color[1] = GetMaterialColorB(c);
 311     GI.Color[2] = GetMaterialColorC(c);
 312     GI.Color[3] = GetMaterialColorD(c);
 313     Alpha = GetAlphaA(c);
 314     GI.Alpha[0] = Alpha < MaxAlpha ? Alpha : MaxAlpha;
 315     Alpha = GetAlphaB(c);
 316     GI.Alpha[1] = Alpha < MaxAlpha ? Alpha : MaxAlpha;
 317     Alpha = GetAlphaC(c);
 318     GI.Alpha[2] = Alpha < MaxAlpha ? Alpha : MaxAlpha;
 319     Alpha = GetAlphaD(c);
 320     GI.Alpha[3] = Alpha < MaxAlpha ? Alpha : MaxAlpha;
 321     v2 BPos = (this->*BitmapPosRetriever)(c);
 322     GI.BitmapPosX = BPos.X;
 323     GI.BitmapPosY = BPos.Y;
 324
 325     if(Sparkling && c > SparkleTime && c < SparkleTime + 16)
 326     {
 327       GI.SparklePosX = SparklePos.X;
 328       GI.SparklePosY = SparklePos.Y;
 329       GI.SparkleFrame = c - SparkleTime;
 330     }
 331     else
 332     {
 333       GI.SparklePosX = SPARKLE_POS_X_ERROR;
 334       GI.SparklePosY = 0;
 335       GI.SparkleFrame = 0;
 336     }
 337
 338     GI.Frame =
 339       !c ||
 340       FrameNeeded ||
 341       ((SpecialFlags & ST_LIGHTNING) && !((c + 1) & 7)) ||
 342       ((WobbleData & WOBBLE) && !(c & WobbleMask))
 343          ? c : 0;
 344
 345     GI.OutlineColor = GetOutlineColor(c);
 346     GI.OutlineAlpha = GetOutlineAlpha(c);
 347     tilemap::iterator Iterator = igraph::AddUser(GI);
 348     GraphicData.GraphicIterator[c] = Iterator;
 349     GraphicData.Picture[c] = Iterator->second.Bitmap;
 350   }
 351 }
 352
 353 col16 object::GetMaterialColorA(int) const
 354 {
 355   return MainMaterial->GetColor();
 356 }
 357
 358 truth object::AddRustLevelDescription(festring& String, truth Articled) const
 359 {
 360   return MainMaterial->AddRustLevelDescription(String, Articled);
 361 }
 362
 363
 364 truth object::AddMaterialDescription(festring& String, truth Articled) const {
 365   //FIXME: gum solution
 366   if (isBone()) {
 367     festring s(MainMaterial->GetName(Articled));
 368     festring::sizetype pos = s.FindLast("bone");
 369     if (pos != festring::NPos && pos == s.GetSize()-4) {
 370       while (pos > 0 && s[pos-1] == ' ') pos--;
 371       s.Erase(pos, s.GetSize()-pos);
 372       if (s.GetSize() == 0) return true; // no name left
 373     }
 374     String << s;
 375   } else {
 376     MainMaterial->AddName(String, Articled);
 377   }
 378   String << ' ';
 379   return true;
 380 }
 381
 382
 383 void object::AddContainerPostFix(festring& String) const
 384 {
 385   if(GetSecondaryMaterial())
 386     GetSecondaryMaterial()->AddName(String << " full of ", false, false);
 387 }
 388
 389 void object::AddLumpyPostFix(festring& String) const
 390 {
 391   MainMaterial->AddName(String << " of ", false, false);
 392 }
 393
 394 alpha object::GetAlphaA(int) const
 395 {
 396   return MainMaterial->GetAlpha();
 397 }
 398
 399 void object::RandomizeVisualEffects()
 400 {
 401   int AcceptedFlags = GetOKVisualEffects();
 402
 403   if(AcceptedFlags)
 404     SetVisualEffects((RAND() & 0x7 & AcceptedFlags) | GetForcedVisualEffects());
 405   else
 406     SetVisualEffects(GetForcedVisualEffects());
 407 }
 408
 409 void object::LoadMaterial(inputfile& SaveFile, material*& Material)
 410 {
 411   SaveFile >> Material;
 412
 413   if(Material)
 414   {
 415     if(Material->HasBe())
 416       Enable();
 417
 418     Material->SetMotherEntity(this);
 419     game::CombineLights(Emitation, Material->GetEmitation());
 420   }
 421 }
 422
 423 int object::RandomizeMaterialConfiguration()
 424 {
 425   const fearray<sLong>& MCC = GetMaterialConfigChances();
 426   return MCC.Size > 1
 427     ? femath::WeightedRand(MCC.Data, GetMaterialConfigChanceSum())
 428     : 0;
 429 }
 430
 431 truth object::AddEmptyAdjective(festring& String, truth Articled) const
 432 {
 433   if(GetSecondaryMaterial())
 434     return false;
 435   else
 436   {
 437     String << (Articled ? "an empty " : "empty ");
 438     return true;
 439   }
 440 }
 441
 442 void object::CalculateEmitation()
 443 {
 444   Emitation = GetBaseEmitation();
 445
 446   if(MainMaterial)
 447     game::CombineLights(Emitation, MainMaterial->GetEmitation());
 448 }
 449
 450 truth object::CalculateHasBe() const
 451 {
 452   return MainMaterial && MainMaterial->HasBe();
 453 }
 454
 455 int object::GetSparkleFlags() const
 456 {
 457   return MainMaterial->IsSparkling() ? SPARKLING_A : 0;
 458 }
 459
 460 void object::InitSparkleValidityArrays()
 461 {
 462   int y, x, Index = 0;
 463
 464   for(y = 0; y < 16; ++y)
 465     for(x = 0; x < 8; ++x)
 466       RightArmSparkleValidityArray[Index++] = v2(x, y);
 467
 468   Index = 0;
 469
 470   for(y = 0; y < 16; ++y)
 471     for(x = 8; x < 16; ++x)
 472       LeftArmSparkleValidityArray[Index++] = v2(x, y);
 473
 474   Index = 0;
 475
 476   for(y = 0; y < 10; ++y)
 477     for(x = 0; x < 16; ++x)
 478       GroinSparkleValidityArray[Index++] = v2(x, y);
 479
 480   for(y = 10; y < 13; ++y)
 481     for(x = y - 5; x < 20 - y; ++x)
 482       GroinSparkleValidityArray[Index++] = v2(x, y);
 483
 484   Index = 0;
 485
 486   for(y = 10; y < 16; ++y)
 487     for(x = 0; x < 8; ++x)
 488       if((y != 10 || x < 5) && (y != 11 || x < 6) && (y != 12 || x < 7))
 489   RightLegSparkleValidityArray[Index++] = v2(x, y);
 490
 491   Index = 0;
 492
 493   for(y = 10; y < 16; ++y)
 494     for(x = 8; x < 16; ++x)
 495       if((y != 10 || x > 9) && (y != 11 || x > 8))
 496   LeftLegSparkleValidityArray[Index++] = v2(x, y);
 497
 498   Index = 0;
 499
 500   for(y = 0; y < 16; ++y)
 501     for(x = 0; x < 16; ++x)
 502       NormalSparkleValidityArray[Index++] = v2(x, y);
 503 }
 504
 505 int object::GetRustDataA() const
 506 {
 507   return MainMaterial->GetRustData();
 508 }
 509
 510 truth object::DetectMaterial(cmaterial* Material) const
 511 {
 512   for(int c = 0; c < GetMaterials(); ++c)
 513     if(GetMaterial(c) && GetMaterial(c)->IsSameAs(Material))
 514       return true;
 515
 516   return false;
 517 }