src/game/lsquare.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 /* Compiled through levelset.cpp */
  13
  14 lsquare*** eyecontroller::Map;
  15
  16 lsquare*** pathcontroller::Map;
  17 ccharacter* pathcontroller::Character;
  18
  19 lsquare*** stackcontroller::Map;
  20 lsquare** stackcontroller::Stack;
  21 sLong stackcontroller::StackIndex;
  22 int stackcontroller::LevelXSize, stackcontroller::LevelYSize;
  23 v2 stackcontroller::Center;
  24
  25 feuLong tickcontroller::Tick;
  26 feuLong tickcontroller::ShiftedTick[4];
  27 feuLong tickcontroller::ShiftedQuadriTick[4];
  28
  29 void tickcontroller::PrepareShiftedTick()
  30 {
  31   for(int c = 0; c < 4; ++c)
  32   {
  33     ShiftedTick[c] = Tick << (c << 3);
  34     ShiftedQuadriTick[c] = (Tick + 1) << (c << 3);
  35   }
  36 }
  37
  38 truth lsquare::IsDipDestination() const { return GLTerrain->IsDipDestination() || (OLTerrain && OLTerrain->IsDipDestination()); }
  39
  40 lsquare::lsquare (level *LevelUnder, v2 Pos) :
  41   square(LevelUnder, Pos),
  42   Fluid(0), Smoke(0), Rain(0), Trap(0),
  43   GLTerrain(0), OLTerrain(0),
  44   Memorized(0), FowMemorized(0),
  45   Engraved(0),
  46   GroundBorderPartnerTerrain(0),
  47   GroundBorderPartnerInfo(0),
  48   OverBorderPartnerTerrain(0),
  49   OverBorderPartnerInfo(0),
  50   SquarePartEmitationTick(0),
  51   SquarePartLastSeen(0),
  52   Emitation(0),
  53   SmokeAlphaSum(0),
  54   AmbientLuminance(0),
  55   SunLightLuminance(0),
  56   TemporaryEmitation(0),
  57   SecondarySunLightEmitation(0),
  58   LastExplosionID(0),
  59   RoomIndex(0)
  60 {
  61   Stack = new stack(this, 0);
  62 }
  63
  64
  65 lsquare::~lsquare () {
  66   delete GLTerrain;
  67   delete OLTerrain;
  68   delete Stack;
  69   delete [] Engraved;
  70
  71   deleteList(Fluid);
  72
  73   delete Memorized;
  74   delete FowMemorized;
  75   delete StaticContentCache.Bitmap;
  76   delete [] GroundBorderPartnerTerrain;
  77   delete [] OverBorderPartnerTerrain;
  78
  79   deleteList(Smoke);
  80   deleteList(Rain);
  81   deleteList(Trap);
  82 }
  83
  84
  85 void lsquare::SignalEmitationIncrease (col24 EmitationUpdate) {
  86   if (game::CompareLights(EmitationUpdate, Emitation) > 0 && !game::IsGenerating() && !(Flags & FREEZED)) {
  87     CalculateEmitation(); // could this be optimized?
  88     Emitate();
  89   }
  90 }
  91
  92
  93 void lsquare::SignalEmitationDecrease (col24 EmitationUpdate) {
  94   if (game::CompareLights(EmitationUpdate, Emitation) >= 0 && Emitation && !game::IsGenerating() && !(Flags & FREEZED)) {
  95     col24 Backup = Emitation;
  96     CalculateEmitation();
  97     if (Backup != Emitation) {
  98       Noxify(Backup);
  99       Emitate(Emitation, FORCE_ADD);
 100     }
 101   }
 102 }
 103
 104
 105 void lsquare::CalculateEmitation () {
 106   Emitation = Stack->GetEmitation();
 107
 108   for (int c = 0; c < 4; ++c) {
 109     stack *Stack = GetStackOfAdjacentSquare(c);
 110     if (Stack) game::CombineLights(Emitation, Stack->GetSideEmitation(3 - c));
 111   }
 112
 113   if (Character) game::CombineLights(Emitation, Character->GetEmitation());
 114   game::CombineLights(Emitation, GLTerrain->GetEmitation());
 115   if (OLTerrain) game::CombineLights(Emitation, OLTerrain->GetEmitation());
 116   game::CombineLights(Emitation, TemporaryEmitation);
 117   for (const fluid* F = Fluid; F; F = F->Next) game::CombineLights(Emitation, F->GetEmitation());
 118   for (const rain* R = Rain; R; R = R->Next) game::CombineLights(Emitation, R->GetEmitation());
 119 }
 120
 121
 122 void lsquare::UpdateMemorized () {
 123   if (Flags&MEMORIZED_UPDATE_REQUEST) {
 124     if (!IsDark() || CanBeFeltByPlayer()) {
 125       blitdata B = { Memorized,
 126          { 0, 0 },
 127          { 0, 0 },
 128          { TILE_SIZE, TILE_SIZE },
 129          { NORMAL_LUMINANCE },
 130          TRANSPARENT_COLOR,
 131          ALLOW_ALPHA };
 132       DrawStaticContents(B);
 133       Memorized->FastBlit(FowMemorized);
 134       B.Bitmap = FowMemorized;
 135       B.Flags = 0;
 136       B.MaskColor = 0;
 137       igraph::GetFOWGraphic()->NormalMaskedBlit(B);
 138     } else {
 139       Memorized->ClearToColor(0);
 140       igraph::GetFOWGraphic()->FastBlit(FowMemorized);
 141     }
 142
 143     if (!StaticContentCache.Bitmap) {
 144       StaticContentCache.Bitmap = new bitmap(TILE_V2);
 145       StaticContentCache.Bitmap->ActivateFastFlag();
 146     }
 147
 148     UpdateStaticContentCache(Luminance);
 149     Flags &= ~MEMORIZED_UPDATE_REQUEST;
 150   }
 151 }
 152
 153
 154 void lsquare::UpdateStaticContentCache (col24 Luminance) const {
 155   blitdata B = { StaticContentCache.Bitmap,
 156      { 0, 0 },
 157      { 0, 0 },
 158      { TILE_SIZE, TILE_SIZE },
 159      { Luminance },
 160      0,
 161      0 };
 162   Memorized->LuminanceBlit(B);
 163   StaticContentCache.Luminance = Luminance;
 164 }
 165
 166
 167 void lsquare::DrawStaticContents (blitdata &BlitData) const {
 168   if ((BlitData.CustomData&ALLOW_ANIMATE) && !StaticAnimatedEntities && Memorized && !game::GetSeeWholeMapCheatMode()) {
 169     if (StaticContentCache.Luminance != BlitData.Luminance) UpdateStaticContentCache(BlitData.Luminance);
 170     StaticContentCache.Bitmap->FastBlit(BlitData.Bitmap, BlitData.Dest);
 171     return;
 172   }
 173
 174   if (!OLTerrain || OLTerrain->ShowThingsUnder()) GLTerrain->Draw(BlitData);
 175
 176   int GroundPartners = (GroundBorderPartnerInfo>>24)&15;
 177
 178   for (int c = 0; c < GroundPartners; ++c) {
 179     BlitData.CustomData |= 8-((GroundBorderPartnerInfo>>((c<<1)+c))&7);
 180     GroundBorderPartnerTerrain[c]->Draw(BlitData);
 181     BlitData.CustomData &= ~SQUARE_INDEX_MASK;
 182   }
 183
 184   truth StackDrawn = false;
 185
 186   if (OLTerrain && !IsFlyable()) {
 187     if (OLTerrain->IsTransparent() && OLTerrain->ShowThingsUnder()) {
 188       StackDrawn = true;
 189       DrawStacks(BlitData);
 190     }
 191     OLTerrain->Draw(BlitData);
 192   }
 193
 194   for (const fluid* F = Fluid; F; F = F->Next) F->SimpleDraw(BlitData);
 195   if (OLTerrain && IsFlyable()) OLTerrain->Draw(BlitData);
 196   if (!StackDrawn && Flags & IS_TRANSPARENT) DrawStacks(BlitData);
 197   for (const trap* T = Trap; T; T = T->Next) T->Draw(BlitData);
 198
 199   int OverPartners = OverBorderPartnerInfo >> 24 & 15;
 200
 201   for (int c = 0; c < OverPartners; ++c) {
 202     BlitData.CustomData |= 8-((OverBorderPartnerInfo>>((c<<1)+c))&7);
 203     OverBorderPartnerTerrain[c]->Draw(BlitData);
 204     BlitData.CustomData &= ~SQUARE_INDEX_MASK;
 205   }
 206 }
 207
 208
 209 void lsquare::Draw (blitdata& BlitData) const {
 210   if ((Flags&NEW_DRAW_REQUEST) || AnimatedEntities) {
 211     if (!IsDark() || game::GetSeeWholeMapCheatMode()) {
 212       if (game::GetSeeWholeMapCheatMode() == SHOW_MAP_IN_UNIFORM_LIGHT || (game::GetSeeWholeMapCheatMode() && !(Flags & IS_TRANSPARENT)))
 213         BlitData.Luminance = ivanconfig::GetContrastLuminance();
 214       else
 215         BlitData.Luminance = ivanconfig::ApplyContrastTo(Luminance);
 216
 217       DrawStaticContents(BlitData);
 218
 219       if (Character && (Character->CanBeSeenByPlayer() || game::GetSeeWholeMapCheatMode())) {
 220         BlitData.CustomData |= Character->GetSquareIndex(Pos);
 221
 222         if (Character->IsFlying()) {
 223           for (const smoke *S = Smoke; S; S = S->Next) S->Draw(BlitData);
 224           Character->Draw(BlitData);
 225         } else {
 226           Character->Draw(BlitData);
 227           for (const smoke *S = Smoke; S; S = S->Next) S->Draw(BlitData);
 228         }
 229         BlitData.CustomData &= ~SQUARE_INDEX_MASK;
 230       } else {
 231         for(const smoke *S = Smoke; S; S = S->Next) S->Draw(BlitData);
 232       }
 233
 234       for (const rain *R = Rain; R; R = R->Next) if (R->IsEnabled()) R->Draw(BlitData);
 235     } else if (CanBeFeltByPlayer()) {
 236       col24 L = Luminance;
 237       game::CombineLights(L, DIM_LUMINANCE);
 238       BlitData.Luminance = ivanconfig::ApplyContrastTo(L);
 239       DrawStaticContents(BlitData);
 240       for (const rain* R = Rain; R; R = R->Next) if (R->IsEnabled()) R->Draw(BlitData);
 241     } else {
 242       DOUBLE_BUFFER->Fill(BlitData.Dest, BlitData.Border, 0);
 243       if (Character && Character->CanBeSeenByPlayer()) {
 244         BlitData.CustomData |= Character->GetSquareIndex(Pos);
 245         BlitData.Luminance = ivanconfig::GetContrastLuminance();
 246         Character->Draw(BlitData);
 247         BlitData.CustomData &= ~SQUARE_INDEX_MASK;
 248       }
 249     }
 250
 251     Flags &= ~STRONG_NEW_DRAW_REQUEST;
 252   }
 253 }
 254
 255 struct emitationcontroller : public tickcontroller, public stackcontroller
 256 {
 257   static truth Handler(int x, int y)
 258   {
 259     lsquare* Square = Map[x >> 1][y >> 1];
 260     culong SquareFlags = Square->Flags;
 261
 262     if(SquareFlags & PERFECTLY_QUADRI_HANDLED)
 263       return SquareFlags & ALLOW_EMITATION_CONTINUE;
 264
 265     if(SquareFlags & IS_TRANSPARENT)
 266       return ProcessSquare(x >> 1, y >> 1, Square);
 267
 268     if(!(SquareFlags & IN_SQUARE_STACK))
 269     {
 270       Square->Flags |= IN_SQUARE_STACK;
 271       Stack[StackIndex++] = Square;
 272     }
 273
 274     cint SquarePartIndex = (x & 1) + ((y & 1) << 1);
 275     Square->SquarePartEmitationTick =
 276       (Square->SquarePartEmitationTick & ~SquarePartTickMask[SquarePartIndex]) | ShiftedTick[SquarePartIndex];
 277
 278     return false;
 279   }
 280   static int ProcessSquare(int X, int Y, lsquare* Square)
 281   {
 282     Stack[StackIndex++] = Square;
 283     culong SquareFlags = Square->Flags;
 284     cint MaxE = MaxLuxTable[X - EmitterPosXMinus16][Y - EmitterPosYMinus16];
 285
 286     if(MaxE >= LIGHT_BORDER && (SquareFlags & INSIDE || (!(ID & SECONDARY_SUN_LIGHT) && MaxE > MinNightAmbientLuminanceElement)))
 287     {
 288       Square->Flags |= ALLOW_EMITATION_CONTINUE | PERFECTLY_QUADRI_HANDLED;
 289       return true;
 290     }
 291     else
 292     {
 293       Square->Flags = (SquareFlags & ~ALLOW_EMITATION_CONTINUE) | PERFECTLY_QUADRI_HANDLED;
 294       return false;
 295     }
 296   }
 297   static feuLong& GetTickReference(int X, int Y)
 298   {
 299     return Map[X][Y]->SquarePartEmitationTick;
 300   }
 301   static void ProcessStack()
 302   {
 303     for(sLong c1 = 0; c1 < StackIndex; ++c1)
 304     {
 305       lsquare* Square = Stack[c1];
 306       culong SquareTick = Square->SquarePartEmitationTick;
 307       feuLong TempID = ID;
 308
 309       for(int c2 = 0; c2 < 4; ++c2) {
 310         if ((SquareTick & SquarePartTickMask[c2]) == ShiftedTick[c2]) {
 311           TempID |= 1 << EMITTER_SQUARE_PART_SHIFT << c2;
 312         }
 313       }
 314
 315       Square->Flags &= ~(IN_SQUARE_STACK|PERFECTLY_QUADRI_HANDLED);
 316       v2 Pos = Square->Pos;
 317       int XVal = Pos.X - EmitterPosXMinus16;
 318       int YVal = Pos.Y - EmitterPosYMinus16;
 319
 320       if (MaxLuxTable[XVal][YVal] >= LIGHT_BORDER)
 321         Square->AlterLuminance(TempID, MakeRGB24(RedLuxTable[XVal][YVal], GreenLuxTable[XVal][YVal], BlueLuxTable[XVal][YVal]));
 322     }
 323   }
 324   static feuLong ID;
 325   static int MinNightAmbientLuminanceElement;
 326   static int EmitterPosXMinus16;
 327   static int EmitterPosYMinus16;
 328   static uChar** MaxLuxTable;
 329   static uChar** RedLuxTable;
 330   static uChar** GreenLuxTable;
 331   static uChar** BlueLuxTable;
 332 };
 333
 334 feuLong emitationcontroller::ID;
 335 int emitationcontroller::MinNightAmbientLuminanceElement;
 336 int emitationcontroller::EmitterPosXMinus16;
 337 int emitationcontroller::EmitterPosYMinus16;
 338 uChar** emitationcontroller::MaxLuxTable;
 339 uChar** emitationcontroller::RedLuxTable;
 340 uChar** emitationcontroller::GreenLuxTable;
 341 uChar** emitationcontroller::BlueLuxTable;
 342
 343 void lsquare::Emitate(col24 Emitation, feuLong IDFlags)
 344 {
 345   if(game::IsDark(Emitation))
 346     return;
 347
 348   int Radius = game::CalculateMinimumEmitationRadius(Emitation);
 349
 350   if(!Radius)
 351     return;
 352
 353   stackcontroller::Map = GetLevel()->GetMap();
 354   stackcontroller::Stack = GetLevel()->GetSquareStack();
 355   stackcontroller::StackIndex = 0;
 356   tickcontroller::Tick = game::IncreaseSquarePartEmitationTicks();
 357   tickcontroller::PrepareShiftedTick();
 358   emitationcontroller::ID = MakeEmitterID(Pos) | IDFlags;
 359   emitationcontroller::MinNightAmbientLuminanceElement = GetMinColor24(GetLevel()->GetNightAmbientLuminance());
 360   emitationcontroller::EmitterPosXMinus16 = Pos.X - 16;
 361   emitationcontroller::EmitterPosYMinus16 = Pos.Y - 16;
 362   emitationcontroller::MaxLuxTable = game::GetLuxTable()[GetMaxColor24(Emitation)];
 363   emitationcontroller::RedLuxTable = game::GetLuxTable()[GetRed24(Emitation)];
 364   emitationcontroller::GreenLuxTable = game::GetLuxTable()[GetGreen24(Emitation)];
 365   emitationcontroller::BlueLuxTable = game::GetLuxTable()[GetBlue24(Emitation)];
 366   mapmath<emitationcontroller>::DoQuadriArea(Pos.X, Pos.Y,
 367                Radius * Radius,
 368                GetLevel()->GetXSize(),
 369                GetLevel()->GetYSize());
 370   emitationcontroller::ProcessStack();
 371 }
 372
 373 struct noxifycontroller : public stackcontroller
 374 {
 375   static truth Handler(int x, int y)
 376   {
 377     if(x >= 0 && y >= 0 && x < LevelXSize && y < LevelYSize)
 378     {
 379       lsquare* Square = Map[x][y];
 380
 381       if(Square->SquarePartEmitationTick != Tick)
 382       {
 383         Square->SquarePartEmitationTick = Tick;
 384         return Square->NoxifyEmitter(ID);
 385       }
 386     }
 387
 388     return false;
 389   }
 390   static int GetStartX(int) { return Center.X; }
 391   static int GetStartY(int) { return Center.Y; }
 392   static feuLong ID;
 393   static feuLong Tick;
 394 };
 395
 396 feuLong noxifycontroller::ID;
 397 feuLong noxifycontroller::Tick;
 398
 399 void lsquare::Noxify(col24 Emitation, feuLong IDFlags)
 400 {
 401   if(game::IsDark(Emitation))
 402     return;
 403
 404   int Radius = game::CalculateMinimumEmitationRadius(Emitation);
 405
 406   if(!Radius)
 407     return;
 408
 409   stackcontroller::Map = GetLevel()->GetMap();
 410   stackcontroller::LevelXSize = GetLevel()->GetXSize();
 411   stackcontroller::LevelYSize = GetLevel()->GetYSize();
 412   stackcontroller::Center = Pos;
 413   noxifycontroller::ID = MakeEmitterID(Pos) | IDFlags;
 414   noxifycontroller::Tick = game::IncreaseSquarePartEmitationTicks();
 415   NoxifyEmitter(noxifycontroller::ID);
 416   mapmath<noxifycontroller>::DoArea();
 417 }
 418
 419 truth lsquare::NoxifyEmitter(feuLong ID)
 420 {
 421   emittervector::iterator i, End = Emitter.end();
 422
 423   for(i = Emitter.begin(); i != End; ++i)
 424     if(!((i->ID ^ ID) & (EMITTER_IDENTIFIER_BITS|SECONDARY_SUN_LIGHT)))
 425     {
 426       RemoveLuminance(i->Emitation);
 427       Swap(*i, Emitter.back());
 428       Emitter.pop_back();
 429       return true;
 430     }
 431
 432   return false;
 433 }
 434
 435 void lsquare::AlterLuminance(feuLong ID, col24 NewLuminance)
 436 {
 437   emittervector::iterator i, End = Emitter.end();
 438
 439   if(!(ID & FORCE_ADD))
 440     for(i = Emitter.begin(); i != End; ++i)
 441       if(!((i->ID ^ ID) & (EMITTER_IDENTIFIER_BITS|SECONDARY_SUN_LIGHT)))
 442       {
 443         i->ID |= ID;
 444
 445         if(i->Emitation != NewLuminance)
 446           ChangeLuminance(i->Emitation, NewLuminance);
 447
 448         return;
 449       }
 450
 451   Emitter.push_back(emitter(ID, 0));
 452   ChangeLuminance(Emitter.back().Emitation, NewLuminance);
 453 }
 454
 455 void lsquare::AddSunLightEmitter(feuLong ID)
 456 {
 457   sunemittervector::iterator i, End = SunEmitter.end();
 458
 459   for(i = SunEmitter.begin(); i != End; ++i)
 460     if(!((*i ^ ID) & EMITTER_IDENTIFIER_BITS))
 461     {
 462       if(ID & ~*i & RE_SUN_EMITATED) *i &= ~EMITTER_SHADOW_BITS;
 463
 464       *i |= ID;
 465       Swap(*i, SunEmitter.front());
 466       return;
 467     }
 468
 469   SunEmitter.push_back(ID);
 470 }
 471
 472 truth lsquare::Open(character* Opener)
 473 {
 474   return GetStack()->Open(Opener) || (OLTerrain && OLTerrain->Open(Opener));
 475 }
 476
 477 truth lsquare::Close(character* Closer)
 478 {
 479   if(!GetStack()->GetItems() && !Character)
 480     return OLTerrain && OLTerrain->Close(Closer);
 481   else
 482   {
 483     ADD_MESSAGE("There's something in the way...");
 484     return false;
 485   }
 486 }
 487
 488 void lsquare::Save(outputfile& SaveFile) const
 489 {
 490   Stack->Save(SaveFile); // This must be before square::Save! (Note: This comment is years old. It's probably obsolete)
 491   square::Save(SaveFile);
 492   SaveFile << mGoSeen;
 493   SaveFile << GLTerrain << OLTerrain;
 494   SaveFile << Emitter << SunEmitter;
 495   SaveFile << Emitation << Engraved << Luminance;
 496   SaveFile << SmokeAlphaSum << (uChar)Flags << Memorized;
 497   SaveFile << SecondarySunLightEmitation;
 498   SaveFile << (uChar)RoomIndex;
 499   SaveFile << SunLightLuminance;
 500   SaveLinkedList(SaveFile, Fluid);
 501   SaveLinkedList(SaveFile, Smoke);
 502   SaveLinkedList(SaveFile, Rain);
 503   SaveLinkedList(SaveFile, Trap);
 504 }
 505
 506 void lsquare::Load(inputfile& SaveFile)
 507 {
 508   Stack->Load(SaveFile); // This must be before square::Load! (Note: This comment is years old. It's probably obsolete)
 509   Stack->SetMotherSquare(this);
 510   square::Load(SaveFile);
 511   SaveFile >> mGoSeen;
 512   SaveFile >> GLTerrain >> OLTerrain;
 513   SaveFile >> Emitter >> SunEmitter;
 514   SaveFile >> Emitation >> Engraved >> Luminance;
 515   SaveFile >> SmokeAlphaSum >> (uChar&)Flags >> Memorized;
 516   Flags &= INSIDE|DESCRIPTION_CHANGE; //only these flags are loaded
 517   Flags |= MEMORIZED_UPDATE_REQUEST;
 518   SecondarySunLightEmitation = ReadType(col24, SaveFile);
 519   RoomIndex = ReadType(uChar, SaveFile);
 520   SunLightLuminance = ReadType(col24, SaveFile);
 521   LoadLinkedList(SaveFile, Fluid);
 522   LoadLinkedList(SaveFile, Smoke);
 523   LoadLinkedList(SaveFile, Rain);
 524   LoadLinkedList(SaveFile, Trap);
 525   CalculateIsTransparent();
 526
 527   if (Memorized) {
 528     FowMemorized = new bitmap(TILE_V2);
 529     FowMemorized->ActivateFastFlag();
 530     Memorized->FastBlit(FowMemorized);
 531     blitdata B = { FowMemorized,
 532        { 0, 0 },
 533        { 0, 0 },
 534        { TILE_SIZE, TILE_SIZE },
 535        { 0 },
 536        0,
 537        0 };
 538
 539     igraph::GetFOWGraphic()->NormalMaskedBlit(B);
 540   }
 541 }
 542
 543 void lsquare::CalculateLuminance()
 544 {
 545   Luminance = AmbientLuminance;
 546   emittervector::const_iterator i, End = Emitter.end();
 547
 548   if(Flags & IS_TRANSPARENT)
 549   {
 550     game::CombineLights(Luminance, SunLightLuminance);
 551
 552     for(i = Emitter.begin(); i != End; ++i)
 553       game::CombineLights(Luminance, i->Emitation);
 554   }
 555   else
 556   {
 557     feuLong BitMask = 0, LOSTick = game::GetLOSTick();
 558
 559     for(int c = 0; c < 4; ++c)
 560       if((SquarePartLastSeen >> (c << 3) & 0xFF) >= LOSTick)
 561         BitMask |= 1 << EMITTER_SQUARE_PART_SHIFT << c;
 562
 563     CalculateSunLightLuminance(BitMask);
 564     game::CombineLights(Luminance, SunLightLuminance);
 565
 566     for(i = Emitter.begin(); i != End; ++i)
 567       if(BitMask & i->ID) game::CombineLights(Luminance, i->Emitation);
 568   }
 569 }
 570
 571 void lsquare::AddCharacter(character* Guy)
 572 {
 573   if(Character)
 574     ABORT("Overgrowth of square population detected!");
 575
 576   Character = Guy;
 577   SignalEmitationIncrease(Guy->GetEmitation());
 578   Flags |= STRONG_NEW_DRAW_REQUEST;
 579
 580   if (Guy->IsAnimated()) IncAnimatedEntities();
 581
 582   SignalPossibleTransparencyChange();
 583
 584   if (Guy->IsPlayer() || (Guy->CanBeSeenByPlayer(true) && CanBeSeenByPlayer())) {
 585     Guy->SignalSeen();
 586   }
 587 }
 588
 589 void lsquare::Clean()
 590 {
 591   GetStack()->Clean();
 592 }
 593
 594 void lsquare::RemoveCharacter()
 595 {
 596   if(Character)
 597   {
 598     character* Backup = Character;
 599
 600     if(Backup->IsAnimated())
 601       DecAnimatedEntities();
 602
 603     Character = 0;
 604     SignalEmitationDecrease(Backup->GetEmitation());
 605     Flags |= STRONG_NEW_DRAW_REQUEST;
 606     SignalPossibleTransparencyChange();
 607   }
 608 }
 609
 610
 611 void lsquare::UpdateMemorizedDescription (truth Cheat) {
 612   if ((Flags & DESCRIPTION_CHANGE) || Cheat) {
 613     if (!IsDark() || Cheat) {
 614       MemorizedDescription.Empty();
 615
 616       if (!OLTerrain || (OLTerrain->IsTransparent() && OLTerrain->ShowThingsUnder() && !OLTerrain->IsWall())) {
 617         truth Anything = false;
 618
 619         if (OLTerrain && OLTerrain->GetNameSingular().GetSize()) {
 620           OLTerrain->AddName(MemorizedDescription, INDEFINITE);
 621           Anything = true;
 622         }
 623
 624         if (Flags & IS_TRANSPARENT) {
 625           itemvectorvector PileVector;
 626           GetStack()->Pile(PileVector, PLAYER, CENTER);
 627
 628           if (PileVector.size()) {
 629             if (Anything) MemorizedDescription << " and ";
 630
 631             if (PileVector.size() == 1)
 632               PileVector[0][0]->AddName(MemorizedDescription, INDEFINITE, PileVector[0].size());
 633             else
 634               MemorizedDescription << "many items";
 635
 636             MemorizedDescription << " on ";
 637             Anything = true;
 638           } else if (Anything) {
 639             MemorizedDescription << " on ";
 640           }
 641
 642           GLTerrain->AddName(MemorizedDescription, INDEFINITE);
 643           festring SideItems;
 644           GetSideItemDescription(SideItems, Cheat);
 645
 646           if (!SideItems.IsEmpty()) MemorizedDescription << " and " << SideItems;
 647         } else {
 648           if (Anything) MemorizedDescription << " on ";
 649
 650           GLTerrain->AddName(MemorizedDescription, INDEFINITE);
 651         }
 652       } else {
 653         OLTerrain->AddName(MemorizedDescription, INDEFINITE);
 654       }
 655
 656       if (FluidIsVisible()) DisplayFluidInfo(MemorizedDescription);
 657
 658       DisplayTrapInfo(MemorizedDescription);
 659
 660       if (Cheat) MemorizedDescription << " (pos " << Pos.X << ':' << Pos.Y << ")";
 661     } else if (CanBeFeltByPlayer()) {
 662       MemorizedDescription.Empty();
 663       OLTerrain->AddName(MemorizedDescription, INDEFINITE);
 664
 665       if (FluidIsVisible()) DisplayFluidInfo(MemorizedDescription);
 666
 667       DisplayTrapInfo(MemorizedDescription);
 668     } else {
 669       MemorizedDescription = CONST_S("darkness");
 670     }
 671
 672     Flags &= ~DESCRIPTION_CHANGE;
 673   }
 674 }
 675
 676 void lsquare::GetSideItemDescription(festring& String, truth Cheat) const
 677 {
 678   int Items = 0;
 679
 680   for(int c = 0; c < 4; ++c)
 681   {
 682     stack* Stack = GetStackOfAdjacentSquare(c);
 683
 684     if(Stack)
 685       Items += Cheat
 686          ? Stack->GetSideItems(3 - c)
 687          : Stack->GetVisibleSideItems(PLAYER, 3 - c);
 688   }
 689
 690   if(Items > 1)
 691     String << "many items on the wall";
 692   else if(Items == 1)
 693   {
 694     for(int c = 0; c < 4; ++c)
 695     {
 696       stack* Stack = GetStackOfAdjacentSquare(c);
 697
 698       if (Stack && ((Cheat && Stack->GetSideItems(3 - c)) || (!Cheat && Stack->GetVisibleSideItems(PLAYER, 3 - c))))
 699         Stack->GetBottomSideItem(PLAYER, 3 - c, Cheat)->AddName(String, INDEFINITE);
 700     }
 701
 702     String << " on the wall";
 703   }
 704 }
 705
 706 truth lsquare::BeKicked(character* Kicker, item* Boot, bodypart* Leg, double KickDamage, double KickToHitValue, int Success, int Direction, truth Critical, truth ForceHit)
 707 {
 708   truth Return;
 709
 710   if(GetCharacter())
 711   {
 712     GetCharacter()->BeKicked(Kicker, Boot, Leg, Pos, KickDamage, KickToHitValue, Success, Direction, Critical, ForceHit);
 713     Return = true;
 714   }
 715   else
 716     Return = false;
 717
 718   if(RoomIndex)
 719     GetLevel()->GetRoom(RoomIndex)->KickSquare(Kicker, this);
 720
 721   GetStack()->BeKicked(Kicker, int(KickDamage), Direction);
 722
 723   if(GetOLTerrain())
 724     GetOLTerrain()->BeKicked(Kicker, int(KickDamage * (100 + Success) / 100), Direction);
 725
 726   return Return;
 727 }
 728
 729 truth lsquare::CanBeDug() const
 730 {
 731   if((!GetPos().X || !GetPos().Y || GetPos().X == GetLevel()->GetXSize() - 1 || GetPos().Y == GetLevel()->GetYSize() - 1) && !*GetLevel()->GetLevelScript()->IsOnGround())
 732   {
 733     ADD_MESSAGE("Somehow you feel that by digging this square you would collapse the whole dungeon.");
 734     return false;
 735   }
 736   else
 737     return true;
 738 }
 739
 740 void lsquare::ChangeLTerrain(glterrain* NewGround, olterrain* NewOver)
 741 {
 742   ChangeGLTerrain(NewGround);
 743   ChangeOLTerrain(NewOver);
 744 }
 745
 746 void lsquare::ChangeGLTerrain(glterrain* NewGround)
 747 {
 748   if(GLTerrain->IsAnimated())
 749     DecStaticAnimatedEntities();
 750
 751   truth WasUsingBorderTiles = GLTerrain->UseBorderTiles();
 752   delete GLTerrain;
 753   GLTerrain = NewGround;
 754   NewGround->SetLSquareUnder(this);
 755   Flags |= NEW_DRAW_REQUEST;
 756   GetLevel()->SetWalkability(Pos, GetTheoreticalWalkability());
 757   CalculateGroundBorderPartners();
 758   SendMemorizedUpdateRequest();
 759
 760   if(WasUsingBorderTiles || NewGround->UseBorderTiles())
 761     RequestForGroundBorderPartnerUpdates();
 762
 763   if(NewGround->IsAnimated())
 764     IncStaticAnimatedEntities();
 765 }
 766
 767 void lsquare::ChangeOLTerrain(olterrain* NewOver)
 768 {
 769   if(OLTerrain && OLTerrain->IsAnimated())
 770     DecStaticAnimatedEntities();
 771
 772   truth WasUsingBorderTiles = OLTerrain && OLTerrain->UseBorderTiles();
 773   delete OLTerrain;
 774   OLTerrain = NewOver;
 775   Flags |= NEW_DRAW_REQUEST;
 776   GetLevel()->SetWalkability(Pos, GetTheoreticalWalkability());
 777   CalculateOverBorderPartners();
 778   CalculateIsTransparent();
 779   SendMemorizedUpdateRequest();
 780
 781   if(WasUsingBorderTiles || (NewOver && NewOver->UseBorderTiles()))
 782     RequestForOverBorderPartnerUpdates();
 783
 784   if(NewOver)
 785   {
 786     NewOver->SetLSquareUnder(this);
 787
 788     if(NewOver->IsAnimated())
 789       IncStaticAnimatedEntities();
 790   }
 791 }
 792
 793 void lsquare::SetLTerrain(glterrain* NewGround, olterrain* NewOver)
 794 {
 795   GLTerrain = NewGround;
 796   NewGround->SetLSquareUnder(this);
 797
 798   if(NewGround->IsAnimated())
 799     IncStaticAnimatedEntities();
 800
 801   OLTerrain = NewOver;
 802
 803   if(NewOver)
 804   {
 805     NewOver->SetLSquareUnder(this);
 806
 807     if(NewOver->IsAnimated())
 808       IncStaticAnimatedEntities();
 809
 810     if(!NewOver->IsTransparent())
 811       Flags &= ~IS_TRANSPARENT;
 812   }
 813
 814   GetLevel()->SetWalkability(Pos, GetTheoreticalWalkability());
 815 }
 816
 817
 818 void lsquare::ApplyScript (const squarescript *SquareScript, room *Room) {
 819   if (SquareScript->AttachRequired()) GetLevel()->AddToAttachQueue(Pos);
 820   //
 821   int EntryIndex = SquareScript->GetEntryIndex();
 822   //
 823   if (EntryIndex != NO_ENTRY) GetLevel()->SetEntryPos(EntryIndex, Pos);
 824   //
 825   const contentscript<character> *CharacterScript = SquareScript->GetCharacter();
 826   //
 827   if (CharacterScript) {
 828     character *Char = CharacterScript->Instantiate();
 829     //
 830     if (Char) {
 831       Char->SetGenerationDanger(GetLevel()->GetDifficulty());
 832       if (!Char->GetTeam()) Char->SetTeam(game::GetTeam(*GetLevel()->GetLevelScript()->GetTeamDefault()));
 833       if (CharacterScript->GetFlags() & IS_LEADER) Char->GetTeam()->SetLeader(Char);
 834       Char->PutToOrNear(Pos);
 835       Char->CreateHomeData();
 836       if (Room && CharacterScript->GetFlags() & IS_MASTER) Room->SetMasterID(Char->GetID());
 837     }
 838   }
 839   //
 840   const fearray<contentscript<item> >* Items = SquareScript->GetItems();
 841   //
 842   if (Items) {
 843     for (uInt c1 = 0; c1 < Items->Size; ++c1) {
 844       const interval *TimesPtr = Items->Data[c1].GetTimes();
 845       int Times = TimesPtr ? TimesPtr->Randomize() : 1;
 846       //
 847       for (int c2 = 0; c2 < Times; ++c2) {
 848         item *Item = Items->Data[c1].Instantiate();
 849         //
 850         if (Item) {
 851           int SquarePosition = Items->Data[c1].GetSquarePosition();
 852           //
 853           if (SquarePosition != CENTER) Item->SignalSquarePositionChange(SquarePosition);
 854           GetStack()->AddItem(Item);
 855           Item->SpecialGenerationHandler();
 856         }
 857       }
 858     }
 859   }
 860   //
 861   const contentscript<glterrain> *GLTerrainScript = SquareScript->GetGTerrain();
 862   //
 863   if (GLTerrainScript) {
 864     GetLevel()->AddFlag(Pos, FORBIDDEN);
 865     ChangeGLTerrain(GLTerrainScript->Instantiate());
 866     //
 867     if (GLTerrainScript->IsInside()) {
 868       if (*GLTerrainScript->IsInside()) Flags |= INSIDE; else Flags &= ~INSIDE;
 869     }
 870   }
 871   //
 872   const contentscript<olterrain> *OLTerrainScript = SquareScript->GetOTerrain();
 873   //
 874   if (OLTerrainScript) {
 875     olterrain *terra = OLTerrainScript->Instantiate();
 876     //
 877     if (terra) {
 878       GetLevel()->AddFlag(Pos, FORBIDDEN);
 879       // check for random altars
 880       if (terra->AcceptsOffers()) {
 881         //FIXME: make IsAltar()? for now only altars can accept offers
 882         if (Room->GetDivineMaster()) {
 883           //if (Terrain->GetConfig() != RoomClass->GetDivineMaster()) ABORT("Random altar in room with DivineMaster!");
 884           if (terra->GetConfig() != Room->GetDivineMaster()) {
 885             // force altar type
 886             fprintf(stderr, "forced altar!\n");
 887             delete terra;
 888             terra = altar::Spawn(Room->GetDivineMaster());
 889           }
 890         } else {
 891           // no DivineMaster yet, assign it
 892           const fearray<int> *am = Room->GetScript()->GetAllowedDivineMasters();
 893           //
 894           if (am && am->Size > 0) {
 895             int Owner = am->GetRandomElement();
 896             //
 897             /*
 898             fprintf(stderr, "AllowedDivineMasters:");
 899             for (uInt f = 0; f < am->Size; ++f) fprintf(stderr, " %d", (*am)[f]);
 900             fprintf(stderr, "\n");
 901             */
 902             //
 903             if (Owner < 1 || Owner > GODS) ABORT("Your god is a bad god!");
 904             //
 905             if (terra->GetConfig() != Owner) {
 906               fprintf(stderr, "recreating altar %d --> %d\n", terra->GetConfig(), Owner);
 907               delete terra;
 908               terra = altar::Spawn(Owner);
 909             } else {
 910               fprintf(stderr, "spawned altar in room w/o divine master, assigning %d\n", terra->GetConfig());
 911             }
 912           } else {
 913             fprintf(stderr, "spawned altar in room w/o divine master, assigning %d\n", terra->GetConfig());
 914           }
 915           Room->SetDivineMaster(terra->GetConfig());
 916         }
 917       }
 918       //
 919       ChangeOLTerrain(terra);
 920     } else {
 921       //fprintf(stderr, "WARNING: LTerra spawn error [lsquare] in file %s, line %d\n", OLTerrainScript->GetSrcFile().CStr(), OLTerrainScript->GetSrcLine());
 922       ChangeOLTerrain(0);
 923     }
 924   }
 925 }
 926
 927
 928 truth lsquare::CanBeSeenByPlayer (truth IgnoreDarkness) const {
 929   return ((IgnoreDarkness || !IsDark()) && LastSeen == game::GetLOSTick());
 930 }
 931
 932
 933 truth lsquare::CanBeSeenFrom (v2 FromPos, sLong MaxDistance, truth IgnoreDarkness) const {
 934   if ((Pos-FromPos).GetLengthSquare() <= MaxDistance && (IgnoreDarkness || !IsDark())) {
 935     if (Character && Character->IsPlayer() && GetNearLSquare(FromPos)->CanBeSeenByPlayer(true)) {
 936       return true;
 937     }
 938     eyecontroller::Map = GetLevel()->GetMap();
 939     return mapmath<eyecontroller>::DoLine(FromPos.X, FromPos.Y, GetPos().X, GetPos().Y, SKIP_FIRST|LINE_BOTH_DIRS);
 940   }
 941   return false;
 942 }
 943
 944
 945 void lsquare::StepOn (character* Stepper, lsquare** ComingFrom) {
 946   if (RoomIndex) {
 947     truth WasInRoom = false;
 948
 949     if (ComingFrom) {
 950       for (int c = 0; c < Stepper->GetSquaresUnder(); ++c) {
 951         if (ComingFrom[c]->GetRoomIndex() == RoomIndex) {
 952           WasInRoom = true;
 953           break;
 954         }
 955       }
 956     }
 957
 958     if (!WasInRoom) GetLevel()->GetRoom(RoomIndex)->Enter(Stepper);
 959   }
 960
 961   GLTerrain->StepOn(Stepper);
 962
 963   if (OLTerrain) {
 964     OLTerrain->StepOn(Stepper);
 965
 966     if (Stepper->DestroysWalls() && OLTerrain->WillBeDestroyedBy(Stepper)) {
 967       if (CanBeSeenByPlayer()) ADD_MESSAGE("%s destroys %s.", Stepper->CHAR_NAME(DEFINITE), OLTerrain->CHAR_NAME(DEFINITE));
 968
 969       Stepper->EditAP(-100);
 970       OLTerrain->BeDestroyed();
 971     }
 972   }
 973
 974   uInt c;
 975   std::vector<trap*> TrapVector;
 976
 977   for (trap* T = Trap; T; T = T->Next) TrapVector.push_back(T);
 978
 979   for (c = 0; c < TrapVector.size(); ++c) {
 980     if (TrapVector[c]->Exists()) {
 981       TrapVector[c]->StepOnEffect(Stepper);
 982       if (!Stepper->IsEnabled()) return;
 983     }
 984   }
 985
 986   if (!Stepper->IsFlying()) {
 987     std::vector<fluid*> FluidVector;
 988
 989     for (fluid* F = Fluid; F; F = F->Next) FluidVector.push_back(F);
 990
 991     for (c = 0; c < FluidVector.size(); ++c) {
 992       if (FluidVector[c]->Exists()) {
 993         FluidVector[c]->StepOnEffect(Stepper);
 994         if (!Stepper->IsEnabled()) return;
 995       }
 996     }
 997
 998     GetStack()->CheckForStepOnEffect(Stepper);
 999   }
1000 }
1001
1002
1003 void lsquare::ReceiveVomit (character *Who, liquid *Liquid) {
1004   if (!GetOLTerrain() || !GetOLTerrain()->ReceiveVomit(Who, Liquid)) {
1005     SpillFluid(Who, Liquid);
1006     if (RoomIndex) GetRoom()->ReceiveVomit(Who);
1007   }
1008 }
1009
1010
1011 void lsquare::SetTemporaryEmitation (col24 What) {
1012   col24 Old = TemporaryEmitation;
1013   TemporaryEmitation = 0;
1014   SignalEmitationDecrease(Old);
1015   TemporaryEmitation = What;
1016   SignalEmitationIncrease(What);
1017 }
1018
1019
1020 void lsquare::ChangeOLTerrainAndUpdateLights(olterrain* NewTerrain)
1021 {
1022   truth WasTransparent = Flags & IS_TRANSPARENT, Noxified = false;
1023   emittervector EmitterBackup;
1024
1025   if(WasTransparent && NewTerrain && !NewTerrain->IsTransparent())
1026   {
1027     EmitterBackup = Emitter;
1028     GetLevel()->ForceEmitterNoxify(EmitterBackup);
1029     Noxified = true;
1030   }
1031
1032   sLong OldEmit = OLTerrain ? OLTerrain->GetEmitation() : 0;
1033   ChangeOLTerrain(NewTerrain);
1034
1035   if(NewTerrain)
1036     SignalEmitationIncrease(NewTerrain->GetEmitation());
1037
1038   SignalEmitationDecrease(OldEmit);
1039   GetStack()->DropSideItems();
1040
1041   if(!IsFlyable() && Smoke)
1042   {
1043     DecAnimatedEntities();
1044
1045     for(smoke* S = Smoke; S; S = S->Next)
1046       S->SendToHell();
1047
1048     Smoke = 0;
1049     SmokeAlphaSum = 0;
1050   }
1051
1052   if(!WasTransparent == !!CalculateIsTransparent())
1053   {
1054     if(Noxified)
1055       GetLevel()->ForceEmitterEmitation(EmitterBackup, SunEmitter, FORCE_ADD);
1056     else
1057       GetLevel()->ForceEmitterEmitation(Emitter, SunEmitter);
1058
1059     CalculateLuminance();
1060
1061     if(LastSeen == game::GetLOSTick())
1062       game::SendLOSUpdateRequest();
1063   }
1064 }
1065
1066 void lsquare::DrawParticles(sLong Color, truth DrawHere)
1067 {
1068   if(GetPos().X < game::GetCamera().X
1069      || GetPos().Y < game::GetCamera().Y
1070      || GetPos().X >= game::GetCamera().X + game::GetScreenXSize()
1071      || GetPos().Y >= game::GetCamera().Y + game::GetScreenYSize()
1072      || !CanBeSeenByPlayer(true)
1073      || Color == TRANSPARENT_COLOR)
1074     return;
1075
1076   clock_t StartTime = clock();
1077
1078   if(DrawHere)
1079     game::DrawEverythingNoBlit();
1080
1081   if(Color & RANDOM_COLOR)
1082     Color = MakeRGB16(60 + RAND() % 190, 60 + RAND() % 190, 60 + RAND() % 190);
1083
1084   v2 Pos = game::CalculateScreenCoordinates(GetPos());
1085
1086   for(int c = 0; c < 10; ++c)
1087     DOUBLE_BUFFER->PutPixel(Pos + v2(1 + RAND() % 14, 1 + RAND() % 14), Color);
1088
1089   Flags |= STRONG_NEW_DRAW_REQUEST; // Clean the pixels from the screen afterwards
1090
1091   if(DrawHere)
1092   {
1093     graphics::BlitDBToScreen();
1094     while(clock() - StartTime < 0.02 * CLOCKS_PER_SEC);
1095   }
1096 }
1097
1098 truth lsquare::DipInto(item* Thingy, character* Dipper)
1099 {
1100   if(IsDipDestination())
1101   {
1102     room* Room = GetRoom();
1103
1104     if(Room && Room->HasDipHandler() && !Room->Dip(Dipper))
1105       return false;
1106
1107     return (GLTerrain->IsDipDestination() && GLTerrain->DipInto(Thingy, Dipper)) || (OLTerrain && OLTerrain->IsDipDestination() && OLTerrain->DipInto(Thingy, Dipper));
1108   }
1109   else
1110   {
1111     if(Dipper->IsPlayer())
1112       ADD_MESSAGE("You cannot dip %s on that square!", Thingy->CHAR_NAME(DEFINITE));
1113
1114     return false;
1115   }
1116 }
1117
1118 // return true if key fits someplace
1119
1120 truth lsquare::TryKey(item* Key, character* Applier)
1121 {
1122   if(GetOLTerrain() && GetOLTerrain()->TryKey(Key, Applier))
1123     return true;
1124
1125   if((!GetOLTerrain() || !GetOLTerrain()->HasKeyHole()) && !GetStack()->TryKey(Key, Applier))
1126   {
1127     ADD_MESSAGE("There's no place here to put the key in!");
1128     return false;
1129   }
1130
1131   return true;
1132 }
1133
1134 void lsquare::SignalSeen(feuLong Tick)
1135 {
1136   if(LastSeen < Tick - 2)
1137     Flags |= STRONG_NEW_DRAW_REQUEST;
1138
1139   Flags &= ~(IN_SQUARE_STACK|PERFECTLY_QUADRI_HANDLED);
1140   LastSeen = Tick;
1141
1142   if(!(Flags & IS_TRANSPARENT))
1143   {
1144     col24 OldLuminance = Luminance;
1145     CalculateLuminance();
1146
1147     if(OldLuminance != Luminance)
1148     {
1149       Flags |= NEW_DRAW_REQUEST;
1150
1151       if (IsDark() != game::IsDark(OldLuminance))
1152         Flags |= MEMORIZED_UPDATE_REQUEST|DESCRIPTION_CHANGE;
1153     }
1154   }
1155
1156   if(IsDark())
1157   {
1158     v2 Dist = Pos - PLAYER->GetPos();
1159
1160     if(abs(Dist.X) > 1 || abs(Dist.Y) > 1)
1161     {
1162       LastSeen -= 2;
1163       return;
1164     }
1165   }
1166
1167   if(!Memorized)
1168     CreateMemorized();
1169
1170   UpdateMemorized();
1171   UpdateMemorizedDescription();
1172
1173   if(Character)
1174     Character->CheckIfSeen();
1175 }
1176
1177
1178 #define DIMMED_LUMINANCE  0x656565
1179
1180 void lsquare::DrawMemorized (blitdata &BlitData) const {
1181   LastSeen = 0;
1182   Flags &= ~STRONG_NEW_DRAW_REQUEST;
1183   BlitData.Luminance = ivanconfig::GetContrastLuminance();
1184
1185   if (FowMemorized) {
1186     blitdata nbd = BlitData;
1187     if (nbd.Luminance == NORMAL_LUMINANCE) nbd.Luminance = DIMMED_LUMINANCE;
1188     FowMemorized->LuminanceBlit(nbd);
1189   } else {
1190     DOUBLE_BUFFER->Fill(BlitData.Dest, BlitData.Border, 0);
1191   }
1192
1193   ccharacter *C = Character;
1194
1195   if (C && C->CanBeSeenByPlayer()) {
1196     BlitData.CustomData |= C->GetSquareIndex(Pos);
1197     C->Draw(BlitData);
1198     BlitData.CustomData &= ~SQUARE_INDEX_MASK;
1199   }
1200 }
1201
1202
1203 void lsquare::DrawMemorizedCharacter (blitdata &BlitData) const {
1204   BlitData.Luminance = ivanconfig::GetContrastLuminance();
1205
1206   if (FowMemorized) {
1207     blitdata nbd = BlitData;
1208     if (nbd.Luminance == NORMAL_LUMINANCE) nbd.Luminance = DIMMED_LUMINANCE;
1209     FowMemorized->LuminanceBlit(nbd);
1210   } else {
1211     DOUBLE_BUFFER->Fill(BlitData.Dest, BlitData.Border, 0);
1212   }
1213
1214   BlitData.CustomData |= Character->GetSquareIndex(Pos);
1215   Character->Draw(BlitData);
1216   BlitData.CustomData &= ~SQUARE_INDEX_MASK;
1217   Flags |= STRONG_NEW_DRAW_REQUEST;
1218 }
1219
1220
1221 truth lsquare::IsDangerous(ccharacter* Who) const
1222 {
1223   return
1224     ((!Who->IsFlying() && (Stack->IsDangerous(Who) || HasDangerousFluids(Who))) ||
1225      IsDangerousToBreathe(Who) || HasDangerousTraps(Who));
1226 }
1227
1228 truth lsquare::IsScary(ccharacter* Who) const
1229 {
1230   return IsScaryToBreathe(Who);
1231 }
1232
1233 stack* lsquare::GetStackOfAdjacentSquare(int I) const
1234 {
1235   lsquare* Square = 0;
1236
1237        if (I == LEFT)  Square = NeighbourLSquare[3];
1238   else if (I == DOWN)  Square = NeighbourLSquare[6];
1239   else if (I == UP)    Square = NeighbourLSquare[1];
1240   else if (I == RIGHT) Square = NeighbourLSquare[4];
1241
1242   return (Square ? Square->Stack : 0);
1243 }
1244
1245 void lsquare::SendMemorizedUpdateRequest()
1246 {
1247   if(!(Flags & FREEZED))
1248   {
1249     Flags |= MEMORIZED_UPDATE_REQUEST|DESCRIPTION_CHANGE;
1250
1251     if(!game::IsGenerating() && (CanBeSeenByPlayer() || CanBeFeltByPlayer()))
1252     {
1253       if(!Memorized) CreateMemorized();
1254
1255       UpdateMemorized();
1256       UpdateMemorizedDescription();
1257     }
1258   }
1259 }
1260
1261 void lsquare::KickAnyoneStandingHereAway()
1262 {
1263   if(Character)
1264   {
1265     character* Backup = Character;
1266     Backup->Remove();
1267     Backup->PutNear(Pos);
1268   }
1269 }
1270
1271 outputfile& operator<<(outputfile& SaveFile, const emitter& Emitter)
1272 {
1273   SaveFile.Write(reinterpret_cast<cchar*>(&Emitter), sizeof(Emitter));
1274   return SaveFile;
1275 }
1276
1277 inputfile& operator>>(inputfile& SaveFile, emitter& Emitter)
1278 {
1279   SaveFile.Read(reinterpret_cast<char*>(&Emitter), sizeof(Emitter));
1280   return SaveFile;
1281 }
1282
1283 void lsquare::AddItem(item* Item)
1284 {
1285   Stack->AddItem(Item);
1286 }
1287
1288 v2 lsquare::DrawLightning(v2 StartPos, sLong Color, int Direction, truth DrawHere)
1289 {
1290   if(GetPos().X < game::GetCamera().X
1291      || GetPos().Y < game::GetCamera().Y
1292      || GetPos().X >= game::GetCamera().X + game::GetScreenXSize()
1293      || GetPos().Y >= game::GetCamera().Y + game::GetScreenYSize()
1294      || !CanBeSeenByPlayer(true))
1295     switch(Direction)
1296     {
1297      case 1: return v2(RAND() & 15, 15);
1298      case 3: return v2(15, RAND() & 15);
1299      case 4: return v2(0, RAND() & 15);
1300      case 6: return v2(RAND() & 15, 0);
1301      default: return StartPos;
1302     }
1303
1304   clock_t StartTime = clock();
1305   bitmap Empty(TILE_V2, TRANSPARENT_COLOR);
1306   Empty.ActivateFastFlag();
1307
1308   if(Color & RANDOM_COLOR)
1309     Color = MakeRGB16(60 + RAND() % 190, 60 + RAND() % 190, 60 + RAND() % 190);
1310
1311   if(Direction != YOURSELF)
1312   {
1313     while(!Empty.CreateLightning(StartPos, game::GetMoveVector(Direction), 16, Color));
1314     v2 EndPos(0, 0);
1315
1316     switch(Direction)
1317     {
1318      case 0: EndPos = v2(0, 0); break;
1319      case 1: EndPos = v2(RAND() & 15, 0); StartPos = v2(EndPos.X, 15); break;
1320      case 2: EndPos = v2(15, 0); break;
1321      case 3: EndPos = v2(0, RAND() & 15); StartPos = v2(15, EndPos.Y); break;
1322      case 4: EndPos = v2(15, RAND() & 15); StartPos = v2(0, EndPos.Y); break;
1323      case 5: EndPos = v2(0, 15); break;
1324      case 6: EndPos = v2(RAND() & 15, 15); StartPos = v2(EndPos.X, 0); break;
1325      case 7: EndPos = v2(15, 15); break;
1326     }
1327
1328     while(!Empty.CreateLightning(EndPos, -game::GetMoveVector(Direction), NO_LIMIT, Color));
1329   }
1330   else
1331   {
1332     static v2 Dir[4] = { v2(0, -1), v2(-1, 0), v2(1, 0), v2(0, 1) };
1333
1334     for(int d = 0; d < 4; ++d)
1335       while(!Empty.CreateLightning(StartPos + Dir[d], ZERO_V2, 10, Color));
1336   }
1337
1338   if(DrawHere)
1339     game::DrawEverythingNoBlit();
1340
1341   blitdata B = { DOUBLE_BUFFER,
1342      { 0, 0 },
1343      { 0, 0 },
1344      { TILE_SIZE, TILE_SIZE },
1345      { 0 },
1346      TRANSPARENT_COLOR,
1347      0 };
1348
1349   B.Dest = game::CalculateScreenCoordinates(GetPos());
1350   Empty.NormalMaskedBlit(B);
1351   Flags |= STRONG_NEW_DRAW_REQUEST;
1352
1353   if(DrawHere)
1354   {
1355     graphics::BlitDBToScreen();
1356     while(clock() - StartTime < 0.02 * CLOCKS_PER_SEC);
1357   }
1358
1359   return StartPos;
1360 }
1361
1362 truth lsquare::Polymorph(const beamdata& Beam)
1363 {
1364   GetStack()->Polymorph(Beam.Owner);
1365
1366   if(GetOLTerrain())
1367     GetOLTerrain()->Polymorph(Beam.Owner);
1368
1369   character* Character = GetCharacter();
1370
1371   if(Character)
1372   {
1373     if(Beam.Owner && Character->GetTeam() != Beam.Owner->GetTeam())
1374       Beam.Owner->Hostility(Character);
1375
1376     Character->PolymorphRandomly(1, 999999, 5000 + RAND() % 5000);
1377   }
1378
1379   if(Engraved)
1380   {
1381     for(int c = 0; Engraved[c] != '\0'; ++c)
1382     {
1383       if(RAND_2)
1384       {
1385         Engraved[c] = 32 + RAND_N(95);
1386       }
1387     }
1388   }
1389   return false;
1390 }
1391
1392 truth lsquare::Strike(const beamdata& Beam)
1393 {
1394   int Damage = 50 + RAND() % 21 - RAND() % 21;
1395   GetStack()->ReceiveDamage(Beam.Owner, Damage, ENERGY, Beam.Direction);
1396   ReceiveTrapDamage(Beam.Owner, Damage, ENERGY, Beam.Direction);
1397
1398   character* Char = GetCharacter();
1399
1400   if(Char)
1401   {
1402     if(Char->IsPlayer())
1403       ADD_MESSAGE("You are hit by a burst of energy!");
1404     else if(Char->CanBeSeenByPlayer())
1405       ADD_MESSAGE("%s is hit by a burst of energy!", Char->CHAR_NAME(DEFINITE));
1406
1407     if(Beam.Owner)
1408       Beam.Owner->Hostility(Char);
1409
1410     Char->ReceiveDamage(Beam.Owner, Damage, ENERGY, ALL);
1411     Char->CheckDeath(Beam.DeathMsg, Beam.Owner);
1412   }
1413
1414   if(GetOLTerrain())
1415     GetOLTerrain()->ReceiveDamage(Beam.Owner, Damage, ENERGY);
1416
1417   return false;
1418 }
1419
1420 truth lsquare::FireBall(const beamdata& Beam)
1421 {
1422   if(!IsFlyable() || GetCharacter())
1423   {
1424     if(CanBeSeenByPlayer(true))
1425       ADD_MESSAGE("A magical explosion is triggered!");
1426
1427     GetLevel()->Explosion(Beam.Owner, Beam.DeathMsg, Pos, 75 + RAND() % 25 - RAND() % 25);
1428     return true;
1429   }
1430
1431   return false;
1432 }
1433
1434 truth lsquare::Teleport(const beamdata& Beam)
1435 {
1436   if(Character)
1437   {
1438     if(Beam.Owner && Character->GetTeam() != Beam.Owner->GetTeam())
1439       Beam.Owner->Hostility(GetCharacter());
1440
1441     if(Character->IsPlayer())
1442       ADD_MESSAGE("You experience a forced teleportation.");
1443     else if(Character->CanBeSeenByPlayer())
1444       ADD_MESSAGE("%s disappears!", Character->CHAR_NAME(DEFINITE));
1445
1446     Character->TeleportRandomly();
1447   }
1448
1449   if(RoomIndex)
1450     GetLevel()->GetRoom(RoomIndex)->TeleportSquare(Beam.Owner, this);
1451
1452   GetStack()->TeleportRandomly();
1453   return false;
1454 }
1455
1456 truth lsquare::Haste(const beamdata&)
1457 {
1458   GetStack()->Haste();
1459   character* Dude = GetCharacter();
1460
1461   if(Dude)
1462     Dude->Haste();
1463
1464   return false;
1465 }
1466
1467 truth lsquare::Slow(const beamdata& Beam)
1468 {
1469   GetStack()->Slow();
1470   character* Dude = GetCharacter();
1471
1472   if(Dude)
1473   {
1474     if(Beam.Owner)
1475       Beam.Owner->Hostility(Dude);
1476
1477     Dude->Slow();
1478   }
1479
1480   return false;
1481 }
1482
1483
1484 truth lsquare::Confuse (const beamdata &Beam) {
1485   character *Dude = GetCharacter();
1486   //
1487   if (Dude && Dude->CanBeConfused()) {
1488     if (Beam.Owner) Beam.Owner->Hostility(Dude);
1489     Dude->BeginTemporaryState(CONFUSED, 50+RAND()%50);
1490   }
1491   return false;
1492 }
1493
1494
1495 truth lsquare::Parasitize (const beamdata &Beam) {
1496   character *Dude = GetCharacter();
1497   //
1498   if (Dude && Dude->GetTorso()->CanHaveParasite()) {
1499     if (Beam.Owner) Beam.Owner->Hostility(Dude);
1500     Dude->GainIntrinsic(PARASITIZED);
1501   }
1502   return false;
1503 }
1504
1505
1506 truth lsquare::InstillPanic (const beamdata &Beam) {
1507   character* Dude = GetCharacter();
1508   //
1509   if (Dude && Dude->CanPanic()) {
1510     if (Beam.Owner) Beam.Owner->Hostility(Dude);
1511     Dude->BeginTemporaryState(PANIC, 50+RAND()%50);
1512   }
1513   return false;
1514 }
1515
1516
1517 truth lsquare::Resurrect(const beamdata& Beam)
1518 {
1519   if (GetCharacter())
1520     return GetCharacter()->RaiseTheDead(Beam.Owner);
1521   else
1522     return GetStack()->RaiseTheDead(Beam.Owner);
1523 }
1524
1525 truth lsquare::Invisibility(const beamdata&)
1526 {
1527   if (GetCharacter())
1528     GetCharacter()->BeginTemporaryState(INVISIBLE, 1000 + RAND() % 1001);
1529
1530   return false;
1531 }
1532
1533 truth lsquare::Duplicate(const beamdata& Beam)
1534 {
1535   truth DuplicatedSomething = false;
1536   character* Character = GetCharacter();
1537
1538   if(Character)
1539     DuplicatedSomething = !!(Character->DuplicateToNearestSquare(Beam.Owner, Beam.SpecialParameters));
1540
1541   if(GetStack()->Duplicate(DuplicatedSomething ? 4 : 5, Beam.SpecialParameters))
1542     DuplicatedSomething = true;
1543
1544   return DuplicatedSomething;
1545 }
1546
1547 truth lsquare::Lightning(const beamdata& Beam)
1548 {
1549   int Damage = 20 + RAND() % 6 - RAND() % 6;
1550   GetStack()->ReceiveDamage(Beam.Owner, Damage, ELECTRICITY, Beam.Direction);
1551   ReceiveTrapDamage(Beam.Owner, Damage, ELECTRICITY, Beam.Direction);
1552
1553   character* Char = GetCharacter();
1554
1555   if(Char)
1556   {
1557     if(Char->IsPlayer())
1558       ADD_MESSAGE("A massive burst of electricity runs through your body!");
1559     else if(Char->CanBeSeenByPlayer())
1560       ADD_MESSAGE("A massive burst of electricity runs through %s!", Char->CHAR_NAME(DEFINITE));
1561
1562     if(Beam.Owner)
1563       Beam.Owner->Hostility(Char);
1564
1565     Char->ReceiveDamage(Beam.Owner, Damage, ELECTRICITY, ALL);
1566     Char->CheckDeath(Beam.DeathMsg, Beam.Owner);
1567   }
1568
1569   if(GetOLTerrain())
1570     GetOLTerrain()->ReceiveDamage(Beam.Owner, Damage, ELECTRICITY);
1571
1572   return false;
1573 }
1574
1575 truth lsquare::DoorCreation(const beamdata& Beam)
1576 {
1577   if ((!GetOLTerrain() || GetOLTerrain()->IsSafeToCreateDoor()) &&
1578       !GetCharacter() &&
1579       (GetLevel()->IsOnGround() ||
1580        (Pos.X > 0 && Pos.Y > 0 && Pos.X < GetLevel()->GetXSize()-1 && Pos.Y < GetLevel()->GetYSize()-1)))
1581   {
1582     if(Beam.Owner && GetRoom())
1583       GetRoom()->HostileAction(Beam.Owner);
1584
1585     door* Door = door::Spawn(0, NO_MATERIALS);
1586     Door->InitMaterials(MAKE_MATERIAL(STEEL));
1587
1588     if(RAND() % 10)
1589       Door->Lock();
1590
1591     ChangeOLTerrainAndUpdateLights(Door);
1592     return true;
1593   }
1594
1595   return false;
1596 }
1597
1598 truth (lsquare::*BeamEffect[BEAM_EFFECTS])(const beamdata&) =
1599 {
1600   &lsquare::Polymorph,
1601   &lsquare::Strike,
1602   &lsquare::FireBall,
1603   &lsquare::Teleport,
1604   &lsquare::Haste,
1605   &lsquare::Slow,
1606   &lsquare::Resurrect,
1607   &lsquare::Invisibility,
1608   &lsquare::Duplicate,
1609   &lsquare::Lightning,
1610   &lsquare::DoorCreation,
1611   &lsquare::AcidRain,
1612   &lsquare::Necromancy
1613 };
1614
1615 truth (lsquare::*lsquare::GetBeamEffect(int I))(const beamdata&)
1616 {
1617   return BeamEffect[I];
1618 }
1619
1620 truth lsquare::CheckKick(ccharacter* Kicker) const
1621 {
1622   if(Character && Kicker->CheckIfTooScaredToHit(Character))
1623     return false;
1624
1625   if(RoomIndex && !GetLevel()->GetRoom(RoomIndex)->CheckKickSquare(Kicker, this))
1626     return false;
1627
1628   return true;
1629 }
1630
1631 void lsquare::GetHitByExplosion(const explosion* Explosion)
1632 {
1633   if(Explosion->ID == LastExplosionID)
1634     return;
1635
1636   LastExplosionID = Explosion->ID;
1637   int DistanceSquare = (Pos - Explosion->Pos).GetLengthSquare();
1638
1639   if(DistanceSquare > Explosion->RadiusSquare)
1640     return;
1641
1642   int Damage = Explosion->Strength / (DistanceSquare + 1);
1643
1644   if (Character && (Explosion->HurtNeutrals || (Explosion->Terrorist && Character->GetRelation(Explosion->Terrorist) == HOSTILE))) {
1645     if (Character->IsPlayer()) game::SetPlayerWasHurtByExplosion(true);
1646     else Character->GetHitByExplosion(Explosion, Damage);
1647   }
1648
1649   GetStack()->ReceiveDamage(Explosion->Terrorist, Damage >> 1, FIRE);
1650   GetStack()->ReceiveDamage(Explosion->Terrorist, Damage >> 1, PHYSICAL_DAMAGE);
1651
1652   ReceiveTrapDamage(Explosion->Terrorist, Damage >> 1, FIRE);
1653   ReceiveTrapDamage(Explosion->Terrorist, Damage >> 1, PHYSICAL_DAMAGE);
1654
1655   if(GetOLTerrain())
1656     GetOLTerrain()->ReceiveDamage(Explosion->Terrorist, Damage >> 1, FIRE);
1657
1658   if(GetOLTerrain())
1659     GetOLTerrain()->ReceiveDamage(Explosion->Terrorist, Damage >> 1, PHYSICAL_DAMAGE);
1660 }
1661
1662 int lsquare::GetSpoiledItems() const
1663 {
1664   return GetStack()->GetSpoiledItems();
1665 }
1666
1667 truth lsquare::LowerEnchantment(const beamdata& Beam)
1668 {
1669   character* Char = GetCharacter();
1670   itemvector AllItems;
1671   sortdata SortData(AllItems, Beam.Owner, true, &item::IsEnchantable);
1672   SortAllItems(SortData);
1673   item* RandomItem;
1674
1675   if(!AllItems.empty())
1676     RandomItem = AllItems[RAND() % AllItems.size()];
1677   else
1678     return false;
1679
1680   if(Char)
1681   {
1682     if(Char->IsPlayer())
1683       ADD_MESSAGE("%s glows blue for a moment!", RandomItem->CHAR_NAME(DEFINITE));
1684
1685     if(Beam.Owner)
1686       Beam.Owner->Hostility(Char);
1687   }
1688
1689   if(RandomItem->GetEnchantment() > -5)
1690     RandomItem->EditEnchantment(-1);
1691
1692   return true;
1693 }
1694
1695 void lsquare::SortAllItems(const sortdata& SortData)
1696 {
1697   if(GetCharacter())
1698     GetCharacter()->SortAllItems(SortData);
1699
1700   GetStack()->SortAllItems(SortData);
1701 }
1702
1703
1704 truth lsquare::SoftenMaterial (const beamdata &Beam) {
1705   character *Char = GetCharacter();
1706   item *RandomItem;
1707   itemvector AllItems;
1708   //
1709   sortdata SortData(AllItems, Beam.Owner, true, &item::IsEnchantable);
1710   SortAllItems(SortData);
1711   //sortdata SortData2(AllItems, Beam.Owner, true, &item::MaterialIsChangeable);
1712   //SortAllItems(SortData2);
1713   if (AllItems.empty()) return false;
1714   RandomItem = AllItems[RAND() % AllItems.size()];
1715   if (Char) {
1716     if (Char->IsPlayer()) ADD_MESSAGE("Your %s glows yellow for a moment!", RandomItem->CHAR_NAME(UNARTICLED));
1717     if (Beam.Owner) Beam.Owner->Hostility(Char);
1718   }
1719   //
1720   truth Changed = 0;
1721   festring Desc;
1722   //
1723   RandomItem->AddName(Desc, UNARTICLED);
1724   material *OldMaterial = RandomItem->GetMainMaterial();
1725   int NewMaterial = RandomItem->GetMainMaterial()->GetSoftenedMaterial(RandomItem);
1726   //
1727   if (NewMaterial != NONE) {
1728     /* Don't Forget! It is an ugly thing, I know, but removal = seg-fault since cannot have NONE material */
1729     RandomItem->ChangeMainMaterial(MAKE_MATERIAL(NewMaterial)); /*->SpawnMore()*/
1730     if (OldMaterial->GetConfig() != NewMaterial) Changed = 1;
1731   }
1732   if (Char) {
1733     if (Changed && Char->IsPlayer()) {
1734       ADD_MESSAGE("Your %s softens into %s!", Desc.CStr(), RandomItem->GetMainMaterial()->GetName(false, false).CStr());
1735     } else if (Changed) {
1736       ADD_MESSAGE("%s's %s softens into %s!", Char->CHAR_DESCRIPTION(DEFINITE), Desc.CStr(), RandomItem->GetMainMaterial()->GetName(false, false).CStr());
1737     }
1738     if (!Changed) {
1739       //may not need this message
1740       if (Char->IsPlayer()) {
1741         ADD_MESSAGE("Your %s vibrates slightly but remains unchanged.", RandomItem->CHAR_NAME(UNARTICLED) );
1742       } else {
1743         ADD_MESSAGE("%s's %s vibrates slightly but remains unchanged.", Char->CHAR_DESCRIPTION(DEFINITE), RandomItem->CHAR_NAME(UNARTICLED) );
1744       }
1745     }
1746   }
1747   return true;
1748 }
1749
1750
1751 void lsquare::RemoveSmoke(smoke* ToBeRemoved)
1752 {
1753   smoke* S = Smoke;
1754
1755   if(S == ToBeRemoved)
1756   {
1757     Smoke = S->Next;
1758
1759     if(!S)
1760       DecAnimatedEntities();
1761   }
1762   else
1763   {
1764     smoke* LS;
1765
1766     do
1767     {
1768       LS = S;
1769       S = S->Next;
1770     }
1771     while(S != ToBeRemoved);
1772
1773     LS->Next = S->Next;
1774   }
1775 }
1776
1777 void lsquare::AddSmoke(gas* ToBeAdded)
1778 {
1779   smoke* S = Smoke;
1780
1781   if(!S)
1782   {
1783     Smoke = new smoke(ToBeAdded, this);
1784     IncAnimatedEntities();
1785   }
1786   else
1787   {
1788     smoke* LS;
1789
1790     do
1791     {
1792       if(ToBeAdded->IsSameAs(S->GetGas()))
1793       {
1794         S->Merge(ToBeAdded);
1795         return;
1796       }
1797
1798       LS = S;
1799       S = S->Next;
1800     }
1801     while(S);
1802
1803     LS->Next = new smoke(ToBeAdded, this);
1804   }
1805 }
1806
1807 void lsquare::ShowSmokeMessage() const
1808 {
1809   for(const smoke* S = Smoke; S; S = S->Next)
1810     S->AddBreatheMessage();
1811 }
1812
1813 void lsquare::SignalSmokeAlphaChange(int What)
1814 {
1815   SmokeAlphaSum += What;
1816   SignalPossibleTransparencyChange();
1817 }
1818
1819 int lsquare::GetDivineMaster() const
1820 {
1821   return RoomIndex ? GetLevel()->GetRoom(RoomIndex)->GetDivineMaster() : 0;
1822 }
1823
1824 void lsquare::DisplaySmokeInfo (festring &Msg) const {
1825   if (Smoke) {
1826     if (!Smoke->Next)
1827       Msg << " A cloud of " << Smoke->GetGas()->GetName(false, false) << " surrounds the square.";
1828     else
1829       Msg << " A lot of gases hover over the square.";
1830   }
1831 }
1832
1833 void lsquare::ReceiveEarthQuakeDamage()
1834 {
1835   GetStack()->ReceiveDamage(0, 5 + RAND() % 10, PHYSICAL_DAMAGE);
1836   ReceiveTrapDamage(0, 5 + RAND() % 10, PHYSICAL_DAMAGE);
1837   /* Gum solution */
1838
1839   if(GetOLTerrain() && GetOLTerrain()->IsDoor())
1840     GetOLTerrain()->ReceiveDamage(0, 5 + RAND() % 10, PHYSICAL_DAMAGE);
1841 }
1842
1843 truth lsquare::CanBeFeltByPlayer() const
1844 {
1845   if (!PLAYER) return false;
1846   return OLTerrain && !PLAYER->CanMoveOn(this) && Pos.IsAdjacent(PLAYER->GetPos());
1847 }
1848
1849 void lsquare::PreProcessForBone()
1850 {
1851   DestroyMemorized();
1852   LastSeen = 0;
1853
1854   if(OLTerrain)
1855     OLTerrain->PreProcessForBone();
1856
1857   if(Smoke)
1858   {
1859     DecAnimatedEntities();
1860
1861     for(smoke* S = Smoke; S; S = S->Next)
1862       S->SendToHell();
1863
1864     Smoke = 0;
1865     SmokeAlphaSum = 0;
1866   }
1867
1868   if(Character && !Character->PreProcessForBone())
1869   {
1870     Character->SendToHell();
1871     Character->Remove();
1872   }
1873
1874   for(fluid* F = Fluid; F; F = F->Next)
1875     F->PreProcessForBone();
1876
1877   for(trap* T = Trap; T; T = T->Next)
1878     T->PreProcessForBone();
1879
1880   GetStack()->PreProcessForBone();
1881 }
1882
1883 void lsquare::PostProcessForBone(double& DangerSum, int& Enemies)
1884 {
1885   if(OLTerrain)
1886     OLTerrain->PostProcessForBone();
1887
1888   if(Character && !Character->PostProcessForBone(DangerSum, Enemies))
1889   {
1890     Character->SendToHell();
1891     Character->Remove();
1892   }
1893
1894   for(fluid* F = Fluid; F; F = F->Next)
1895     F->PostProcessForBone();
1896
1897   for(trap* T = Trap; T; T = T->Next)
1898     T->PostProcessForBone();
1899
1900   GetStack()->PostProcessForBone();
1901 }
1902
1903 void lsquare::FinalProcessForBone()
1904 {
1905   if(OLTerrain)
1906     OLTerrain->FinalProcessForBone();
1907
1908   if(Character)
1909     Character->FinalProcessForBone();
1910
1911   GetStack()->FinalProcessForBone();
1912 }
1913
1914 truth lsquare::EngravingsCanBeReadByPlayer()
1915 {
1916   return PLAYER->CanRead(); // Might be a good idea to improve sometime in the distant future.
1917 }
1918
1919 void lsquare::DisplayEngravedInfo(festring& Buffer) const
1920 {
1921   Buffer << " There is a message engraved here: \"" << Engraved << '\"';
1922 }
1923
1924 truth lsquare::IsDangerousToBreathe(ccharacter* Who) const
1925 {
1926   for(const smoke* S = Smoke; S; S = S->Next)
1927     if(S->IsDangerousToBreathe(Who))
1928       return true;
1929
1930   return false;
1931 }
1932
1933 truth lsquare::IsScaryToBreathe(ccharacter* Who) const
1934 {
1935   for(const smoke* S = Smoke; S; S = S->Next)
1936     if(S->IsScaryToBreathe(Who))
1937       return true;
1938
1939   return false;
1940 }
1941
1942
1943 struct groundborderpartner {
1944   truth operator < (const groundborderpartner &P) const { return Terrain->GetBorderTilePriority() < P.Terrain->GetBorderTilePriority(); }
1945   glterrain *Terrain;
1946   int SquareIndex;
1947 };
1948
1949
1950 void lsquare::CalculateGroundBorderPartners () {
1951   if (GroundBorderPartnerInfo & BORDER_PARTNER_ANIMATED) DecStaticAnimatedEntities();
1952   groundborderpartner BorderPartner[8*2]; //k8: *2 to make g++ shut up (WTF?!)
1953   int Index = 0;
1954   int Priority = GLTerrain->GetBorderTilePriority();
1955   for (int d = 0; d < 8; ++d) {
1956     lsquare *Square = NeighbourLSquare[d];
1957     if (Square) {
1958       glterrain *Terrain = Square->GetGLTerrain();
1959       if (Terrain && Terrain->UseBorderTiles() && Terrain->GetBorderTilePriority() > Priority) {
1960         BorderPartner[Index].Terrain = Terrain;
1961         BorderPartner[Index].SquareIndex = 7-d;
1962         ++Index;
1963       }
1964     }
1965   }
1966   GroundBorderPartnerInfo = 0;
1967   if (!Index) {
1968     delete [] GroundBorderPartnerTerrain;
1969     GroundBorderPartnerTerrain = 0;
1970     return;
1971   }
1972   if (!GroundBorderPartnerTerrain) GroundBorderPartnerTerrain = new glterrain *[8];
1973   std::sort(BorderPartner, BorderPartner+Index); //k8: why g++ complains here? ah, ignore it for now
1974   truth Animated = false;
1975   for (int c = 0; c < Index; ++c) {
1976     glterrain *T = BorderPartner[c].Terrain;
1977     GroundBorderPartnerTerrain[c] = T;
1978     GroundBorderPartnerInfo |= BorderPartner[c].SquareIndex<<((c<<1)+c);
1979     if (T->IsAnimated()) Animated = true;
1980   }
1981   if (Animated) {
1982     GroundBorderPartnerInfo |= BORDER_PARTNER_ANIMATED;
1983     IncStaticAnimatedEntities();
1984   }
1985   GroundBorderPartnerInfo |= Index<<24;
1986 }
1987
1988
1989 struct overborderpartner {
1990   truth operator < (const overborderpartner &P) const { return Terrain->GetBorderTilePriority() < P.Terrain->GetBorderTilePriority(); }
1991   olterrain *Terrain;
1992   int SquareIndex;
1993 };
1994
1995 void lsquare::CalculateOverBorderPartners () {
1996   if (OverBorderPartnerInfo & BORDER_PARTNER_ANIMATED) DecStaticAnimatedEntities();
1997   overborderpartner BorderPartner[8*2]; //k8: *2 to make g++ shut up (WTF?!)
1998   int Index = 0;
1999   int Priority = OLTerrain ? OLTerrain->GetBorderTilePriority() : 0;
2000   for (int d = 0; d < 8; ++d) {
2001     lsquare *Square = NeighbourLSquare[d];
2002     if (Square) {
2003       olterrain *Terrain = Square->GetOLTerrain();
2004       if (Terrain && Terrain->UseBorderTiles() && Terrain->GetBorderTilePriority() > Priority) {
2005         BorderPartner[Index].Terrain = Terrain;
2006         BorderPartner[Index].SquareIndex = 7-d;
2007         ++Index;
2008       }
2009     }
2010   }
2011   OverBorderPartnerInfo = 0;
2012   if (!Index) {
2013     delete [] OverBorderPartnerTerrain;
2014     OverBorderPartnerTerrain = 0;
2015     return;
2016   }
2017   if (!OverBorderPartnerTerrain) OverBorderPartnerTerrain = new olterrain *[8];
2018   std::sort(BorderPartner, BorderPartner+Index); //k8: why g++ complains here? ah, ignore it for now
2019   truth Animated = false;
2020   for (int c = 0; c < Index; ++c) {
2021     olterrain *T = BorderPartner[c].Terrain;
2022     OverBorderPartnerTerrain[c] = T;
2023     OverBorderPartnerInfo |= BorderPartner[c].SquareIndex<<((c<<1)+c);
2024     if (T->IsAnimated()) Animated = true;
2025   }
2026   if (Animated) {
2027     OverBorderPartnerInfo |= BORDER_PARTNER_ANIMATED;
2028     IncStaticAnimatedEntities();
2029   }
2030   OverBorderPartnerInfo |= Index<<24;
2031 /*k8
2032   if (OverBorderPartnerInfo & BORDER_PARTNER_ANIMATED)
2033     int esko = esko = 2;
2034 */
2035 }
2036
2037
2038 void lsquare::RequestForGroundBorderPartnerUpdates()
2039 {
2040   if(!game::IsGenerating())
2041     for(int d = 0; d < 8; ++d)
2042     {
2043       lsquare* Square = NeighbourLSquare[d];
2044
2045       if(Square)
2046       {
2047         Square->CalculateGroundBorderPartners();
2048         Square->SendNewDrawRequest();
2049         Square->SendMemorizedUpdateRequest();
2050       }
2051     }
2052 }
2053
2054 void lsquare::RequestForOverBorderPartnerUpdates()
2055 {
2056   if(!game::IsGenerating())
2057     for(int d = 0; d < 8; ++d)
2058     {
2059       lsquare* Square = NeighbourLSquare[d];
2060
2061       if(Square)
2062       {
2063         Square->CalculateOverBorderPartners();
2064         Square->SendNewDrawRequest();
2065         Square->SendMemorizedUpdateRequest();
2066       }
2067     }
2068 }
2069
2070 int lsquare::GetWalkability() const
2071 {
2072   if(!GetLevel()->IsOnGround())
2073   {
2074     if(Pos.X >= 1 && Pos.Y >= 1 && Pos.X < GetLevel()->GetXSize() - 1 && Pos.Y < GetLevel()->GetYSize() - 1)
2075       return OLTerrain ? OLTerrain->GetWalkability() & GLTerrain->GetWalkability() : GLTerrain->GetWalkability();
2076     else
2077       return 0;
2078   }
2079   else
2080     return OLTerrain ? OLTerrain->GetWalkability() & GLTerrain->GetWalkability() : GLTerrain->GetWalkability();
2081 }
2082
2083 void lsquare::RemoveFluid(fluid* ToRemove)
2084 {
2085   fluid*& F = ListFind(Fluid, pointercomparer<fluid>(ToRemove));
2086   F = F->Next;
2087   SignalEmitationDecrease(ToRemove->GetEmitation());
2088 }
2089
2090 struct fluidcomparer
2091 {
2092   fluidcomparer(const liquid* Liquid) : Liquid(Liquid) { }
2093   truth operator()(const fluid* F) const { return Liquid->IsSameAs(F->GetLiquid()); }
2094   const liquid* Liquid;
2095 };
2096
2097 fluid* lsquare::AddFluid(liquid* ToBeAdded)
2098 {
2099   fluid*& F = ListFind(Fluid, fluidcomparer(ToBeAdded));
2100
2101   if(F)
2102   {
2103     F->AddLiquidAndVolume(ToBeAdded->GetVolume());
2104     delete ToBeAdded;
2105   }
2106   else
2107   {
2108     F = new fluid(ToBeAdded, this);
2109     SignalEmitationIncrease(ToBeAdded->GetEmitation());
2110   }
2111
2112   SendNewDrawRequest();
2113   SendMemorizedUpdateRequest();
2114   return F;
2115 }
2116
2117 void lsquare::DisplayFluidInfo(festring& Msg) const
2118 {
2119   if(Fluid)
2120   {
2121     Msg << ". There is ";
2122     fluid::AddFluidInfo(Fluid, Msg);
2123     AddLocationDescription(Msg);
2124   }
2125 }
2126
2127 void lsquare::SpillFluid(character* Spiller, liquid* Liquid, truth ForceHit, truth ShowMsg)
2128 {
2129   if(!Liquid->GetVolume())
2130   {
2131     delete Liquid;
2132     return;
2133   }
2134
2135   if(IsFlyable())
2136   {
2137     if(GetCharacter())
2138     {
2139       if(Spiller && !GetCharacter()->IsAlly(Spiller))
2140         Spiller->Hostility(GetCharacter());
2141
2142       sLong CharVolume = GetCharacter()->GetVolume();
2143       double ChanceMultiplier = 1. / (300 + sqrt(GetStack()->GetVolume() + CharVolume));
2144       double Root = sqrt(CharVolume);
2145
2146       if(ForceHit || Root > RAND() % 400 || Root > RAND() % 400)
2147       {
2148         sLong SpillVolume = sLong(Liquid->GetVolume() * Root * ChanceMultiplier);
2149
2150         if(SpillVolume)
2151         {
2152           if(ShowMsg && (GetCharacter()->IsPlayer() || GetCharacter()->CanBeSeenByPlayer()))
2153             ADD_MESSAGE("%s is spilled all over %s.", Liquid->GetName(false, false).CStr(), GetCharacter()->CHAR_DESCRIPTION(DEFINITE));
2154
2155           Liquid->EditVolume(-SpillVolume);
2156           GetCharacter()->SpillFluid(Spiller, Liquid->SpawnMoreLiquid(SpillVolume), GetCharacter()->GetSquareIndex(GetPos()));
2157         }
2158       }
2159     }
2160
2161     GetStack()->SpillFluid(Spiller, Liquid, Liquid->GetVolume());
2162   }
2163
2164   if(Liquid->GetVolume() && !Liquid->IsSameAs(GLTerrain->GetMainMaterial()))
2165   {
2166     fluid* F = AddFluid(Liquid);
2167
2168     if(GetCharacter())
2169       F->StepOnEffect(GetCharacter());
2170   }
2171   else
2172     delete Liquid;
2173 }
2174
2175 void lsquare::DrawStacks(blitdata& BlitData) const
2176 {
2177   Stack->Draw(PLAYER, BlitData, CENTER);
2178
2179   for(int c = 0; c < 4; ++c)
2180   {
2181     stack* Stack = GetStackOfAdjacentSquare(c);
2182
2183     if(Stack)
2184       Stack->Draw(PLAYER, BlitData, 3 - c);
2185   }
2186 }
2187
2188 void lsquare::RemoveRain(rain* ToBeRemoved)
2189 {
2190   SendNewDrawRequest();
2191   rain* R = Rain;
2192
2193   if(ToBeRemoved->IsEnabled())
2194     DecAnimatedEntities();
2195
2196   if(R == ToBeRemoved)
2197     Rain = R->Next;
2198   else
2199   {
2200     rain* LR;
2201
2202     do
2203     {
2204       LR = R;
2205       R = R->Next;
2206     }
2207     while(R != ToBeRemoved);
2208
2209     LR->Next = R->Next;
2210   }
2211
2212   SignalEmitationDecrease(ToBeRemoved->GetEmitation());
2213 }
2214
2215 void lsquare::AddRain(liquid* RainLiquid, v2 Speed, int Team, truth OwnLiquid)
2216 {
2217   rain* R = Rain, * NewRain = new rain(RainLiquid, this, Speed, Team, OwnLiquid);
2218
2219   if(NewRain->IsEnabled())
2220     IncAnimatedEntities();
2221
2222   if(!R)
2223     Rain = NewRain;
2224   else
2225   {
2226     rain* LR;
2227
2228     do
2229     {
2230       LR = R;
2231       R = R->Next;
2232     }
2233     while(R);
2234
2235     LR->Next = NewRain;
2236   }
2237 }
2238
2239 void lsquare::RemoveSunLight()
2240 {
2241   SunLightLuminance = 0;
2242   SunEmitter.clear();
2243 }
2244
2245 void lsquare::CheckIfIsSecondarySunLightEmitter()
2246 {
2247   col24 OldEmitation = SecondarySunLightEmitation;
2248
2249   if(Flags & IS_TRANSPARENT && (!(Flags & INSIDE) || SunLightLuminance))
2250   {
2251     for(int d = 0; d < 8; ++d)
2252     {
2253       lsquare* Neighbour = NeighbourLSquare[d];
2254
2255       if(Neighbour && Neighbour->Flags & INSIDE)
2256       {
2257         col24 NewEmitation = GetLevel()->GetAmbientLuminance();
2258
2259         if(OldEmitation != NewEmitation)
2260         {
2261           SecondarySunLightEmitation = NewEmitation;
2262
2263           if(game::CompareLights(NewEmitation, OldEmitation) >= 0)
2264             Emitate(NewEmitation, SECONDARY_SUN_LIGHT);
2265           else
2266           {
2267             Noxify(OldEmitation, SECONDARY_SUN_LIGHT);
2268             Emitate(NewEmitation, SECONDARY_SUN_LIGHT|FORCE_ADD);
2269           }
2270         }
2271
2272         return;
2273       }
2274     }
2275   }
2276
2277   if(OldEmitation)
2278   {
2279     Noxify(OldEmitation, SECONDARY_SUN_LIGHT);
2280     SecondarySunLightEmitation = 0;
2281   }
2282 }
2283
2284 void lsquare::CalculateNeighbourLSquares()
2285 {
2286   int XSize = GetLevel()->GetXSize();
2287   int YSize = GetLevel()->GetYSize();
2288
2289   for(int d = 0; d < 8; ++d)
2290   {
2291     v2 NPos = Pos + game::GetMoveVector(d);
2292
2293     if(NPos.X >= 0 && NPos.Y >= 0 && NPos.X < XSize && NPos.Y < YSize)
2294       NeighbourLSquare[d] = GetLevel()->GetLSquare(NPos);
2295     else
2296       NeighbourLSquare[d] = 0;
2297   }
2298 }
2299
2300 void lsquare::RemoveLuminance(col24& Emitation)
2301 {
2302   col24 OldLuminance = Luminance;
2303   col24 OldEmitation = Emitation;
2304   Emitation = 0;
2305
2306   if(game::CompareLights(OldEmitation, OldLuminance) < 0) return;
2307
2308   if(!(Flags & IS_TRANSPARENT))
2309   {
2310     Flags |= NEW_DRAW_REQUEST;
2311
2312     if(LastSeen == game::GetLOSTick()) game::SendLOSUpdateRequest();
2313   }
2314   else
2315   {
2316     CalculateLuminance();
2317
2318     if(OldLuminance == Luminance)
2319       return;
2320
2321     Flags |= NEW_DRAW_REQUEST;
2322
2323     if(!Luminance)
2324     {
2325       Flags |= MEMORIZED_UPDATE_REQUEST|DESCRIPTION_CHANGE;
2326
2327       if(LastSeen == game::GetLOSTick()) game::SendLOSUpdateRequest();
2328     }
2329   }
2330 }
2331
2332 void lsquare::ChangeLuminance(col24& Emitation, col24 NewLuminance)
2333 {
2334   col24 OldLuminance = Luminance;
2335
2336   if(!(Flags & IS_TRANSPARENT))
2337   {
2338     Emitation = NewLuminance;
2339     Flags |= NEW_DRAW_REQUEST;
2340
2341     if(LastSeen == game::GetLOSTick())
2342       game::SendLOSUpdateRequest();
2343
2344     return;
2345   }
2346
2347   truth EmitationInsignificant = !Emitation
2348          || game::CompareLights(Emitation, OldLuminance) < 0;
2349   Emitation = NewLuminance;
2350
2351   if(game::CompareLights(NewLuminance, OldLuminance) > 0 && EmitationInsignificant)
2352     game::CombineLights(Luminance, NewLuminance);
2353   else
2354   {
2355     if(EmitationInsignificant)
2356       return;
2357
2358     CalculateLuminance();
2359
2360     if(OldLuminance == Luminance)
2361       return;
2362   }
2363
2364   Flags |= NEW_DRAW_REQUEST;
2365
2366   if(!OldLuminance)
2367   {
2368     Flags |= MEMORIZED_UPDATE_REQUEST|DESCRIPTION_CHANGE;
2369
2370     if(LastSeen == game::GetLOSTick())
2371       game::SendLOSUpdateRequest();
2372   }
2373 }
2374
2375 void lsquare::EnableGlobalRain()
2376 {
2377   for(rain* R = Rain; R; R = R->Next)
2378     if(!R->HasOwnLiquid())
2379     {
2380       R->Enable();
2381       IncAnimatedEntities();
2382     }
2383 }
2384
2385 void lsquare::DisableGlobalRain()
2386 {
2387   SendNewDrawRequest();
2388
2389   for(rain* R = Rain; R; R = R->Next)
2390     if(!R->HasOwnLiquid())
2391     {
2392       R->Disable();
2393       DecAnimatedEntities();
2394     }
2395 }
2396
2397 void lsquare::InitLastSeen()
2398 {
2399   LastSeen = LastSeen == game::GetLOSTick() ? 2 : 0;
2400   SquarePartLastSeen = 0;
2401 }
2402
2403 truth lsquare::Engrave(cfestring& What)
2404 {
2405   if(Engraved)
2406     delete [] Engraved;
2407
2408   if(!What.IsEmpty())
2409   {
2410     Engraved = new char[What.GetSize() + 1];
2411     strcpy(Engraved, What.CStr());
2412   }
2413   else
2414     Engraved = 0;
2415
2416   return true;
2417 }
2418
2419 void lsquare::SendSunLightSignals()
2420 {
2421   if(Flags & IS_TRANSPARENT)
2422   {
2423     col24 OldLuminance = Luminance;
2424     CalculateLuminance();
2425
2426     if(Luminance != OldLuminance)
2427     {
2428       Flags |= NEW_DRAW_REQUEST;
2429
2430       if(!Luminance != !OldLuminance)
2431       {
2432         Flags |= MEMORIZED_UPDATE_REQUEST|DESCRIPTION_CHANGE;
2433
2434         if(LastSeen == game::GetLOSTick())
2435           game::SendLOSUpdateRequest();
2436       }
2437     }
2438   }
2439   else
2440   {
2441     Flags |= NEW_DRAW_REQUEST;
2442
2443     if(LastSeen == game::GetLOSTick())
2444       game::SendLOSUpdateRequest();
2445   }
2446 }
2447
2448 void lsquare::ZeroReSunEmitatedFlags()
2449 {
2450   sunemittervector::iterator i, End = SunEmitter.end();
2451
2452   for(i = SunEmitter.begin(); i != End; ++i) *i &= ~RE_SUN_EMITATED;
2453 }
2454
2455 truth lsquare::CalculateIsTransparent()
2456 {
2457   if((!OLTerrain || OLTerrain->IsTransparent()) && SmokeAlphaSum < 175
2458      && (!Character || Character->IsTransparent()))
2459   {
2460     Flags |= IS_TRANSPARENT;
2461     return true;
2462   }
2463   else
2464   {
2465     Flags &= ~IS_TRANSPARENT;
2466     return false;
2467   }
2468 }
2469
2470 void lsquare::CalculateSunLightLuminance(feuLong SeenBitMask)
2471 {
2472   sunemittervector::const_iterator i, SunEnd = SunEmitter.end();
2473   int S = 0, L = 0;
2474
2475   for(i = SunEmitter.begin(); i != SunEnd; ++i)
2476   {
2477     feuLong ShadowFlag = 1 << EMITTER_SHADOW_SHIFT;
2478     feuLong SquarePartFlag = 1 << EMITTER_SQUARE_PART_SHIFT;
2479     for (int c = 0; c < 4; ++c, ShadowFlag <<= 1, SquarePartFlag <<= 1) {
2480       if (SeenBitMask & *i & SquarePartFlag) {
2481         if (*i & ShadowFlag) ++S; else ++L;
2482       }
2483     }
2484   }
2485
2486   if(!L)
2487     SunLightLuminance = 0;
2488   else if(!S)
2489     SunLightLuminance = GetLevel()->GetSunLightEmitation();
2490   else
2491   {
2492     col24 ShadowColor = GetLevel()->GetAmbientLuminance();
2493     col24 LightColor = GetLevel()->GetSunLightEmitation();
2494     SunLightLuminance = MakeRGB24(
2495       (GetRed24(LightColor)*L+GetRed24(ShadowColor)*S)/(S+L),
2496       (GetGreen24(LightColor)*L+GetGreen24(ShadowColor)*S)/(S+L),
2497       (GetBlue24(LightColor)*L+GetBlue24(ShadowColor)*S)/(S+L));
2498   }
2499 }
2500
2501 void lsquare::CreateMemorized()
2502 {
2503   Memorized = new bitmap(TILE_V2);
2504   Memorized->ActivateFastFlag();
2505   FowMemorized = new bitmap(TILE_V2);
2506   FowMemorized->ActivateFastFlag();
2507 }
2508
2509 truth lsquare::AcidRain(const beamdata& Beam)
2510 {
2511   if(!IsFlyable() || GetCharacter() || Beam.Direction == YOURSELF)
2512   {
2513     int StackSize = GetLevel()->AddRadiusToSquareStack(Pos, 9);
2514     lsquare** Stack = GetLevel()->GetSquareStack();
2515     v2 Speed = v2(512, 512);
2516     int Team = Beam.Owner ? Beam.Owner->GetTeam()->GetID() : MONSTER_TEAM;
2517
2518     for(int c = 0; c < StackSize; ++c)
2519     {
2520       Stack[c]->AddRain(liquid::Spawn(SULPHURIC_ACID, 300), Speed, Team, true);
2521       Stack[c]->Flags &= ~IN_SQUARE_STACK;
2522     }
2523
2524     if(Beam.Owner && Character && Character->GetTeam() != Beam.Owner->GetTeam())
2525       Beam.Owner->Hostility(Character);
2526
2527     return true;
2528   }
2529
2530   return false;
2531 }
2532
2533 truth lsquare::DetectMaterial (cmaterial *Material) const {
2534   if (GLTerrain->DetectMaterial(Material) ||
2535       (OLTerrain && OLTerrain->DetectMaterial(Material)) ||
2536       Stack->DetectMaterial(Material) ||
2537       (Character && Character->DetectMaterial(Material))) return true;
2538   for (const fluid *F = Fluid; F; F = F->Next) if (F->GetLiquid()->IsSameAs(Material)) return true;
2539   for (const smoke *S = Smoke; S; S = S->Next) if (S->GetGas()->IsSameAs(Material)) return true;
2540   for (const rain *R = Rain; R; R = R->Next) if (R->GetLiquid()->IsSameAs(Material)) return true;
2541   return false;
2542 }
2543
2544 void lsquare::Reveal(feuLong Tick, truth IgnoreDarkness)
2545 {
2546   if(!Memorized)
2547     CreateMemorized();
2548
2549   LastSeen = Tick;
2550
2551   if(IgnoreDarkness)
2552     Luminance = NORMAL_LUMINANCE;
2553   else
2554   {
2555     SquarePartLastSeen = 0;
2556
2557     for(int c = 0; c < 4; ++c)
2558       SquarePartLastSeen |= (Tick << (c << 3));
2559
2560     CalculateLuminance();
2561   }
2562
2563   Flags |=
2564     NEW_DRAW_REQUEST|
2565     MEMORIZED_UPDATE_REQUEST|
2566     DESCRIPTION_CHANGE;
2567   UpdateMemorized();
2568   UpdateMemorizedDescription();
2569 }
2570
2571 void lsquare::DestroyMemorized()
2572 {
2573   delete Memorized;
2574   delete FowMemorized;
2575   Memorized = 0;
2576   FowMemorized = 0;
2577 }
2578
2579 void lsquare::SwapMemorized(lsquare* Square)
2580 {
2581   Swap(Memorized, Square->Memorized);
2582   Swap(FowMemorized, Square->FowMemorized);
2583   MemorizedDescription.SwapData(Square->MemorizedDescription);
2584 }
2585
2586 truth lsquare::Necromancy(const beamdata& Beam)
2587 {
2588   return GetStack()->Necromancy(Beam.Owner);
2589 }
2590
2591 // Returns 0 if fails
2592
2593 lsquare* lsquare::GetRandomAdjacentSquare() const
2594 {
2595   lsquare* OK[8];
2596   int Index = 0;
2597
2598   for(int c = 0; c < 8; ++c)
2599   {
2600     lsquare* Square = NeighbourLSquare[c];
2601
2602     if(Square)
2603       OK[Index++] = Square;
2604   }
2605
2606   if(Index)
2607     return OK[RAND_N(Index)];
2608   else
2609     return 0;
2610 }
2611
2612 truth pathcontroller::Handler(int x, int y)
2613 {
2614   return Character->CanMoveOn(Map[x][y]);
2615 }
2616
2617 void lsquare::SignalPossibleTransparencyChange()
2618 {
2619   truth WasTransparent = IsTransparent();
2620   CalculateIsTransparent();
2621
2622   if(WasTransparent && !IsTransparent())
2623   {
2624     Flags |= IS_TRANSPARENT;
2625     emittervector EmitterBackup = Emitter;
2626     GetLevel()->ForceEmitterNoxify(EmitterBackup);
2627     Flags &= ~IS_TRANSPARENT;
2628     GetLevel()->ForceEmitterEmitation(EmitterBackup, SunEmitter, FORCE_ADD);
2629     CalculateLuminance();
2630     Flags |= DESCRIPTION_CHANGE|MEMORIZED_UPDATE_REQUEST;
2631
2632     if(LastSeen == game::GetLOSTick())
2633       game::SendLOSUpdateRequest();
2634   }
2635   else if(!WasTransparent && IsTransparent())
2636   {
2637     GetLevel()->ForceEmitterEmitation(Emitter, SunEmitter);
2638     CalculateLuminance();
2639     Flags |= DESCRIPTION_CHANGE|MEMORIZED_UPDATE_REQUEST;
2640
2641     if(LastSeen == game::GetLOSTick())
2642       game::SendLOSUpdateRequest();
2643   }
2644 }
2645
2646 void lsquare::RemoveTrap(trap* ToRemove)
2647 {
2648   trap*& T = ListFind(Trap, pointercomparer<trap>(ToRemove));
2649   T = T->Next;
2650   SendNewDrawRequest();
2651   SendMemorizedUpdateRequest();
2652 }
2653
2654 struct trapcomparer
2655 {
2656   trapcomparer(int Type) : Type(Type) { }
2657   truth operator()(const trap* T) const { return T->GetType() == Type; }
2658   int Type;
2659 };
2660
2661 truth lsquare::AddTrap(trap* ToBeAdded)
2662 {
2663   trap*& T = ListFind(Trap, trapcomparer(ToBeAdded->GetType()));
2664
2665   if(T)
2666   {
2667     delete ToBeAdded;
2668     return false;
2669   }
2670   else
2671     T = ToBeAdded;
2672
2673   ToBeAdded->SetLSquareUnder(this);
2674   SendNewDrawRequest();
2675   SendMemorizedUpdateRequest();
2676   return true;
2677 }
2678
2679 void lsquare::DisplayTrapInfo(festring& Msg) const
2680 {
2681   for(const trap* T = Trap; T; T = T->Next)
2682     T->AddDescription(Msg);
2683 }
2684
2685 void lsquare::FillTrapVector(std::vector<trap*>& TrapVector) const
2686 {
2687   for(trap* T = Trap; T; T = T->Next)
2688     TrapVector.push_back(T);
2689 }
2690
2691 void lsquare::ReceiveTrapDamage(character* Damager, int Damage, int Type, int Direction)
2692 {
2693   std::vector<trap*> TrapVector;
2694   FillTrapVector(TrapVector);
2695
2696   for(uInt c = 0; c < TrapVector.size(); ++c)
2697     TrapVector[c]->ReceiveDamage(Damager, Damage, Type, Direction);
2698 }
2699
2700 truth lsquare::HasDangerousTraps(ccharacter* Who) const
2701 {
2702   for(trap* T = Trap; T; T = T->Next)
2703     if(T->IsDangerous(Who))
2704       return true;
2705
2706   return false;
2707 }
2708
2709 truth lsquare::HasDangerousFluids(ccharacter* Who) const
2710 {
2711   for(const fluid* F = Fluid; F; F = F->Next)
2712     if(F->IsDangerous(Who))
2713       return true;
2714
2715   return false;
2716 }
2717
2718 truth lsquare::HasNoBorderPartners() const
2719 {
2720   return !(GroundBorderPartnerInfo >> 24) && !(OverBorderPartnerInfo >> 24);
2721 }
2722
2723 void lsquare::AddLocationDescription(festring& String) const
2724 {
2725   if(IsFlyable())
2726     GLTerrain->AddLocationDescription(String);
2727   else
2728     OLTerrain->AddLocationDescription(String);
2729 }
2730
2731 truth lsquare::VomitingIsDangerous(ccharacter* Char) const
2732 {
2733   return ((OLTerrain && OLTerrain->VomitingIsDangerous(Char))
2734     || (Character && Character->GetTeam() != Char->GetTeam()
2735         && Character->GetRelation(Char) != HOSTILE));
2736 }
2737
2738 bool lsquare::TeleportAllSmokeAway()
2739 {
2740   return false;
2741 }
2742
2743 bool lsquare::TeleportAllFluidsAway()
2744 {
2745   return false;
2746 }
2747
2748 bool lsquare::TeleportAllTrapsAway()
2749 {
2750   for(trap* T = Trap; T; T = Trap)
2751   {
2752     T->Untrap();
2753     RemoveTrap(T);
2754     v2 V, Pos = GetPos();
2755     for(V = GetLevel()->GetRandomSquare(); V != Pos; V = GetLevel()->GetRandomSquare());
2756     GetNearLSquare(V)->AddTrap(T);
2757   }
2758
2759   return false;
2760 }
2761
2762 void lsquare::AddSpecialCursors()
2763 {
2764   if((FowMemorized || game::GetSeeWholeMapCheatMode()) && OLTerrain)
2765     OLTerrain->AddSpecialCursors();
2766 }