src/game/lterra.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 /* Compiled through levelset.cpp */
  14
  15 glterrainprototype::glterrainprototype(const glterrainprototype* Base, glterrainspawner Spawner, cchar* ClassID) : Base(Base), Spawner(Spawner), ClassID(ClassID) { Index = protocontainer<glterrain>::Add(this); }
  16 olterrainprototype::olterrainprototype(const olterrainprototype* Base, olterrainspawner Spawner, cchar* ClassID) : Base(Base), Spawner(Spawner), ClassID(ClassID) { Index = protocontainer<olterrain>::Add(this); }
  17
  18 square* lterrain::GetSquareUnderEntity(int) const { return LSquareUnder; }
  19 level* lterrain::GetLevel() const { return LSquareUnder->GetLevel(); }
  20 lsquare* lterrain::GetNearLSquare(v2 Pos) const { return LSquareUnder->GetLevel()->GetLSquare(Pos); }
  21 lsquare* lterrain::GetNearLSquare(int x, int y) const { return LSquareUnder->GetLevel()->GetLSquare(x, y); }
  22 room* lterrain::GetRoom() const { return GetLSquareUnder()->GetRoom(); }
  23 void lterrain::SetMainMaterial(material* NewMaterial, int SpecialFlags) { SetMaterial(MainMaterial, NewMaterial, 0, SpecialFlags); }
  24 void lterrain::ChangeMainMaterial(material* NewMaterial, int SpecialFlags) { ChangeMaterial(MainMaterial, NewMaterial, 0, SpecialFlags); }
  25 void lterrain::InitMaterials(const materialscript* M, const materialscript*, truth CUP) { InitMaterials(M->Instantiate(), CUP); }
  26
  27 void glterrain::InstallDataBase(int NewConfig) { databasecreator<glterrain>::InstallDataBase(this, NewConfig); }
  28 void olterrain::InstallDataBase(int NewConfig) { databasecreator<olterrain>::InstallDataBase(this, NewConfig); }
  29 int glterrain::GetGraphicsContainerIndex() const { return GR_GLTERRAIN; }
  30 int olterrain::GetGraphicsContainerIndex() const { return GR_OLTERRAIN; }
  31
  32 truth olterraindatabase::AllowRandomInstantiation() const { return !(Config & S_LOCK_ID); }
  33
  34 festring olterrain::GetText() const { return ""; }
  35
  36 void lterrain::Load(inputfile& SaveFile)
  37 {
  38   LSquareUnder = static_cast<lsquare*>(game::GetSquareInLoad());
  39   object::Load(SaveFile);
  40 }
  41
  42 void glterrain::Save(outputfile& SaveFile) const
  43 {
  44   SaveFile << (uShort)GetType();
  45   lterrain::Save(SaveFile);
  46   SaveFile << (uShort)GetConfig();
  47 }
  48
  49 void glterrain::Load(inputfile& SaveFile)
  50 {
  51   lterrain::Load(SaveFile);
  52   databasecreator<glterrain>::InstallDataBase(this, ReadType(uShort, SaveFile));
  53 }
  54
  55 void olterrain::Save(outputfile& SaveFile) const
  56 {
  57   SaveFile << (uShort)GetType();
  58   lterrain::Save(SaveFile);
  59   SaveFile << (uShort)GetConfig();
  60   SaveFile << HP;
  61 }
  62
  63 void olterrain::Load(inputfile& SaveFile)
  64 {
  65   lterrain::Load(SaveFile);
  66   databasecreator<olterrain>::InstallDataBase(this, ReadType(uShort, SaveFile));
  67   SaveFile >> HP;
  68 }
  69
  70 v2 lterrain::GetPos() const
  71 {
  72   return LSquareUnder->GetPos();
  73 }
  74
  75 truth lterrain::SitOn(character* Sitter)
  76 {
  77   if(GetSitMessage().GetSize())
  78   {
  79     ADD_MESSAGE("%s", GetSitMessage().CStr());
  80     Sitter->EditAP(-1000);
  81     return true;
  82   }
  83   else
  84     return false;
  85 }
  86
  87 void olterrain::Break()
  88 {
  89   lsquare* Square = GetLSquareUnder();
  90   const fearray<contentscript<item> >& ItemArray = GetLeftOverItems();
  91
  92   for(uInt c1 = 0; c1 < ItemArray.Size; ++c1)
  93     if(ItemArray[c1].IsValid())
  94     {
  95       const interval* TimesPtr = ItemArray[c1].GetTimes();
  96       int Times = TimesPtr ? TimesPtr->Randomize() : 1;
  97
  98       for(int c2 = 0; c2 < Times; ++c2)
  99       {
 100   item* Item = ItemArray[c1].InstantiateBasedOnMaterial(GetMainMaterial()->GetDigProductMaterial());
 101
 102   if(Item)
 103   {
 104     Square->AddItem(Item);
 105     Item->SpecialGenerationHandler();
 106   }
 107       }
 108     }
 109
 110   Square->ChangeOLTerrainAndUpdateLights(0);
 111 }
 112
 113 glterrain* glterrainprototype::SpawnAndLoad(inputfile& SaveFile) const
 114 {
 115   glterrain* Terrain = Spawner(0, LOAD);
 116   Terrain->Load(SaveFile);
 117   Terrain->CalculateAll();
 118   return Terrain;
 119 }
 120
 121 olterrain* olterrainprototype::SpawnAndLoad(inputfile& SaveFile) const
 122 {
 123   olterrain* Terrain = Spawner(0, LOAD);
 124   Terrain->Load(SaveFile);
 125   Terrain->CalculateAll();
 126   return Terrain;
 127 }
 128
 129 void lterrain::Initialize(int NewConfig, int SpecialFlags)
 130 {
 131   if(!(SpecialFlags & LOAD))
 132   {
 133     InstallDataBase(NewConfig);
 134     RandomizeVisualEffects();
 135
 136     if(!(SpecialFlags & NO_MATERIALS))
 137       GenerateMaterials();
 138   }
 139
 140   if(!(SpecialFlags & LOAD))
 141   {
 142     PostConstruct();
 143     RestoreHP();
 144   }
 145
 146   if(!(SpecialFlags & LOAD))
 147   {
 148     if(!(SpecialFlags & NO_MATERIALS))
 149     {
 150       CalculateAll();
 151
 152       if(!(SpecialFlags & NO_PIC_UPDATE))
 153   UpdatePictures();
 154     }
 155   }
 156 }
 157
 158 truth lterrain::CanBeSeenByPlayer() const
 159 {
 160   return LSquareUnder->CanBeSeenByPlayer();
 161 }
 162
 163 truth lterrain::CanBeSeenBy(character* Who) const
 164 {
 165   if(Who->IsPlayer())
 166     return CanBeSeenByPlayer();
 167   else
 168     return LSquareUnder->CanBeSeenFrom(Who->GetPos(), Who->GetLOSRangeSquare());
 169 }
 170
 171 void olterrain::ShowRestMessage(character*) const
 172 {
 173   if(GetRestMessage().GetSize())
 174     ADD_MESSAGE("%s", GetRestMessage().CStr());
 175 }
 176
 177 void lterrain::SignalEmitationIncrease(col24 EmitationUpdate)
 178 {
 179   if(game::CompareLights(EmitationUpdate, Emitation) > 0)
 180   {
 181     game::CombineLights(Emitation, EmitationUpdate);
 182
 183     if(LSquareUnder)
 184       LSquareUnder->SignalEmitationIncrease(EmitationUpdate);
 185   }
 186 }
 187
 188 void lterrain::SignalEmitationDecrease(col24 EmitationUpdate)
 189 {
 190   if(game::CompareLights(EmitationUpdate, Emitation) >= 0 && Emitation)
 191   {
 192     col24 Backup = Emitation;
 193     CalculateEmitation();
 194
 195     if(Backup != Emitation && LSquareUnder)
 196       LSquareUnder->SignalEmitationDecrease(EmitationUpdate);
 197   }
 198 }
 199
 200 truth olterrain::Enter(truth DirectionUp) const
 201 {
 202   if(DirectionUp)
 203     ADD_MESSAGE("You can't go up.");
 204   else
 205     ADD_MESSAGE("You can't go down.");
 206
 207   return false;
 208 }
 209
 210 int olterrain::GetStrengthValue() const
 211 {
 212   return GetMainMaterial()->GetStrengthValue() / 20;
 213 }
 214
 215 void olterrain::ReceiveDamage(character* Villain, int Damage, int)
 216 {
 217   if(CanBeDestroyed() && Damage > GetStrengthValue())
 218   {
 219     EditHP(GetStrengthValue() - Damage);
 220
 221     if(HP <= 0)
 222     {
 223       room* Room = GetRoom();
 224       Break();
 225
 226       if(Room)
 227   Room->DestroyTerrain(Villain);
 228     }
 229   }
 230 }
 231
 232 void olterrain::BeKicked(character* Kicker, int Damage, int)
 233 {
 234   if(CanBeDestroyed() && Damage > GetMainMaterial()->GetStrengthValue() >> 1)
 235   {
 236     EditHP((GetMainMaterial()->GetStrengthValue() >> 1) - Damage);
 237
 238     if(HP <= 0)
 239     {
 240       room* Room = GetRoom();
 241
 242       if(CanBeSeenByPlayer())
 243   ADD_MESSAGE("%s is shattered.", CHAR_NAME(DEFINITE));
 244
 245       Break();
 246
 247       if(Room)
 248   Room->DestroyTerrain(Kicker);
 249     }
 250   }
 251   else if(Kicker->IsPlayer())
 252     ADD_MESSAGE("Your kick has no effect on %s.", CHAR_NAME(DEFINITE));
 253 }
 254
 255 int olterrain::CalculateMaxHP()
 256 {
 257   if(GetMainMaterial())
 258   {
 259     sLong SV = GetMainMaterial()->GetStrengthValue();
 260     return SV * SV * GetHPModifier() / 6000;
 261   }
 262   else
 263     return 0;
 264 }
 265
 266 int glterrain::GetAttachedGod() const
 267 {
 268   return DataBase->AttachedGod ? DataBase->AttachedGod : MainMaterial->GetAttachedGod();
 269 }
 270
 271 int olterrain::GetAttachedGod() const
 272 {
 273   return DataBase->AttachedGod ? DataBase->AttachedGod : MainMaterial->GetAttachedGod();
 274 }
 275
 276 void olterrain::SetConfig(int NewConfig, int SpecialFlags)
 277 {
 278   databasecreator<olterrain>::InstallDataBase(this, NewConfig);
 279
 280   if(!(SpecialFlags & NO_PIC_UPDATE))
 281     UpdatePictures();
 282 }
 283
 284 god* olterrain::GetMasterGod() const
 285 {
 286   return game::GetGod(GetConfig());
 287 }
 288
 289 truth olterrain::CanBeDestroyed() const
 290 {
 291   return DataBase->CanBeDestroyed && ((GetPos().X && GetPos().Y && GetPos().X != GetLevel()->GetXSize() - 1 && GetPos().Y != GetLevel()->GetYSize() - 1) || GetLevel()->IsOnGround());
 292 }
 293
 294 //extern itemprototype key_ProtoType;
 295
 296 int olterrainprototype::CreateSpecialConfigurations (olterraindatabase **TempConfig, int Configs, int Level) {
 297   if (Level) return Configs;
 298
 299   if (TempConfig[0]->CreateDivineConfigurations) {
 300     Configs = databasecreator<olterrain>::CreateDivineConfigurations(this, TempConfig, Configs);
 301   }
 302
 303   /* Gum solution */
 304   if (TempConfig[0]->CreateLockConfigurations) {
 305     const item::database*const* KeyConfigData = key::ProtoType.GetConfigData();
 306     int KeyConfigSize = key::ProtoType.GetConfigSize();
 307     int OldConfigs = Configs;
 308     for (int c1 = 0; c1 < OldConfigs; ++c1) {
 309       if (!TempConfig[c1]->IsAbstract) {
 310         festring lcfgname;
 311         lcfgname << TempConfig[c1]->CfgStrName;
 312         lcfgname << "|locked-broken";
 313         int BaseConfig = TempConfig[c1]->Config;
 314         int NewConfig = BaseConfig|BROKEN_LOCK;
 315         olterraindatabase* ConfigDataBase = new olterraindatabase(*TempConfig[c1]);
 316         ConfigDataBase->InitDefaults(this, NewConfig, lcfgname);
 317         ConfigDataBase->PostFix << "with a broken lock";
 318         TempConfig[Configs++] = ConfigDataBase;
 319         for (int c2 = 0; c2 < KeyConfigSize; ++c2) {
 320           festring xcfgname;
 321           xcfgname << TempConfig[c1]->CfgStrName;
 322           xcfgname << "|locked";
 323           NewConfig = BaseConfig|KeyConfigData[c2]->Config;
 324           ConfigDataBase = new olterraindatabase(*TempConfig[c1]);
 325           ConfigDataBase->InitDefaults(this, NewConfig, xcfgname);
 326           ConfigDataBase->PostFix << "with ";
 327           if (KeyConfigData[c2]->UsesLongAdjectiveArticle) ConfigDataBase->PostFix << "an "; else ConfigDataBase->PostFix << "a ";
 328           ConfigDataBase->PostFix << KeyConfigData[c2]->Adjective << " lock";
 329           TempConfig[Configs++] = ConfigDataBase;
 330         }
 331       }
 332     }
 333   }
 334
 335   if (TempConfig[0]->CreateWindowConfigurations) {
 336     int OldConfigs = Configs;
 337     for (int c1 = 0; c1 < OldConfigs; ++c1) {
 338       if (!TempConfig[c1]->IsAbstract) {
 339         festring xcfgname;
 340         xcfgname << TempConfig[c1]->CfgStrName;
 341         xcfgname << "|window";
 342         int NewConfig = TempConfig[c1]->Config|WINDOW;
 343         olterraindatabase* ConfigDataBase = new olterraindatabase(*TempConfig[c1]);
 344         ConfigDataBase->InitDefaults(this, NewConfig, xcfgname);
 345         ConfigDataBase->PostFix << "with a window";
 346         ConfigDataBase->IsAlwaysTransparent = true;
 347         ConfigDataBase->BitmapPos = ConfigDataBase->WindowBitmapPos;
 348         TempConfig[Configs++] = ConfigDataBase;
 349       }
 350     }
 351   }
 352
 353   return Configs;
 354 }
 355
 356 truth olterrain::IsTransparent() const
 357 {
 358   return IsAlwaysTransparent() || MainMaterial->IsTransparent();
 359 }
 360
 361 void glterrain::ModifyAnimationFrames(int& AF) const
 362 {
 363   if(UseBorderTiles())
 364     AF += AF << 3;
 365 }
 366
 367 v2 glterrain::GetBorderBitmapPos(v2 BasePos, int I) const
 368 {
 369   if(UseBorderTiles())
 370   {
 371     int Index = I ? 8 - (I + (I << 3)) / GraphicData.AnimationFrames : 8;
 372     v2 MV = game::GetMoveVector(Index);
 373
 374     if(VisualEffects & MIRROR)
 375       MV.X = -MV.X;
 376
 377     if(VisualEffects & FLIP)
 378       MV.Y = -MV.Y;
 379
 380     if(VisualEffects & ROTATE)
 381     {
 382       cint T = MV.Y;
 383       MV.Y = -MV.X;
 384       MV.X = T;
 385     }
 386
 387     return BasePos + (MV << 4);
 388   }
 389   else
 390     return BasePos;
 391 }
 392
 393 void glterrain::Draw(blitdata& BlitData) const
 394 {
 395   if(UseBorderTiles())
 396   {
 397     cint TrueAF = GraphicData.AnimationFrames / 9;
 398     int PictureIndex = (BlitData.CustomData & SQUARE_INDEX_MASK) * TrueAF;
 399
 400     if(BlitData.CustomData & ALLOW_ANIMATE && TrueAF != 1)
 401       PictureIndex += GET_TICK() & (TrueAF - 1);
 402
 403     GraphicData.Picture[PictureIndex]->LuminanceMaskedBlit(BlitData);
 404   }
 405   else
 406   {
 407     cint AF = GraphicData.AnimationFrames;
 408     cint F = !(BlitData.CustomData & ALLOW_ANIMATE) || AF == 1 ? 0 : GET_TICK() & (AF - 1);
 409     GraphicData.Picture[F]->LuminanceBlit(BlitData);
 410   }
 411 }
 412
 413 void olterrain::ModifyAnimationFrames(int& AF) const
 414 {
 415   if(UseBorderTiles())
 416     AF += AF << 3;
 417 }
 418
 419 v2 olterrain::GetBorderBitmapPos(v2 BasePos, int I) const
 420 {
 421   if(UseBorderTiles())
 422   {
 423     int Index = I ? 8 - (I + (I << 3)) / GraphicData.AnimationFrames : 8;
 424     v2 MV = game::GetMoveVector(Index);
 425
 426     if(VisualEffects & MIRROR)
 427       MV.X = -MV.X;
 428
 429     if(VisualEffects & FLIP)
 430       MV.Y = -MV.Y;
 431
 432     if(VisualEffects & ROTATE)
 433     {
 434       cint T = MV.Y;
 435       MV.Y = -MV.X;
 436       MV.X = T;
 437     }
 438
 439     return BasePos + (MV << 4);
 440   }
 441   else
 442     return BasePos;
 443 }
 444
 445 void olterrain::Draw(blitdata& BlitData) const
 446 {
 447   if(UseBorderTiles())
 448   {
 449     cint TrueAF = GraphicData.AnimationFrames / 9;
 450     int PictureIndex = (BlitData.CustomData & SQUARE_INDEX_MASK) * TrueAF;
 451
 452     if(BlitData.CustomData & ALLOW_ANIMATE && TrueAF != 1)
 453       PictureIndex += GET_TICK() & (TrueAF - 1);
 454
 455     GraphicData.Picture[PictureIndex]->AlphaLuminanceBlit(BlitData);
 456   }
 457   else
 458   {
 459     cint AF = GraphicData.AnimationFrames;
 460     cint F = !(BlitData.CustomData & ALLOW_ANIMATE) || AF == 1 ? 0 : GET_TICK() & (AF - 1);
 461     GraphicData.Picture[F]->AlphaLuminanceBlit(BlitData);
 462   }
 463 }
 464
 465 void lterrain::SignalRustLevelChange()
 466 {
 467   UpdatePictures();
 468   GetLSquareUnder()->SendMemorizedUpdateRequest();
 469   GetLSquareUnder()->SendNewDrawRequest();
 470 }
 471
 472 void olterrain::SignalRustLevelChange()
 473 {
 474   lterrain::SignalRustLevelChange();
 475   HP = Min(HP, CalculateMaxHP());
 476 }
 477
 478 void lterrain::TryToRust (sLong LiquidModifier) {
 479   if (MainMaterial->TryToRust(LiquidModifier*10, 10000)) {
 480     if (CanBeSeenByPlayer()) {
 481       if (MainMaterial->GetRustLevel() == NOT_RUSTED) ADD_MESSAGE("%s rusts.", CHAR_NAME(DEFINITE));
 482       else ADD_MESSAGE("%s rusts more.", CHAR_NAME(DEFINITE));
 483     }
 484     MainMaterial->SetRustLevel(MainMaterial->GetRustLevel()+1);
 485   }
 486 }
 487
 488 void olterrain::ReceiveAcid(material*, sLong Modifier)
 489 {
 490   if(GetMainMaterial()->GetInteractionFlags() & CAN_DISSOLVE)
 491   {
 492     int Damage = Modifier / 10000;
 493
 494     if(Damage)
 495     {
 496       Damage += RAND() % Damage;
 497       ReceiveDamage(0, Damage, ACID);
 498     }
 499   }
 500 }
 501
 502 void lterrain::InitMaterials(material* FirstMaterial, truth CallUpdatePictures)
 503 {
 504   InitMaterial(MainMaterial, FirstMaterial, 0);
 505   SignalVolumeAndWeightChange();
 506
 507   if(CallUpdatePictures)
 508     UpdatePictures();
 509 }
 510
 511 void lterrain::GenerateMaterials()
 512 {
 513   int Chosen = RandomizeMaterialConfiguration();
 514   const fearray<sLong>& MMC = GetMainMaterialConfig();
 515   InitMaterial(MainMaterial,
 516          MAKE_MATERIAL(MMC.Data[MMC.Size == 1 ? 0 : Chosen]),
 517          0);
 518 }
 519
 520 void glterraindatabase::InitDefaults (const glterrainprototype *NewProtoType, int NewConfig, cfestring &acfgstrname)
 521 {
 522   IsAbstract = false;
 523   ProtoType = NewProtoType;
 524   Config = NewConfig;
 525   CfgStrName = acfgstrname;
 526 }
 527
 528 void olterraindatabase::InitDefaults (const olterrainprototype *NewProtoType, int NewConfig, cfestring &acfgstrname)
 529 {
 530   IsAbstract = false;
 531   ProtoType = NewProtoType;
 532   Config = NewConfig;
 533   CfgStrName = acfgstrname;
 534 }
 535
 536 truth olterrain::ShowThingsUnder() const
 537 {
 538   return DataBase->ShowThingsUnder || IsTransparent();
 539 }
 540
 541 truth olterrain::WillBeDestroyedBy(ccharacter* Char) const
 542 {
 543   return IsWall() && CanBeDestroyed() && MainMaterial->GetStrengthValue() <= (Char->GetAttribute(ARM_STRENGTH) * 3);
 544 }
 545
 546 v2 glterrain::GetBitmapPos(int I) const
 547 {
 548   return GetBorderBitmapPos(DataBase->BitmapPos, I);
 549 }
 550
 551 v2 olterrain::GetBitmapPos(int I) const
 552 {
 553   return GetBorderBitmapPos(DataBase->BitmapPos, I);
 554 }
 555
 556 truth glterrain::IsAnimated() const
 557 {
 558   return GraphicData.AnimationFrames > (UseBorderTiles() ? 9 : 1);
 559 }
 560
 561 truth olterrain::IsAnimated() const
 562 {
 563   return GraphicData.AnimationFrames > (UseBorderTiles() ? 9 : 1);
 564 }
 565
 566 void lterrain::AddLocationDescription(festring& String) const
 567 {
 568   String << " on the " << GetNameSingular();
 569 }