root/trunk/MobFormat.cpp

///////////////////////////////////////////////////////////
//                      MobSurgeon                       //
//          Ðåäàêòîð mob-îâ äëÿ Ïðîêëÿòûõ Çåìåëü         //
//           Copyright (C) 2005-2007 Gipat Group         //
//              Ðàñïðîñòðàíÿåòñÿ íà óñëîâèÿõ             //
//    Gipat Group's opened EI-editor-utility license     //
//                      âåðñèè 1.0                       //
//                                                       //
//                  www.gipatgroup.org                   //
///////////////////////////////////////////////////////////

//Ê ðàáîòå íàä äàííûì ôàéëîì ïðèëîæèëè ðóêè, íîãè.... êîðî÷å àôôòàðû:
// 1) Sagrer (sagrer@yandex.ru)

////////////////////////////////////////////////////////////////////////

//---------------------------------------------------------------------------


#pragma hdrstop

#include "MobFormat.h"
#include <Dialogs.hpp>
#include "MainForm.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)

TMobLoaderThread *MobLoaderThr;
TMobSaverThread *MobSaverThr;

TMob::TMob()
{
  //Êîíñòðóêòîð.
  UsingThread = false;
  Loading = false;
  Saving = false;
  SaveAttempts = 10;  //Ïî óìîë÷àíèþ ïîñëå ñáîÿ ïûòàòüñÿ ñäåëàòü ñàâ åùå 10 ðàç.
  TailSize = 0;

  UnloadMob();  //Èíôà î ìîáå - èíèöèàëèçîâàòü.
}

TMob::~TMob()
{
  //Äåñòðóêòîð.
  //Óáèðàåò ìóñîð
  UnloadMob();

}

void TMob::UnloadMob()
//Òèïà ÷èñòèò êëàññ îò èíôû íà ñëó÷àé åñëè ìîá äî ýòîãî çàãðóæàëñÿ óæå.
{
  FullLogStr = "";
  LastLogMessage = "";
  NewMessageSent = false;
  UnknownBlocks.Length = 0;

  if (TailSize > 0)
  {
    //Î÷èñòèòü ïàìÿòü, çàíÿòóþ ïîä õâîñò.
    delete Tail;
    TailSize = 0;
  };
  MobLoaded = false;     //Âñå, òèïà äàæå åñëè ìîá áûë çàãðóæåí - òåïåðü íè÷å íå çàãðóæåíî.
  CurrBlockSgn = false;

  //Èíôà î áëîêàõ...
  ScriptBlockExists = false;   //Áëîê ñêðèïòà...
  ClearObjectsBlockInfo();     //Áëîê îáúåêòîâ...

};

void TMob::ClearObjectsBlockInfo()
//×èñòèò êëàññ îò èíôû îòíîñÿùåéñÿ ê áëîêó îáúåêòîâ...
{
  UnknObjs.Length = 0;
  UnitObjs.Length = 0;
  ObjectObjs.Length = 0;
  LeverObjs.Length = 0;
  TrapObjs.Length = 0;
  FlameObjs.Length = 0;
  Particle1Objs.Length = 0;
  Particle2Objs.Length = 0;
  Particle3Objs.Length = 0;

  ObjectsBlockExists = false;
};

bool TMob::LoadMob(String& FileName)
//Ãðóçèò ìîá â îáúåêò.
{
  bool Result = false;

  //Ïåðåèíèöèàëèçàöèÿ ïåðåìåííûõ è î÷èñòêà ìóñîðà...
  UnloadMob();

  Loading = true;  //Òèïà ÷òîá çíàòü ÷òî ùà çàãðóæàåìñÿ...
  if (UsingThread == false)
  {
    //Åñëè íèòêà íå èñïîëüçóåòñÿ
    Result = ReallyLoadMob(FileName);
  }
  else
  {
    //Åñëè èñïîëüçóåòñÿ íèòêà.
    //Ñîçäàòü íèòêó...
    MobLoaderThr = new TMobLoaderThread(true);
    //Ïåðåäàòü íóæíóþ íèòêå èíôó...
    MobLoaderThr->FileName = FileName;
    MobLoaderThr->PMobObj = this; //Ññûëêà íà îáúåêò êëàññà TMob - ÷òîá ó íèòêè
                                  //áûë ê íåìó äîñòóï.
    //Î÷èñòèòü ðåäàêòîð ëîãà.
    //LogEd->Lines->Clear();
    //È çàôîêóñèòü - ÷òîá ëîã ïðîêðó÷èâàëñÿ ïî ìåðå âûâîäà.
    //Ôîêóñèòü - òîëüêî åñëè àêòèâåí òàá ñ ëîãîì...
    if (MainF->MainF_PK->ActivePage->Name == "LogSh")
    {
      LogEd->SetFocus();
    };  

    //Íà÷àòü âûïîëíåíèå íèòêè...
    MobLoaderThr->Resume();

    //Äîæäàòüñÿ çàâåðøåíèÿ ðàáîòû íèòêè...
    do
    {
      Application->ProcessMessages();

      //Ïðîâåðèòü, íåò ëè íîâîé èíôû...
      if (NewMessageSent == true)
      {
        //Ïðèøëà íîâàÿ ìåññàãà â ëîã. Âûâåñòè åå.
        LogEd->Lines->Add(LastLogMessage);
        NewMessageSent = false;
        //È ðàçìîðîçèòü íèòêó, êîòîðàÿ çàìîðîçèëà ñàìà ñåáÿ....
        MobLoaderThr->Resume();
        
      };
    } while (MobLoaderThr->Finished != true);

    //Çàïîìíèòü ðåçóëüòàò...
    Result = MobLoaderThr->result;

    UsingThread = false;
  };

  Loading = false;  //Âñå, áîëüøå íå çàãðóæàåìñÿ...

  return Result;  //È âåðíóòü ðåçóëüòàò...

};

bool TMob::SaveMob(String& FileName)
//Ñåéâèò ìîá èç îáúåêòà.
{
  bool Result = false;

  //Ïåðåèíèöèàëèçàöèÿ ïåðåìåííûõ è î÷èñòêà ìóñîðà...
  FullLogStr = "";
  LastLogMessage = "";
  NewMessageSent = false;

  Saving = true;   //Òèïà íà÷èíàåì ñåéâèòüñÿ...
  if (UsingThread == false)
  {
    //Åñëè íèòêà íå èñïîëüçóåòñÿ
    Result = ReallySaveMob(FileName);
  }
  else
  {
    //Åñëè èñïîëüçóåòñÿ íèòêà.
    //Ñîçäàòü íèòêó...
    MobSaverThr = new TMobSaverThread(true);
    //Ïåðåäàòü íóæíóþ íèòêå èíôó...
    MobSaverThr->FileName = FileName;
    MobSaverThr->PMobObj = this; //Ññûëêà íà îáúåêò êëàññà TMob - ÷òîá ó íèòêè
                                  //áûë ê íåìó äîñòóï.
    //Î÷èñòèòü ðåäàêòîð ëîãà.
    //È çàôîêóñèòü - ÷òîá ëîã ïðîêðó÷èâàëñÿ ïî ìåðå âûâîäà.
    if (MainF->MainF_PK->ActivePage->Name == "LogSh")
    {
      LogEd->SetFocus();
    };  

    //Íà÷àòü âûïîëíåíèå íèòêè...
    MobSaverThr->Resume();

    //Äîæäàòüñÿ çàâåðøåíèÿ ðàáîòû íèòêè...
    do
    {
      Application->ProcessMessages();

      //Ïðîâåðèòü, íåò ëè íîâîé èíôû...
      if (NewMessageSent == true)
      {
        //Ïðèøëà íîâàÿ ìåññàãà â ëîã. Âûâåñòè åå.
        LogEd->Lines->Add(LastLogMessage);
        NewMessageSent = false;
        //È ðàçìîðîçèòü íèòêó, êîòîðàÿ çàìîðîçèëà ñàìà ñåáÿ....
        MobSaverThr->Resume();
        
      };
    } while (MobSaverThr->Finished != true);

    //Çàïîìíèòü ðåçóëüòàò...
    Result = MobSaverThr->result;
    
    UsingThread = false;
  };
  Saving = false;  //Âñå, çàñåéâèëèñü...

  return Result;
};

void TMob::StringToLog(String& message)
//Äîáàâëÿåò ìåññàãó â ëîã.
{
  //Äîáàâèü ìåññàã â îáùèé ëîã
  FullLogStr = FullLogStr+message+char(13)+char(10);

  //Åñëè èñïîëüçóåòñÿ íèòêà - äîáàâèòü è ïîñëåäíþþ ìåññàãó:
  if (UsingThread == true)
  {
    if (Loading == true)
    {
      //Åñëè èäåò çàãðóçêà...
      //Âûçâàòü ôóíêöèþ îáúåêòà òðåäà, ÷òîá îíà ñèíõðîíèçîâàëà
      MobLoaderThr->SynchrLogMess(message);
    };

    if (Saving == true)
    {
      //Åñëè èäåò ñåéâèíã...
      //Âûçâàòü ôóíêöèþ îáúåêòà òðåäà, ÷òîá îíà ñèíõðîíèçîâàëà
      MobSaverThr->SynchrLogMess(message);
    };
  };
  
};

bool TMob::ReallyLoadMob(String& FileName)
//Ðåàëüíî çàãðóæàåò ìîá. Ìîæåò ðàáîòàòü èç íèòêè.
{
  //Ëîêàëüíûå ïåðåìåííûå...
  DWORD ChetireBaita, BlockSignature;
  bool Result = false;
  bool AllOk = true;
  DWORD MainBlock_Size, CurrBlockSize = 0;
  __int64 Cursor = 0;
  __int64 FileSize, VosemBaitov = 0;
  int BlockNumber = 1;
  byte *TempBuff;

  //Â ëîãå - íàðèñîâàü îòäåëèòåëü - äëÿ êðàñîòû :)
  StringToLog("");
  StringToLog("-----------------------------");
  //Èòàê.  íà÷àëå íàäî çàãðóçèòü ôàéë.
  TFileStream *File1;
  if (FileExists(FileName) == true)
  {
    //Òîëüêî åñëè ôàéëî ñóùåñòâóåò.
    StringToLog(FileName);
    StringToLog("Ôàéëî ñóùåñòâóåò... îòêðûâàþ...");
    //Ñîçäàòü ïîòîê...
    TFileStream *File1;
    try
    {
      File1 = new TFileStream(FileName,fmOpenRead);
    }
    catch (...)
    {
      StringToLog("Íå ìîãó ïîëó÷èòü äîñòóï ê ôàéëó!");
      AllOk = false;
      goto StopLoadMob_noloaded_Label;
    };

    //Ïîäãîòîâèòü ïàìÿòü ïîä ôàéë.
    FileSize = File1->Size;
    byte *File1Loaded;
    File1Loaded = new byte[FileSize];

    //Ãðóçàíóòü ôàéë â ïàìÿòü
    File1->Read(File1Loaded,FileSize);
    //Óáèòü ïîòîê... îí áîëüøå íå íóæåí.
    delete File1;

    //À âîò òåïåðü, ñîáñòâåííî - ìîæíî è çàãðóçèòü èíôó â ïåðåìåííûå êëàññà.

    //Äëÿ íà÷àëà - ïðîâåðèòü, ìîá ëè ýòî âîîáùå.
    Cursor = 0;
    memcpy(&ChetireBaita,&File1Loaded[Cursor],4);
    Cursor = Cursor+4;
    if (ChetireBaita == MobSignature)
    {
      //Åñëè ýòî íîðìàëüíûé ìîá
      StringToLog("Ýòî íîðìàëüíûé ìîá");

      //Íó è ñîáñíî òåïåðü - ìîæíî òèïà íà÷èíàòü òèïà ãðóçèòü òèïà ìîá :).

      //Ïîëó÷èòü ðàçìåð ïåðâîãî áëîêà ìîáà.
      memcpy(&ChetireBaita,&File1Loaded[Cursor],4);
      Cursor = Cursor+4;
      MainBlock_Size = ChetireBaita;
      StringToLog("Îñíîâíîé áëîê ìîáà âåñèò "+IntToStr(MainBlock_Size)+" áàéò.");

      if (MainBlock_Size < FileSize)
      {
        //Åñëè ïîñëå îñíîâíîãî áëîêà åñòü åùå ÷åãî-òî
        StringToLog("Ýòî ìåíüøå ðàçìåðà ôàéëà ("+IntToStr(FileSize)+" áàéò) - ÎÁÍÀÐÓÆÅÍ ÕÂÎÑÒ! :)");
        TailSize = FileSize-MainBlock_Size;  //È ñðàçó-æå ïîäñ÷èòàòü è çàïîìíèòü ðàçìåð õâîñòà :).
      };

      if (MainBlock_Size > FileSize)
      {
        //Åñëè ðàçìåð áëîêà áîëüøå ðàçìåðà ôàéëà - òî ýòî áðåä êàêîé-òî...
        //Çàãðóçêà òèïà îòìåíÿåòñÿ...
        StringToLog("Îñíîâíîé áëîê ìîáà âåñèò "+IntToStr(MainBlock_Size)+" áàéò. - ýòî áîëüøå ðàçìåðà ôàéëà! ("+IntToStr(FileSize)+" áàéò).");
        AllOk = false;
        goto StopLoadMobLabel;
      };

      //Åñëè ðàçìåð áëîêà íå áîëüøå ðàçìåðà ôàéëà òî ïðîäîëæàòü...

      //×òåíèå ãëàâíîãî áëîêà...

      //Ïðîâåðèòü ïåðâûé áëîê
      memcpy(&VosemBaitov,&File1Loaded[Cursor],8);
      Cursor = Cursor+8;
      if ((VosemBaitov != MainBlock_QuestMob) && (VosemBaitov != MainBlock_ZonalMob))
      {
        //Êàêîé-òî íåñòàíäàðòíûé âòîðîé áëîîê.
        // äàííûé ìîìåíò - ýòî ïðèâåäåò ê íå÷èòàáåëüíîñòè ìîáà.
        StringToLog("Ïåðâûé áëîê ãëàâíîãî áëîêà íåñòàíäàðòåí. Çàãðóçêà îòìåíåíà.");
        AllOk = false;
        goto StopLoadMobLabel;
      }
      else if (VosemBaitov == MainBlock_QuestMob)
      {
        //Êâåñòîâûé ìîá.
        MobType = "QuestMob";
        StringToLog("Ìîá ïîìå÷åí êàê êâåñòîâûé.");
      }
      else if (VosemBaitov == MainBlock_ZonalMob)
      {
        //Çîíàëüíûé ìîá.
        MobType = "ZonalMob";
        StringToLog("Ìîá ïîìå÷åí êàê çîíàëüíûé.");
      };

      //Ïåðâûé áëîê ñòàíäàðòåí, ìîæíî ïðîäîëæàòü...
      BlocksInMob = 1;

      //Òåïåðü ñîáñíî - íàäî èäòè òèïà ïî áëîêàì :). Ïîêà âñå áëîêè íå áóäóò çàãðóæåíû,
      //ëèáî ïîêà ÷òî-òî òàì íå îáëîìèòñÿ.
      do
      {
        //Ïîëó÷èòü òèï áëîêà.
        memcpy(&ChetireBaita,&File1Loaded[Cursor],4);
        Cursor = Cursor+4;
        BlockSignature = ChetireBaita;  //×òîá îñâîáîäèòü áóôôåð
        BlocksInMob = BlocksInMob+1;    //Ïîñ÷èòàòü íàéäåííûé áëîê.

        //Òåïåðü â çàâèñèìîñòè îò òèïà áëîêà...
        if (BlockSignature == TextBlockSgn)
        {
          //Òèïà áëîê ñêðèïòà.
          BlockNumber = BlockNumber+1;  //Òèïà óâåëè÷èòü íîìåð áëîêà :).
          ScriptBlockExists = true;  //Îòìåòèòü ÷òî áëîê ñóùåñòâóåò :).

          //Ïîëó÷èòü ðàçìåð áëîêà
          memcpy(&ChetireBaita,&File1Loaded[Cursor],4);
          Cursor = Cursor+4;
          CurrBlockSize = ChetireBaita;  //Âîò òóò ñîáñíî ðàçìåð.

          //Ïðî÷èòàòü áëîê òèïà öåëèêîì :)
          TempBuff = new byte[CurrBlockSize];
          Cursor = Cursor-8;  //Îòêàòèòü êóðñîð íàçàä ÷òîá ñ÷èòàòü öåëüíûé áëîê...
          memcpy(&TempBuff[0],&File1Loaded[Cursor],CurrBlockSize);
          Cursor = Cursor+CurrBlockSize;

          //Ñêîðìèòü òî ÷òî ïðî÷èòàíî ôóíêöèè-ðàñêîâûðèâàëêå áëîêà.
          ReadScriptBlock(TempBuff,CurrBlockSize);

          //Î÷èñòèòü áóôôåð
          delete TempBuff;

          //È ñîîáùèòü â ëîã î ñ÷èòàííîì áëîêå...
          StringToLog("Çàãðóæåí ñêðèïò äëèíîé "+IntToStr(ScriptText.Length())+" áàéò. Áëîê ¹ "+IntToStr(BlockNumber)+". Äëèíà âñåãî áëîêà "+IntToStr(CurrBlockSize)+" áàéò.");
        }

        else if (BlockSignature == ObjectsBlockSgn)
        {
          //Òèïà áëîê îáúåêòîâ.
          BlockNumber = BlockNumber+1;  //Òèïà óâåëè÷èòü íîìåð áëîêà :).
          //Îòìåòêó î òîì ÷òî áëîê ñóùåñòâóåò ïîñòàâèò ôóíêöèÿ, ñ÷èòûâàþùàÿ áëîê :).

          //Ïîëó÷èòü ðàçìåð áëîêà
          memcpy(&ChetireBaita,&File1Loaded[Cursor],4);
          Cursor = Cursor+4;
          CurrBlockSize = ChetireBaita;  //Âîò òóò ñîáñíî ðàçìåð.

          //Ïðî÷èòàòü áëîê òèïà öåëèêîì :)
          TempBuff = new byte[CurrBlockSize];
          Cursor = Cursor-8;  //Îòêàòèòü êóðñîð íàçàä ÷òîá ñ÷èòàòü öåëüíûé áëîê...
          memcpy(&TempBuff[0],&File1Loaded[Cursor],CurrBlockSize);
          Cursor = Cursor+CurrBlockSize;

          //Ñêîðìèòü òî ÷òî ïðî÷èòàíî ôóíêöèè-ðàñêîâûðèâàëêå áëîêà.
          AllOk = ReadObjectsBlock(TempBuff,CurrBlockSize);
          if (AllOk == false)
          {
            //Åñëè áûë òèïà ñáîé ïðè ÷òåíèè áëîêà - òî àààáëîì.
            goto StopLoadMobLabel;
          };

          //Î÷èñòèòü áóôôåð
          delete TempBuff;

          //È ñîîáùèòü â ëîã î ñ÷èòàííîì áëîêå...
          StringToLog("Çàãðóæåí áëîê îáúåêòîâ äëèíîé "+IntToStr(CurrBlockSize)+" áàéò. Áëîê ¹ "+IntToStr(BlockNumber)+".");
          StringToLog("Â áëîêå íàéäåíî "+IntToStr(UnitObjs.Length)+" þíèòîâ.");
          StringToLog("Â áëîêå íàéäåíî "+IntToStr(ObjectObjs.Length)+" îáúåêòîâ.");
          StringToLog(" áëîêå íàéäåíî "+IntToStr(LeverObjs.Length)+" ðû÷àãîâ.");
          StringToLog("Â áëîêå íàéäåíî "+IntToStr(TrapObjs.Length)+" ëîâóøåê.");
          StringToLog("Â áëîêå íàéäåíî "+IntToStr(FlameObjs.Length)+" ôëåéìîâ.");
          StringToLog("Â áëîêå íàéäåíî "+IntToStr(Particle1Objs.Length)+" ïàðòèêëîâ 1-ãî òèïà.");
          StringToLog("Â áëîêå íàéäåíî "+IntToStr(Particle2Objs.Length)+" ïàðòèêëîâ 2-ãî òèïà.");
          StringToLog("Â áëîêå íàéäåíî "+IntToStr(Particle3Objs.Length)+" ïàðòèêëîâ 3-ãî òèïà.");
          StringToLog("Â áëîêå íàéäåíî "+IntToStr(UnknObjs.Length)+" îáúåêòîâ íåèçâåñòíîãî òèïà.");
        }

        else
        {
          BlockNumber = BlockNumber+1;  //Òèïà óâåëè÷èòü íîìåð áëîêà :).
          //Åñëè òèï áëîêà íåèçâåñòåí.
          //Òî áëîê ïðîñòî ÷èòàåòñÿ êàê íåèçâåñòíûé.

          UnknownBlocks.Length = UnknownBlocks.Length+1; //Äîáàâèòü íîâûé ýëåìåíò.
          //Ïîëó÷èòü ðàçìåð áëîêà
          memcpy(&ChetireBaita,&File1Loaded[Cursor],4);
          Cursor = Cursor+4;

          //È çàïîìíèòü èíôó áëîêà...
          UnknownBlocks[UnknownBlocks.High].BlockSize = ChetireBaita;
          UnknownBlocks[UnknownBlocks.High].BlockNumber = BlockNumber;
          UnknownBlocks[UnknownBlocks.High].BlockContent = new byte[ChetireBaita];
          Cursor = Cursor-8; //×òîá ÷èòàòü áëîê ñ ñàìîãî íà÷àëà.
          memcpy(&UnknownBlocks[UnknownBlocks.High].BlockContent[0],&File1Loaded[Cursor],ChetireBaita);
          Cursor = Cursor+ChetireBaita;

          //Íó è â ëîã ñîîáùèòü ïðî ýòî äåëî :).
          StringToLog("Ñ÷èòàí áëîê íåèçâåñòíîãî òèïà. Âñòðåòèëñÿ ïîä íîìåðîì "+IntToStr(BlockNumber)+".");
        }; //Ïîñëåäíèé else  

      } while (Cursor != MainBlock_Size);

      //À òåïåðü - åñëè ó ìîáà áûë "õâîñò" - òî íàäî ýòîò õâîñò òîæå çàïîìíèòü :).
      if (TailSize > 0)
      {
        Tail = new byte[TailSize];
        memcpy(&Tail[0],&File1Loaded[Cursor],TailSize);
        Cursor = Cursor+TailSize;
        StringToLog("Ïðî÷èòàí õâîñò äëèíîé "+IntToStr(TailSize)+" áàéò.");
      };

      //Ïðîâåðêà ïîëîæåíèÿ êóðñîðà...
      if (Cursor == FileSize)
      {
        //Åñëè êóðñîð ñòîèò â êîíöå ôàéëà - çíà÷èò òèïà âñå îê :).
        StringToLog("Êóðñîð ñòîèò â êîíöå ôàéëà - çíà÷èò âñÿ èíôà çàãðóæåíà â îáúåêò êëàññà.");
        Result = true;
        MobLoaded = true;  //Ïîìåòèòü, ÷òî ìîá çàãðóæåí â îáúåêò.
      };

    }
    else
    {
      //Ýòî íå ìîá íèõðåíà!
      StringToLog("Ýòî íå ìîá íèõðåíà!");
      AllOk = false;
    };

    StopLoadMobLabel:  //Ñþäà áóäåò ñêà÷åê åñëè âîçíèêíåò îøèáêà â ïðîöåññå çàãðóçêè
    ;
    //Ïî÷èñòèòü ìóñîð
    //Óáèòü óêàçÿâó íà ïàìÿòü, êóäà ãðóçèëñÿ ôàéë
    delete File1Loaded;
    StopLoadMob_noloaded_Label:   //À ñþäà - åñëè íå óäàñòñÿ îòêðûòü ôàéë.
    ;
  };

  //Òèïà ïðîöåññ çàâåðøåí. Âåðíóòü ðåçóëüòàò, à òàêæå ñîîáùèòü â ëîã
  //îá ócïåõå\íåóñïåõå îïåðàöèè.
  if (Result == true)
  {
    StringToLog("Ìîá çàãðóæåí óñïåøíî!");
  }
  else
  {
    StringToLog("Çàãðóçèòü ìîá íå óäàëîñü!");
  };

  //Ïî ïðè÷èíå âñòðå÷è ñ íåïîíÿòíûìè ãëþêàíÿðàìè

  return Result;
};

bool TMob::ReallySaveMob(String& FileName)
//Ðåàëüíî ñåéâèò ìîá. Ìîæåò ðàáîòàòü èç íèòêè.
{
  //Ëîêàëüíûå ïåðåìåííûå...
  DWORD ChetireBaita, BlockSignature;
  bool Result, BlockWrote, SgnFinded = false;
  bool AllOk = true, FileSaved = true;
  DWORD MainBlock_Size, CurrBlockSize, SizeAdress = 0;
  __int64 Cursor = 0;
  __int64 FileSize, VosemBaitov = 0;
  int BlockNumber = 1;
  int i;   //Ñ÷åò÷èê :).
  DynamicArray <byte> SaveBuffer;   //Â ýòîò ìàññèâ ñîáñíî è áóäåò çàïèñûâàòüñÿ èíôà ïåðåä ñåéâîì....
  byte *TempBuff;   //Âðåìåííûé áàéòîâûé ìàññèâ...
  DynamicArray <byte> TempBuff2;  //Äèíàìè÷åñêèé âðåìåííûé áàéòîâûé ìàññèâ...

  //Ñîáñíî ñàìà ôóíêöèÿ...

  //Ïðî÷èñòèòü ñëóæåáíûå ïåðåìåííûå...
  CurrBlockSgn = 0;
  AllKnownBlocksSaved = false;

  //Â ëîãå - íàðèñîâàü îòäåëèòåëü - äëÿ êðàñîòû :)
  StringToLog("");
  StringToLog("-----------------------------");
  //StringToLog("Çàïóùåíà ñåéâèëêà...");

  if (MobLoaded == true)
  {
    //Åñëè ìîá õîòü ðàç áûë çàãðóæåí è âîîîáùå åñòü ÷åãî ñîõðàíÿòü...
    //Çàïèñàòü ñèãíàòóðó ìîáà...
    SaveBuffer.Length = Cursor+4;
    memcpy(&SaveBuffer[Cursor],&MobSignature,4);
    Cursor = Cursor+4;
    StringToLog("Ñèãíàòóðà çàïèñàíà...");

    //Äëèíó ãëàâíîãî áëîêà âðåìåííî çàáèòü íóëÿìè...
    SaveBuffer.Length = Cursor+4;
    ChetireBaita = 0;
    memcpy(&SaveBuffer[Cursor],&ChetireBaita,4);
    Cursor = Cursor+4;

    //Â çàâèñèìîñòè îò òèïà ìîáà - ïîëîæèòü ñîîòâ. áëîê-ìåòêó...
    if (MobType == "QuestMob")
    {
      SaveBuffer.Length = Cursor+8;
      memcpy(&SaveBuffer[Cursor],&MainBlock_QuestMob,8);
      Cursor = Cursor+8;
      StringToLog("Ìîá ïîìå÷åí êàê êâåñòîâûé...");
    }
    else if (MobType == "ZonalMob")
    {
      SaveBuffer.Length = Cursor+8;
      memcpy(&SaveBuffer[Cursor],&MainBlock_ZonalMob,8);
      Cursor = Cursor+8;
      StringToLog("Ìîá ïîìå÷åí êàê çîíàëüíûé...");
    };

    //À òåïåðü - çàêèäàòü òóäû âîâíóòðü ðàçíûå áëîêè.
    //Çàïèñûâàòü áëîêè ëèáî ïî ïîðÿäêó, ïðîâåðÿÿ íåèçâåñòíûå áëîêè,
    //ëèáî, åñëè áëîê ñ íóæíûì íîìåðîì ñðåäè íåèçâåñòíûõ íå íàéäåí -
    //ïî ñòàíäàðòíîìó ïîðÿäêó :).

    do
    {
      //Óâåëè÷èòü íîìåð áëîêà.
      BlockNumber = BlockNumber+1;

      BlockWrote = false;   //Èíäèêàòîð....

      //Ïðîâåðèòü, åñòü ëè ñðåäè íåèçâåñòíûõ áëîê ñ òàêèì íîìåðîì...
      for(i = 0;i<=UnknownBlocks.High;i++)
      {
        //Òèïà ïðîáåæàòüñÿ ïî ñïèñêó áëîêîâ :).
        if (UnknownBlocks[i].BlockNumber == BlockNumber)
        {
          //Íàøëè áëîê, êîòîðûé õî÷åò çàïèñàòüñÿ ïîä ýòèì íîìåðîì :).

          //Íó çíà÷èò - ïèøåì! :).
          SaveBuffer.Length = Cursor+UnknownBlocks[i].BlockSize;
          memcpy(&SaveBuffer[Cursor],&UnknownBlocks[i].BlockContent[0],UnknownBlocks[i].BlockSize);
          Cursor = Cursor+UnknownBlocks[i].BlockSize;
          StringToLog("Ïîä íîìåðîì "+IntToStr(BlockNumber)+" çàïèñàí áëîê íåèçâåñòíîãî òèïà.");

          BlockWrote = true;  //Èíäèêàòîð ÷òî áëîê óæå çàïèñàí.

          i = UnknownBlocks.High;  //×òîá áîëüøå ïî ñïèñêó íå øàðèòü...
        };
      };

      //Òåîðåòè÷åñêè - åñëè áëîê åùå íå áûë çàïèñàí - çàïèñàòü áëîê èçâåñòíîãî
      //òèïà, èäóùèé "ïî ïîðÿäêó".

      if (AllKnownBlocksSaved == false)
      {
        //Òîêà åñëè âñå áëîêè åùå íå çàïèñàíû...
        if (BlockWrote == false)
        {
          //Ñîáñíî - ïèñàòü òîò áëîê èçâåñòíîãî òèïà, ÷úÿ ïðèøëà î÷åðåäü.

          //Îïðåäåëèòü - êàêîé èç áëîêîâ ñåéâèòü...
          SgnFinded = false;
          do
          {
            //Ïîëó÷èòü î÷åðåäíóþ ñèãíàòóðó...
            CurrBlockSgn = GetNextBlockSgn(CurrBlockSgn);

            //Ïðîâåðèòü, ñóùåñòâóåò ëè â ìîáå íóæíûé áëîê.
            if (CurrBlockSgn == 0)
            {
              //Îáíàðóæåí ñèãíàë çàâåðøåíèÿ ïîèñêà...
              SgnFinded = true;
            }
            else if (CurrBlockSgn == TextBlockSgn)
            {
              //Áëîê ñêðèïòà.
              if (ScriptBlockExists == true)
              {
                SgnFinded = true;
              };
            }
            else if (CurrBlockSgn == ObjectsBlockSgn)
            {
              //Áëîê îáúåêòîâ.
              if (ObjectsBlockExists == true)
              {
                SgnFinded = true;
              };
            };
          }
          while (SgnFinded != true);

          //À òåïåðü - â çàâèñèìîñòè îò òîãî, êàêîé áëîê "ðåøåíî" ñîõðàíèòü...
          if (CurrBlockSgn == 0)
          {
            //Îáíàðóæåí ñèãíàë çàâåðøåíèÿ ïîèñêà...
            //íó òèïà âñå, áîëüøå áëîêè èçâåñòíîãî òèïà ñåéâèòüñÿ íå áóäóò...
            AllKnownBlocksSaved = true;
          }
          else if (CurrBlockSgn == TextBlockSgn)
          {
            //Áëîê ñêðèïòà.

            //Ïîäãîòîâèòü áóôôåð...
            TempBuff2.Length = 0;

            //Íó è - ñ÷èòàòü â íåãî èíôó :).
            GenScriptBlock(TempBuff2);

            //À òåïåðü - çàïèñàòü áëîê â áóäóþùèé ôàéë :).
            SaveBuffer.Length = Cursor+TempBuff2.Length;
            memcpy(&SaveBuffer[Cursor],&TempBuff2[0],TempBuff2.Length);
            Cursor = Cursor+TempBuff2.Length;

            StringToLog("Ïîä íîìåðîì "+IntToStr(BlockNumber)+" çàïèñàí áëîê ñêðèïòà äëèíîé "+IntToStr(TempBuff2.Length)+" áàéò.");
            BlockWrote = true;  //Èíäèêàòîð ÷òî áëîê óæå çàïèñàí.

            //Íó è ïðî÷èñòèòü áóôôåð...
            TempBuff2.Length = 0;

          }
          else if (CurrBlockSgn == ObjectsBlockSgn)
          {
            //Áëîê îáúåêòîâ.

            //Ïîäãîòîâèòü áóôôåð...
            TempBuff2.Length = 0;

            //Íó è - ñ÷èòàòü â íåãî èíôó :).
            GenObjectsBlock(TempBuff2);

            //À òåïåðü - çàïèñàòü áëîê â áóäóþùèé ôàéë :).
            SaveBuffer.Length = Cursor+TempBuff2.Length;
            memcpy(&SaveBuffer[Cursor],&TempBuff2[0],TempBuff2.Length);
            Cursor = Cursor+TempBuff2.Length;

            StringToLog("Ïîä íîìåðîì "+IntToStr(BlockNumber)+" çàïèñàí áëîê îáúåêòîâ äëèíîé "+IntToStr(TempBuff2.Length)+" áàéò.");
            BlockWrote = true;  //Èíäèêàòîð ÷òî áëîê óæå çàïèñàí.

            //Íó è ïðî÷èñòèòü áóôôåð...
            TempBuff2.Length = 0;
            
          };

        };  //if (BlockWrote == false)
      };  //if (AllKnownBlocksSaved == false)

    }
    while (BlockNumber != BlocksInMob);

    //Ïîñêîëüêó óæå çàïèñàí ãëàâíûé áëîê ìîáà - òî ñòîèò ïîäñ÷èòàòü åãî äëèíó
    //(â ïðèíöèïå îíà èçâåñòíà - ýòî êóðñîð :) ), è çàïèñàòü åž êóäà ñëåäóåò...
    ChetireBaita = Cursor;
    memcpy(&SaveBuffer[4],&ChetireBaita,4);
    StringToLog("Çàïèñàíà äëèíà ãëàâíîãî áëîêà...");

    //Òàê. Òåïåðü íàäî ïîðàáîòàòü íàä õâîñòîì. Åñëè õâîñòà íåòó íèôèãà
    // - òî êîíå÷íî ìîæíî çàáèòü, à âîò åñëè õâîñò åñòü - ïðèäåòñÿ åãî
    //ïðèêðåïëÿòü ê... ýýý... çàäíåé ÷àñòè òåëà ìîáà :).

    if (TailSize > 0)
    {
      SaveBuffer.Length = Cursor+TailSize;
      memcpy(&SaveBuffer[Cursor],&Tail[0],TailSize);
      Cursor = Cursor+TailSize;
      StringToLog(" êîíåö ìîáà ïðèñàáà÷åí õâîñò, äëèíîé "+IntToStr(TailSize)+" áàéò.");
    };

    //Òåïåðü - ñîîáùèòü þçâåðþ ðàçìåð ïîëó÷åííîãî ôàéëà...
    StringToLog("Â ðåçóëüòàòå âñåé ýòîé ôèãíè ó íàñ âûëåïèëñÿ ôàéëèê ðàçìåðîì "+IntToStr(Cursor)+" áàéò.");

    //À òåïåðü - òèïà ñàìûé îòâåòñòâåííûé ìîìåíò - íàäî âñþ ýòó ôèãíþ çàñåéâèòü
    //â ðåàëüíûé ôàéë :).

    for (i = 0; i <= SaveAttempts; i++)
    {
      try
      {

        if (FileExists(FileName) == true)
        {
          //Åñëè ôàéë åñòü - óáèòü áåç ëèøíèõ ðàçãîâîðîâ.
          //Ðàçãîâîðû ãîâîðèòü â ñëó÷àå ÷åãî áóäåò èíòåðôåéñ ïðîãè
          //åùå äî íà÷àëà ñîõðàíåíèÿ... À ìû òóò ðàáîòàåì ïðîñòî -
          //åñëè êàêàÿ-òî ïàäëà ìåøàåò ñäåëàòü ñåéâ - çàìî÷èòü åå íàôèê :).

          if (DeleteFile(FileName) == true)
          {
            StringToLog("Ôàéë "+FileName+" óäàëåí, ò.ê. íà åãî ìåñòî áóäåò ñîõðàíÿòüñÿ ôàéë.");
          };
        };

        //Òåîðåòè÷åñêè - åñëè è áûë ôàéë ñ òàêèì èìåíåì - åãî óæå äîëæíî íå áûòü :).

        //Ñîçäàåì ôàéë è ïîòîê...
        TFileStream *File1;
        File1 = new TFileStream(FileName,fmCreate);

        //Ïèøåì èíôó â ôàéë...
        File1->Write(&SaveBuffer[0],Cursor);

        //Çàêðûâàåì ôàéë...
        delete File1;

        if (FileExists(FileName) == true)
        {
          //Ñîîáùàåì þçâåðþ î òîì ÷òî ôàéë çàïèñàí.
          StringToLog("Ìîá ñîõðàíåí íà äèñê â ôàéë "+FileName+" .");
          Result = true; //Óñïåøíûé ñåéâ :).
          i = SaveAttempts;
        }
        else
        {
          //Ïî íåïîíÿòíîé ïðè÷èíå íåòó âðîäå áû ñîõðàíåííîãî ôàéëà. Îøèáêó åìó :)
          //òî÷íåå - îòïðàâèòü íà ïîâòîðíûå ñåéâû.
          StringToLog("×Å ÇÀ ÕÅÐÍß!!!!! ÎØÈÁÎÊ ÍÈÕÅÐÀ ÍÅ ÁÛËÎ À ÔÀÉËÀ ÌËß ÍÅÒÓ!!!!!!!!!! ÑÎÎÁÙÈÒÅ ÐÀÇÐÀÁÎÒ×ÈÊÓ!!!!!!");
          StringToLog("Ïûòàþñü ñîõðàíèòü åùå ðàç....");
          //à äëÿ åòîãî è äåëàòü íèôèãà íå íàäî - îíî ñàìî :).
        };
      }
      catch(...)
      {
        //Ïðîèçîøëà êàêàÿ-òî îøèáêà.

        //Ñîîáùàåì þçâåðþ î òîì ÷òî ôàéë íå çàïèñàí.
        StringToLog("Ïî íåïîíÿòíîé ïðè÷èíå íå óäàëîñü ñîõðàíèòü íà äèñê ôàéë "+FileName+" .");

        //È ñêàçàòü ÷òî ùà áóäåò ïîïûòêà ñäåëàòü åùå 1 ñåéâ...
        if (i < SaveAttempts)
        {
          StringToLog("Ïûòàþñü ñîõðàíèòü åùå ðàç....");
        };
      };
    };

    if ( (FileExists(FileName) == false) && (Result == false) )
    {
      //Êîðî÷å ïîñëå 10 ïîïûòîê íèõåðà íå ñîõðàíèëîñü.
      StringToLog("ÅÒÀ ÏÈÏÅÖ ÒÐÙ ÊÀÌÀÍÄÈÐ!!! ÍÈÕÅÐÀ ÍÅ ÑÀÂÈÒÑß!!! È ÔÀÉË ÓÃÐÎÁÈËÑß!!! ÍÎ ÎÍ ÅÙÅ Â ÏÀÌßÒÈ - ÏÎÏÐÎÁÓÉÒÅ ÇÀÑÀÂÈÒÜ ÍÀ ÄÐÓÃÎÅ ÈÌß!!!");
    };
  }
  else
  {
    //Åñëè ñîõðàíÿòü íå÷åãî... ïîñëàòü íàõ :).
    StringToLog(" îáúåêò êëàññà åùå íå áûëî íè÷åãî çàãðóæåíî!!! Ñîõðàíÿòü íå÷åãî!!!");
  };

  if (Result == true)
  {
    //Åñëè ñîõðàíåíèå óñïåøíî...
    StringToLog("Ìîá óñïåøíî ñîõðàíåí :).");
  }
  else
  {
    //Åñëè ñîõðàíåíèå íåóñïåøíî...
    StringToLog("Ìîá íèõðåíà íå ñîõðàíåí :(.");
  };

  return Result;
};

String TMob::DeCodeScript(byte *ScriptTextBytes,DWORD Size,DWORD Key)
//Ôóíêöèÿ äîëæíà òèïà äåêîäèðîâàòü ñêðèïò. È âîçâðàùàòü åãî óæå â âèäå ñòðîêè.
{
  //Ëîêàëüíûå ïåðåìåííûå...
  String Result = "";
  DWORD TmpKey = 0;

  //Ñîáñíî ðàáîòà íàä ñêðèïòîì...
  // íà÷àëå - òèïà ïåðåêîïèðîâàòü ñòðîêó :)
  Result.SetLength(Size);
  memcpy(&Result[1],&ScriptTextBytes[0],Size);

  //Òåïåðü - ðàñêîäèðîâàòü ñêðèïò.
  for (DWORD i=1; i<=Size; i++)
  {
    TmpKey = (((((Key*13) << 4 ) + Key) << 8 ) - Key);
    Key = Key + TmpKey*4 + 2531011;
    TmpKey = Key;
    TmpKey = TmpKey >> 16;
    Result[i] = Result[i] ^ TmpKey;
  };

  return Result;
};

byte* TMob::EnCodeScript(String ScriptTextStr,DWORD Size,DWORD Key)
//Ôóíêöèÿ äîëæíà òèïà çàêîäèðîâàòü ñêðèïò. È âîçâðàùàòü åãî óæå â âèäå ïîñëåäîâàòåëüíîñòè áàéòîâ.
{
  //Ëîêàëüíûå ïåðåìåííûå...
  byte *Result = new byte[Size];
  DWORD TmpKey = 0;

  //Ñîáñíî ðàáîòà íàä ñêðèïòîì...
  // íà÷àëå - òèïà ïåðåêîïèðîâàòü ñòðîêó :)
  memcpy(&Result[0],&ScriptTextStr[1],Size);

  //Òåïåðü - ðàñêîäèðîâàòü ñêðèïò.
  for (DWORD i=0; i<Size; i++)
  {
    TmpKey = (((((Key*13) << 4 ) + Key) << 8 ) - Key);
    Key = Key + TmpKey*4 + 2531011;
    TmpKey = Key;
    TmpKey = TmpKey >> 16;
    Result[i] = Result[i] ^ TmpKey;
  };

  return Result;
};

DWORD TMob::GetNextBlockSgn(DWORD CurrSgn)
//Âîçâðàùàåò ñèãíàòóðó áëîêà êîòîðûé äîëæåí ñåéâèòüñÿ ñëåäóþùèì.
{
  //Ïåðåìåííûå
  DWORD Result = 0;

  //Âûâîä ñèãíàòóðû...
  if (CurrSgn == 0)
  {
    //Âûäàòü ñèãíàòóðó ñàìîãî ïåðâîãî áëîêà - ñêðèïòà.
    Result = TextBlockSgn;
  }
  else if (CurrSgn == TextBlockSgn)
  {
    //Âûäàòü ïîñëåäíþþ ñèãíàòóðó - íîëü - íå áûâàåò íè ó 1 áëîêà.
    Result = ObjectsBlockSgn;
  }
  else if (CurrSgn == ObjectsBlockSgn)
  {
    //Âûäàòü ïîñëåäíþþ ñèãíàòóðó - íîëü - íå áûâàåò íè ó 1 áëîêà.
    Result = 0;
  };

  return Result;
};

///////////////////////////////////
//  ×èòàëêè áëîêîâ
///////////////////////////////////

bool TMob::ReadScriptBlock(byte *Buff, DWORD& Size)
//Áëîê ñêðèïòà.
{
  //Ëîêàëüíûå ïåðåìåííûå...
  DWORD ChetireBaita;
  bool Result = false;
  __int64 Cursor = 0;
  byte *TempBuff;
  DWORD ScriptTextSize = Size - 12; //âûñ÷èòàòü ðàçìåð òåêñòà ñêðèïòà :)

  ScriptText = "";  // ëþáîì ñëó÷àå - ïðî÷èñòèòü ñêðèïò.

  Cursor = Cursor+8;

  //Ïîëó÷èòü êëþ÷
  memcpy(&ChetireBaita,&Buff[Cursor],4);
  Cursor = Cursor+4;
  ScriptKey = ChetireBaita;

  if (ScriptTextSize > 0)
  {
    //Ñ÷èòàòü ñàì ñêðèïò - òîëüêî åñëè îí áîëüøå íóëÿ :).
    TempBuff = new byte[ScriptTextSize];
    memcpy(&TempBuff[0],&Buff[Cursor],ScriptTextSize);
    Cursor = Cursor+ScriptTextSize;

    //Äåêîäèðîâàòü ñêðèïò è çàïèñàòü åãî â ñòðîêó...
    ScriptText = DeCodeScript(TempBuff,ScriptTextSize,ScriptKey);
    delete TempBuff;
  };

  Result = true;
  return Result;
};

bool TMob::ReadObjectsBlock(byte *Buff, DWORD& Size)
//Áëîê îáúåêòîâ.
{
  //Ëîêàëüíûå ïåðåìåííûå...
  DWORD ChetireBaita, CurrBlockSignature, ObjBlockSize, TempDW1,
  MinBlockSgn, MinBlockSize, TempDW2, i;
  bool Result = true;
  __int64 Cursor = 0, StartBlockPos = 0, UnknObjsNum = 0, UnitObjsNum = 0,
  ObjectObjsNum = 0, UnknObjsCurr = -1, UnitObjsCurr = -1, ObjectObjsCurr = -1,
  LeverObjsNum = 0, LeverObjsCurr = -1, TrapObjsNum = 0, TrapObjsCurr = -1,
  FlameObjsNum = 0, FlameObjsCurr = -1, Particle1ObjsNum = 0, Particle1ObjsCurr = -1,
  Particle2ObjsNum = 0, Particle2ObjsCurr = -1, Particle3ObjsNum = 0, Particle3ObjsCurr = -1;
  byte *TempBuff;
  byte TempByte;

  //Èòàê, ñèíãàòóðà áëîêà óæå ñ÷èòàíà, äëèíà áëîêà èçâåñòíà. Íàäî íà÷èíàòü
  //ñêàíèðîâàòü áëîê, âñå îáíàðóæåííûå áëîêè - çàïèñàòü â ïåðåìåííûå êëàññà.
  //Ïîðÿäîê çàïèñè áëîêîâ îáúåêòîâ - çíà÷åíèÿ íå èìååò â ïðèíöèïå.

  //Èòàê. Îáû÷íûé öèêë. Ðàáîòàòü áóäåò äî òåõ ïîð, ïîêà êóðñîð íå îêàæåòñÿ
  //â êîíöå áëîêà.

  Cursor = Cursor+8;  //Òèïà ïðîñêî÷èòü çàãîëîâîê è äëèíó áëîêà.

  //Ïî÷èñòèòü èíôó î ñóùåñòâîâàíèè ýòîãî áëîêà.... ïàìÿòü òàì îñâîáîäèòü çàîäíî...
  ClearObjectsBlockInfo();

  if (Size > 8)
  {
    //Òîëüêî åñëè åñòü îáúåêòû â áëîêå.

    //Ïîäñ÷èòàòü êîëè÷åñòâî ðàçíîîáðàçíûõ áëîêîâ...
    do
    {
      //Ïîëó÷èòü ñèãíàòóðó áëîêà îáúåêòà...
      memcpy(&CurrBlockSignature,&Buff[Cursor],4);
      StartBlockPos = Cursor;  //Çàïîìíèòü ïîçèöèþ â íà÷àëå áëîêà...
      Cursor = Cursor+4;
      //Ñ÷èòàòü äëèíó áëîêà...
      memcpy(&ObjBlockSize,&Buff[Cursor],4);
      Cursor = Cursor+4;
      //Ïðûãíóòü ê ñëåäóþùåé ñèãíàòóðå :).
      Cursor = Cursor+ObjBlockSize-8;

      //Â çàâèñèìîñòè îò ñèãíàòóðû...
      if (CurrBlockSignature == OB_Sgn_Unit)
      {
        //Åñëè ýòî þíèò...
        UnitObjsNum = UnitObjsNum+1;
      }
      else if (CurrBlockSignature == OB_Sgn_Object)
      {
        //Åñëè ýòî ïðîñòî îáúåêò...
        ObjectObjsNum = ObjectObjsNum+1;
      }
      else if (CurrBlockSignature == OB_Sgn_Lever)
      {
        //Åñëè ýòî ðû÷àã...
        LeverObjsNum = LeverObjsNum+1;
      }
      else if (CurrBlockSignature == OB_Sgn_Trap)
      {
        //Åñëè ýòî ëîâóøêà...
        TrapObjsNum = TrapObjsNum+1;
      }
      else if (CurrBlockSignature == OB_Sgn_Flame)
      {
        //Åñëè ýòî ôëåéì...
        FlameObjsNum = FlameObjsNum+1;
      }
      else if (CurrBlockSignature == OB_Sgn_Particle1)
      {
        //Åñëè ýòî ïàðòèêë 1-ãî òèïà...
        Particle1ObjsNum = Particle1ObjsNum+1;
      }
      else if (CurrBlockSignature == OB_Sgn_Particle2)
      {
        //Åñëè ýòî ïàðòèêë 2-ãî òèïà...
        Particle2ObjsNum = Particle2ObjsNum+1;
      }
      else if (CurrBlockSignature == OB_Sgn_Particle3)
      {
        //Åñëè ýòî ïàðòèêë 3-ãî òèïà...
        Particle3ObjsNum = Particle3ObjsNum+1;
      }
      else
      {
        //Åñëè òèï áëîêà íåèçâåñòåí.
        UnknObjsNum = UnknObjsNum+1;
      };
    }
    while (Cursor != Size);

    Cursor = 8;  //Âåðíóòü êóðñîð ãäå áûë - íà âîñüìåðêó :).
    //À áûë îí òàì äî ïîäñ÷åòà êîëè÷åñòâà áëîêîâ.

    //Âûäåëèòü ïàìÿòü ïîä áëîêè...
    UnitObjs.Length = UnitObjsNum;
    ObjectObjs.Length = ObjectObjsNum;
    LeverObjs.Length = LeverObjsNum;
    TrapObjs.Length = TrapObjsNum;
    FlameObjs.Length = FlameObjsNum;
    Particle1Objs.Length = Particle1ObjsNum;
    Particle2Objs.Length = Particle2ObjsNum;
    Particle3Objs.Length = Particle3ObjsNum;
    UnknObjs.Length = UnknObjsNum;

    //À òåïåðü ïðî÷èòàòü ýòè áëîêè :).
    do
    {
      //Ïîëó÷èòü ñèãíàòóðó áëîêà îáúåêòà...
      memcpy(&CurrBlockSignature,&Buff[Cursor],4);
      StartBlockPos = Cursor;  //Çàïîìíèòü ïîçèöèþ â íà÷àëå áëîêà...
      Cursor = Cursor+4;

      //Â çàâèñèìîñòè îò ñèãíàòóðû...
      if (CurrBlockSignature == OB_Sgn_Unit)
      {
        //Åñëè ýòî þíèò...
        //Ñäâèíóòü êóðñîð ìàññèâà...
        UnitObjsCurr = UnitObjsCurr+1;

        //Ñ÷èòàòü äëèíó áëîêà...
        memcpy(&ObjBlockSize,&Buff[Cursor],4);
        Cursor = Cursor+4;

        //Ñ÷èòàòü ñàì áëîê.
        TempBuff = new byte[ObjBlockSize];
        Cursor = Cursor-8;  //Îòêàòèòü êóðñîð íàçàä.
        memcpy(&TempBuff[0],&Buff[Cursor],ObjBlockSize);
        Cursor = Cursor+ObjBlockSize;

        //È ðàñøèôðèòü åãî â ñòðóêòóðó :)
        Result = UnitObjs[UnitObjsCurr].ReadBlock(TempBuff,ObjBlockSize,true,this);
        //Åñëè áûë àààáëîì...
        if (Result == false)
        {
          goto StopLoadObjBlock;
        }
        else
        {
          //Îòëàäî÷íàÿ âåòêà. Ïðîâåðêà - âñå ëè ïðî÷èòàíî èç áëîêà.
          TempDW1 = UnitObjs[UnitObjsCurr].GetBlockSize();
          if (TempDW1 != ObjBlockSize)
          {
            //Ñîîáñ÷èòü åòó õðåíü â ëîã.
            StringToLog(" áëîêå þíèòà "+IntToStr(UnitObjs[UnitObjsCurr].ObjectID)+" ÷òî-òî \"ëèøíåå\" - ñ÷èòàíî "+IntToStr(TempDW1)+" à ðåàëüíî òàì "+IntToStr(ObjBlockSize)+" áàéò.");
          };
        };
      }

      else if (CurrBlockSignature == OB_Sgn_Object)
      {
        //Åñëè ýòî ïðîñòî îáúåêò...
        //Ñäâèíóòü êóðñîð ìàññèâà...
        ObjectObjsCurr = ObjectObjsCurr+1;

        //Ñ÷èòàòü äëèíó áëîêà...
        memcpy(&ObjBlockSize,&Buff[Cursor],4);
        Cursor = Cursor+4;

        //Ñ÷èòàòü ñàì áëîê.
        TempBuff = new byte[ObjBlockSize];
        Cursor = Cursor-8;  //Îòêàòèòü êóðñîð íàçàä.
        memcpy(&TempBuff[0],&Buff[Cursor],ObjBlockSize);
        Cursor = Cursor+ObjBlockSize;

        //È ðàñøèôðèòü åãî â ñòðóêòóðó :)
        Result = ObjectObjs[ObjectObjsCurr].ReadBlock(TempBuff,ObjBlockSize,true,this);
        //Åñëè áûë àààáëîì...
        if (Result == false)
        {
          goto StopLoadObjBlock;
        }