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 {
 298   if(Level)
 299     return Configs;
 300
 301   if(TempConfig[0]->CreateDivineConfigurations)
 302     Configs = databasecreator<olterrain>::CreateDivineConfigurations(this, TempConfig, Configs);
 303
 304   /* Gum solution */
 305
 306   if(TempConfig[0]->CreateLockConfigurations)
 307   {
 308     const item::database*const* KeyConfigData = key::ProtoType.GetConfigData();
 309     int KeyConfigSize = key::ProtoType.GetConfigSize();
 310     int OldConfigs = Configs;
 311
 312     for(int c1 = 0; c1 < OldConfigs; ++c1)
 313       if(!TempConfig[c1]->IsAbstract)
 314       {
 315   int BaseConfig = TempConfig[c1]->Config;
 316   int NewConfig = BaseConfig | BROKEN_LOCK;
 317   olterraindatabase* ConfigDataBase = new olterraindatabase(*TempConfig[c1]);
 318   ConfigDataBase->InitDefaults(this, NewConfig);
 319   ConfigDataBase->PostFix << "with a broken lock";
 320   TempConfig[Configs++] = ConfigDataBase;
 321
 322   for(int c2 = 0; c2 < KeyConfigSize; ++c2)
 323   {
 324     NewConfig = BaseConfig | KeyConfigData[c2]->Config;
 325     ConfigDataBase = new olterraindatabase(*TempConfig[c1]);
 326     ConfigDataBase->InitDefaults(this, NewConfig);
 327     ConfigDataBase->PostFix << "with ";
 328
 329     if(KeyConfigData[c2]->UsesLongAdjectiveArticle)
 330       ConfigDataBase->PostFix << "an ";
 331     else
 332       ConfigDataBase->PostFix << "a ";
 333
 334     ConfigDataBase->PostFix << KeyConfigData[c2]->Adjective << " lock";
 335     TempConfig[Configs++] = ConfigDataBase;
 336   }
 337       }
 338   }
 339
 340   if(TempConfig[0]->CreateWindowConfigurations)
 341   {
 342     int OldConfigs = Configs;
 343
 344     for(int c1 = 0; c1 < OldConfigs; ++c1)
 345       if(!TempConfig[c1]->IsAbstract)
 346       {
 347   int NewConfig = TempConfig[c1]->Config | WINDOW;
 348   olterraindatabase* ConfigDataBase = new olterraindatabase(*TempConfig[c1]);
 349   ConfigDataBase->InitDefaults(this, NewConfig);
 350   ConfigDataBase->PostFix << "with a window";
 351   ConfigDataBase->IsAlwaysTransparent = true;
 352   ConfigDataBase->BitmapPos = ConfigDataBase->WindowBitmapPos;
 353   TempConfig[Configs++] = ConfigDataBase;
 354       }
 355   }
 356
 357   return Configs;
 358 }
 359
 360 truth olterrain::IsTransparent() const
 361 {
 362   return IsAlwaysTransparent() || MainMaterial->IsTransparent();
 363 }
 364
 365 void glterrain::ModifyAnimationFrames(int& AF) const
 366 {
 367   if(UseBorderTiles())
 368     AF += AF << 3;
 369 }
 370
 371 v2 glterrain::GetBorderBitmapPos(v2 BasePos, int I) const
 372 {
 373   if(UseBorderTiles())
 374   {
 375     int Index = I ? 8 - (I + (I << 3)) / GraphicData.AnimationFrames : 8;
 376     v2 MV = game::GetMoveVector(Index);
 377
 378     if(VisualEffects & MIRROR)
 379       MV.X = -MV.X;
 380
 381     if(VisualEffects & FLIP)
 382       MV.Y = -MV.Y;
 383
 384     if(VisualEffects & ROTATE)
 385     {
 386       cint T = MV.Y;
 387       MV.Y = -MV.X;
 388       MV.X = T;
 389     }
 390
 391     return BasePos + (MV << 4);
 392   }
 393   else
 394     return BasePos;
 395 }
 396
 397 void glterrain::Draw(blitdata& BlitData) const
 398 {
 399   if(UseBorderTiles())
 400   {
 401     cint TrueAF = GraphicData.AnimationFrames / 9;
 402     int PictureIndex = (BlitData.CustomData & SQUARE_INDEX_MASK) * TrueAF;
 403
 404     if(BlitData.CustomData & ALLOW_ANIMATE && TrueAF != 1)
 405       PictureIndex += GET_TICK() & (TrueAF - 1);
 406
 407     GraphicData.Picture[PictureIndex]->LuminanceMaskedBlit(BlitData);
 408   }
 409   else
 410   {
 411     cint AF = GraphicData.AnimationFrames;
 412     cint F = !(BlitData.CustomData & ALLOW_ANIMATE) || AF == 1 ? 0 : GET_TICK() & (AF - 1);
 413     GraphicData.Picture[F]->LuminanceBlit(BlitData);
 414   }
 415 }
 416
 417 void olterrain::ModifyAnimationFrames(int& AF) const
 418 {
 419   if(UseBorderTiles())
 420     AF += AF << 3;
 421 }
 422
 423 v2 olterrain::GetBorderBitmapPos(v2 BasePos, int I) const
 424 {
 425   if(UseBorderTiles())
 426   {
 427     int Index = I ? 8 - (I + (I << 3)) / GraphicData.AnimationFrames : 8;
 428     v2 MV = game::GetMoveVector(Index);
 429
 430     if(VisualEffects & MIRROR)
 431       MV.X = -MV.X;
 432
 433     if(VisualEffects & FLIP)
 434       MV.Y = -MV.Y;
 435
 436     if(VisualEffects & ROTATE)
 437     {
 438       cint T = MV.Y;
 439       MV.Y = -MV.X;
 440       MV.X = T;
 441     }
 442
 443     return BasePos + (MV << 4);
 444   }
 445   else
 446     return BasePos;
 447 }
 448
 449 void olterrain::Draw(blitdata& BlitData) const
 450 {
 451   if(UseBorderTiles())
 452   {
 453     cint TrueAF = GraphicData.AnimationFrames / 9;
 454     int PictureIndex = (BlitData.CustomData & SQUARE_INDEX_MASK) * TrueAF;
 455
 456     if(BlitData.CustomData & ALLOW_ANIMATE && TrueAF != 1)
 457       PictureIndex += GET_TICK() & (TrueAF - 1);
 458
 459     GraphicData.Picture[PictureIndex]->AlphaLuminanceBlit(BlitData);
 460   }
 461   else
 462   {
 463     cint AF = GraphicData.AnimationFrames;
 464     cint F = !(BlitData.CustomData & ALLOW_ANIMATE) || AF == 1 ? 0 : GET_TICK() & (AF - 1);
 465     GraphicData.Picture[F]->AlphaLuminanceBlit(BlitData);
 466   }
 467 }
 468
 469 void lterrain::SignalRustLevelChange()
 470 {
 471   UpdatePictures();
 472   GetLSquareUnder()->SendMemorizedUpdateRequest();
 473   GetLSquareUnder()->SendNewDrawRequest();
 474 }
 475
 476 void olterrain::SignalRustLevelChange()
 477 {
 478   lterrain::SignalRustLevelChange();
 479   HP = Min(HP, CalculateMaxHP());
 480 }
 481
 482 void lterrain::TryToRust (sLong LiquidModifier) {
 483   if (MainMaterial->TryToRust(LiquidModifier*10, 10000)) {
 484     if (CanBeSeenByPlayer()) {
 485       if (MainMaterial->GetRustLevel() == NOT_RUSTED) ADD_MESSAGE("%s rusts.", CHAR_NAME(DEFINITE));
 486       else ADD_MESSAGE("%s rusts more.", CHAR_NAME(DEFINITE));
 487     }
 488     MainMaterial->SetRustLevel(MainMaterial->GetRustLevel()+1);
 489   }
 490 }
 491
 492 void olterrain::ReceiveAcid(material*, sLong Modifier)
 493 {
 494   if(GetMainMaterial()->GetInteractionFlags() & CAN_DISSOLVE)
 495   {
 496     int Damage = Modifier / 10000;
 497
 498     if(Damage)
 499     {
 500       Damage += RAND() % Damage;
 501       ReceiveDamage(0, Damage, ACID);
 502     }
 503   }
 504 }
 505
 506 void lterrain::InitMaterials(material* FirstMaterial, truth CallUpdatePictures)
 507 {
 508   InitMaterial(MainMaterial, FirstMaterial, 0);
 509   SignalVolumeAndWeightChange();
 510
 511   if(CallUpdatePictures)
 512     UpdatePictures();
 513 }
 514
 515 void lterrain::GenerateMaterials()
 516 {
 517   int Chosen = RandomizeMaterialConfiguration();
 518   const fearray<sLong>& MMC = GetMainMaterialConfig();
 519   InitMaterial(MainMaterial,
 520          MAKE_MATERIAL(MMC.Data[MMC.Size == 1 ? 0 : Chosen]),
 521          0);
 522 }
 523
 524 void glterraindatabase::InitDefaults(const glterrainprototype* NewProtoType, int NewConfig)
 525 {
 526   IsAbstract = false;
 527   ProtoType = NewProtoType;
 528   Config = NewConfig;
 529 }
 530
 531 void olterraindatabase::InitDefaults(const olterrainprototype* NewProtoType, int NewConfig)
 532 {
 533   IsAbstract = false;
 534   ProtoType = NewProtoType;
 535   Config = NewConfig;
 536 }
 537
 538 truth olterrain::ShowThingsUnder() const
 539 {
 540   return DataBase->ShowThingsUnder || IsTransparent();
 541 }
 542
 543 truth olterrain::WillBeDestroyedBy(ccharacter* Char) const
 544 {
 545   return IsWall() && CanBeDestroyed() && MainMaterial->GetStrengthValue() <= (Char->GetAttribute(ARM_STRENGTH) * 3);
 546 }
 547
 548 v2 glterrain::GetBitmapPos(int I) const
 549 {
 550   return GetBorderBitmapPos(DataBase->BitmapPos, I);
 551 }
 552
 553 v2 olterrain::GetBitmapPos(int I) const
 554 {
 555   return GetBorderBitmapPos(DataBase->BitmapPos, I);
 556 }
 557
 558 truth glterrain::IsAnimated() const
 559 {
 560   return GraphicData.AnimationFrames > (UseBorderTiles() ? 9 : 1);
 561 }
 562
 563 truth olterrain::IsAnimated() const
 564 {
 565   return GraphicData.AnimationFrames > (UseBorderTiles() ? 9 : 1);
 566 }
 567
 568 void lterrain::AddLocationDescription(festring& String) const
 569 {
 570   String << " on the " << GetNameSingular();
 571 }