changeset 2242:c4f87fb3cfee

for NextTurn()
author Ritor1
date Mon, 24 Feb 2014 16:19:01 +0600
parents 6ab7d7c112bb
children 9e1bd714d1d2
files CastSpellInfo.cpp Game.cpp Indoor.cpp Mouse.cpp Outdoor.cpp Overlays.cpp Party.cpp Player.cpp TurnEngine.cpp TurnEngine.h UI/UiGame.cpp Viewport.cpp mm7_3.cpp mm7_6.cpp
diffstat 14 files changed, 1081 insertions(+), 1196 deletions(-) [+]
line wrap: on
line diff
--- a/CastSpellInfo.cpp	Sun Feb 23 03:07:46 2014 +0100
+++ b/CastSpellInfo.cpp	Mon Feb 24 16:19:01 2014 +0600
@@ -3327,7 +3327,7 @@
   //  || (result = pTurnEngine->field_4, pTurnEngine->field_4 != 1) && pTurnEngine->field_4 != 3 )
   if (pParty->bTurnBasedModeOn)
   {
-    if (pTurnEngine->turn_stage == 1 || pTurnEngine->turn_stage == 3)
+    if ( pTurnEngine->turn_stage == TE_WAIT || pTurnEngine->turn_stage == TE_MOVEMENT )
       return;
   }
 
--- a/Game.cpp	Sun Feb 23 03:07:46 2014 +0100
+++ b/Game.cpp	Mon Feb 24 16:19:01 2014 +0600
@@ -3428,7 +3428,7 @@
               Actor::StealFrom(uMessageParam);
             continue;
           }
-          if ( pTurnEngine->turn_stage == 1 || pTurnEngine->turn_stage == 3 )
+          if ( pTurnEngine->turn_stage == TE_WAIT || pTurnEngine->turn_stage == TE_MOVEMENT )
             continue;
           if ( !(pTurnEngine->field_18 & TE_HAVE_PENDING_ACTIONS) )
           {
@@ -3447,7 +3447,7 @@
             _42ECB5_PlayerAttacksActor();
             continue;
           }
-          if ( pTurnEngine->turn_stage == 1 || pTurnEngine->turn_stage == 3 )
+          if ( pTurnEngine->turn_stage == TE_WAIT || pTurnEngine->turn_stage == TE_MOVEMENT )
             continue;
           if ( !(pTurnEngine->field_18 & TE_HAVE_PENDING_ACTIONS) )
             _42ECB5_PlayerAttacksActor();
@@ -3710,7 +3710,7 @@
           continue;
         }
         case UIMSG_OpenSpellbookPage:
-          if ( pTurnEngine->turn_stage == 3 || !uActiveCharacter || uMessageParam == pPlayers[uActiveCharacter]->lastOpenedSpellbookPage )
+          if ( pTurnEngine->turn_stage == TE_MOVEMENT || !uActiveCharacter || uMessageParam == pPlayers[uActiveCharacter]->lastOpenedSpellbookPage )
             continue;
           OnCloseSpellBookPage();
           pPlayers[uActiveCharacter]->lastOpenedSpellbookPage = uMessageParam;
@@ -3719,7 +3719,7 @@
           continue;
         case UIMSG_SelectSpell:
         {
-          if (pTurnEngine->turn_stage == 3)
+          if (pTurnEngine->turn_stage == TE_MOVEMENT)
             continue;
           if (!uActiveCharacter)
             continue;
@@ -3757,17 +3757,17 @@
         continue;
 
         case UIMSG_CastSpellFromBook:
-          if ( pTurnEngine->turn_stage != 3 )
+          if ( pTurnEngine->turn_stage != TE_MOVEMENT )
             _42777D_CastSpell_UseWand_ShootArrow(uMessageParam, v199, 0, 0, 0);
         continue;
 
         case UIMSG_SpellScrollUse:
 			__debugbreak();
-          if ( pTurnEngine->turn_stage != 3 )
+          if ( pTurnEngine->turn_stage != TE_MOVEMENT )
             _42777D_CastSpell_UseWand_ShootArrow(uMessageParam, v199, 133, 1, 0);
           continue;
         case UIMSG_SpellBookWindow:
-          if ( pTurnEngine->turn_stage == 3 )
+          if ( pTurnEngine->turn_stage == TE_MOVEMENT )
             continue;
           if ( bUnderwater == true )
           {
--- a/Indoor.cpp	Sun Feb 23 03:07:46 2014 +0100
+++ b/Indoor.cpp	Mon Feb 24 16:19:01 2014 +0600
@@ -2819,7 +2819,7 @@
       }
       if ( pActors[actor_id].uAIState == Pursuing || pActors[actor_id].uAIState == Fleeing )
         v6 *= 2;
-      if ( pParty->bTurnBasedModeOn == 1 && pTurnEngine->turn_stage == 1 )
+      if ( pParty->bTurnBasedModeOn == 1 && pTurnEngine->turn_stage == TE_WAIT )
         v6 = (signed __int64)((double)v6 * flt_6BE3AC_debug_recmod1_x_1_6);
       if ( v6 > 1000 )
         v6 = 1000;
@@ -2945,7 +2945,7 @@
               v37 = PID_ID(stru_721530.uFaceID);
               if ( PID_TYPE(stru_721530.uFaceID) == OBJECT_Actor)
               {
-                if ( pParty->bTurnBasedModeOn == 1 && (pTurnEngine->turn_stage == 2 || pTurnEngine->turn_stage == 3) )
+                if ( pParty->bTurnBasedModeOn == 1 && (pTurnEngine->turn_stage == TE_ATTACK || pTurnEngine->turn_stage == TE_MOVEMENT) )
                 {
                   pActors[actor_id].vVelocity.x = fixpoint_mul(58500, pActors[actor_id].vVelocity.x);
                   pActors[actor_id].vVelocity.y = fixpoint_mul(58500, pActors[actor_id].vVelocity.y);
@@ -3093,7 +3093,7 @@
           }
           else
           {
-            if ( pParty->bTurnBasedModeOn == 1 && (pTurnEngine->turn_stage == 2 || pTurnEngine->turn_stage == 3) )
+            if ( pParty->bTurnBasedModeOn == 1 && (pTurnEngine->turn_stage == TE_ATTACK || pTurnEngine->turn_stage == TE_MOVEMENT) )
               goto LABEL_123;
             if ( !pActors[actor_id].pMonsterInfo.uHostilityType || v56 != v22 )
             {
@@ -6256,7 +6256,7 @@
 
     stru_721530.uSectorID = uSectorID;
     v38 = 0;
-    if ( pParty->bTurnBasedModeOn == true && pTurnEngine->turn_stage == 3 )
+    if ( pParty->bTurnBasedModeOn == true && pTurnEngine->turn_stage == TE_MOVEMENT )
       v38 = 13312;
     if ( stru_721530._47050A(v38) )
       break;
--- a/Mouse.cpp	Sun Feb 23 03:07:46 2014 +0100
+++ b/Mouse.cpp	Mon Feb 24 16:19:01 2014 +0600
@@ -550,7 +550,7 @@
 
     if ( pParty->bTurnBasedModeOn == 1 )
     {
-      if ( pTurnEngine->turn_stage == 3 )
+      if ( pTurnEngine->turn_stage == TE_MOVEMENT )
         pTurnEngine->field_18 |= TE_FLAG_8;
     }
   }
--- a/Outdoor.cpp	Sun Feb 23 03:07:46 2014 +0100
+++ b/Outdoor.cpp	Mon Feb 24 16:19:01 2014 +0600
@@ -3948,7 +3948,7 @@
 
     stru_721530.uSectorID = 0;
     v36 = 0;
-    if ( pParty->bTurnBasedModeOn == true && pTurnEngine->turn_stage == 3 )
+    if ( pParty->bTurnBasedModeOn == true && pTurnEngine->turn_stage == TE_MOVEMENT )
       v36 = 13312;
     if ( stru_721530._47050A(v36) )
       break;
--- a/Overlays.cpp	Sun Feb 23 03:07:46 2014 +0100
+++ b/Overlays.cpp	Mon Feb 24 16:19:01 2014 +0600
@@ -95,56 +95,32 @@
 //----- (00441964) --------------------------------------------------------
 void OtherOverlayList::DrawTurnBasedIcon(int a2)
 {
-  unsigned int result; // eax@1
-  IconFrameTable *v3; // ecx@6
-  void *v4; // eax@12
+  IconFrame *frame; // eax@12
   unsigned int v5; // [sp-8h] [bp-Ch]@4
-  int v6; // [sp-4h] [bp-8h]@4
-  Texture *v7; // [sp-4h] [bp-8h]@14
 
   if ( pCurrentScreen != SCREEN_GAME || !pParty->bTurnBasedModeOn)
     return;
 
-  if ( pTurnEngine->turn_stage == 3 )
-  {
-    v6 = pEventTimer->uStartTime;
-    v5 = pIconIDs_Turn[5 - pTurnEngine->uActionPointsLeft / 26];
-  }
-  else
+  if ( pTurnEngine->turn_stage == TE_MOVEMENT )//все персы отстрелялись(сжатый кулак)
+    frame = pIconsFrameTable->GetFrame(pIconIDs_Turn[5 - pTurnEngine->uActionPointsLeft / 26], pEventTimer->uStartTime);
+  else  if ( pTurnEngine->turn_stage == TE_WAIT )
   {
-    if ( pTurnEngine->turn_stage == 1 )
-    {
-      v6 = dword_50C994;
-      v3 = pIconsFrameTable;
-      if ( dword_50C998_turnbased_icon_1A )
-        v5 = uIconID_TurnStart;
-      else
-        v5 = uIconID_TurnHour;
-      goto LABEL_12;
-    }
-    if ( pTurnEngine->turn_stage != 2 )
-    {
-      v4 = this;
-      goto LABEL_14;
-    }
-    v6 = pEventTimer->uStartTime;
-    v5 = uIconID_TurnStop;
+    if ( dword_50C998_turnbased_icon_1A )
+      v5 = uIconID_TurnStart;//анимация руки(запуск пошагового режима)
+    else
+      v5 = uIconID_TurnHour; //группа ожидает(часы)
+    frame = pIconsFrameTable->GetFrame(v5, dword_50C994);
   }
-  v3 = pIconsFrameTable;
-LABEL_12:
-  v4 = pIconsFrameTable->GetFrame(v5, v6);
-LABEL_14:
-  v7 = &pIcons_LOD->pTextures[*((short *)v4 + 15)];
+  else if ( pTurnEngine->turn_stage == TE_ATTACK )//группа атакует(ладонь)
+    frame = pIconsFrameTable->GetFrame(uIconID_TurnStop, pEventTimer->uStartTime);
   //if ( pRenderer->pRenderD3D )
-    pRenderer->DrawTextureIndexed(0x18Au, 0x120u, v7);
+    pRenderer->DrawTextureIndexed(394, 288, &pIcons_LOD->pTextures[frame->uTextureID]);
   /*else
     pRenderer->DrawTextureTransparent(0x18Au, 0x120u, v7);*/
-  result = dword_50C994;
   if ( dword_50C994 < dword_50C998_turnbased_icon_1A )
   {
-    result = pEventTimer->uTimeElapsed + dword_50C994;
-    dword_50C994 = result;
-    if ( (signed int)result >= dword_50C998_turnbased_icon_1A )
+    dword_50C994 += pEventTimer->uTimeElapsed;
+    if ( (signed int)dword_50C994 >= dword_50C998_turnbased_icon_1A )
       dword_50C998_turnbased_icon_1A = 0;
   }
 }
@@ -163,18 +139,16 @@
 //----- (00458DBC) --------------------------------------------------------
 void OverlayList::ToFile()
 {
-  OverlayList *v1; // esi@1
   FILE *v2; // eax@1
-  FILE *v3; // edi@1
+  //FILE *v3; // edi@1
 
-  v1 = this;
   v2 = fopen("data\\doverlay.bin", "wb");
-  v3 = v2;
+  //v3 = v2;
   if ( !v2 )
     Error("Unable to save doverlay.bin!");
-  fwrite(v1, 4u, 1u, v2);
-  fwrite(v1->pOverlays, 8u, v1->uNumOverlays, v3);
-  fclose(v3);
+  fwrite(this, 4, 1, v2);
+  fwrite(this->pOverlays, 8, this->uNumOverlays, v2);
+  fclose(v2);
 }
 
 //----- (00458E08) --------------------------------------------------------
@@ -197,31 +171,22 @@
 //----- (00458E4F) --------------------------------------------------------
 bool OverlayList::FromFileTxt(const char *Args)
 {
-  OverlayList *v2; // ebx@1
   __int32 v3; // edi@1
   FILE *v4; // eax@1
   unsigned int v5; // esi@3
-  const void *v6; // ST18_4@9
   void *v7; // eax@9
   FILE *v8; // ST0C_4@11
   char *i; // eax@11
-  unsigned __int16 v10; // ax@14
-  const char *v11; // ST1C_4@14
-  int v12; // eax@16
-  OverlayDesc *v13; // ecx@16
-  char v14; // zf@16
-  unsigned int v15; // eax@16
   char Buf; // [sp+10h] [bp-2F0h]@3
   FrameTableTxtLine v18; // [sp+204h] [bp-FCh]@4
   FrameTableTxtLine v19; // [sp+280h] [bp-80h]@4
   FILE *File; // [sp+2FCh] [bp-4h]@1
   unsigned int Argsa; // [sp+308h] [bp+8h]@3
 
-  v2 = this;
   free(this->pOverlays);
   v3 = 0;
-  v2->pOverlays = 0;
-  v2->uNumOverlays = 0;
+  this->pOverlays = 0;
+  this->uNumOverlays = 0;
   v4 = fopen(Args, "r");
   File = v4;
   if ( !v4 )
@@ -242,16 +207,15 @@
     v5 = Argsa;
     v3 = 0;
   }
-  v6 = v2->pOverlays;
-  v2->uNumOverlays = v5;
+  this->uNumOverlays = v5;
   v7 = malloc(8 * v5);
-  v2->pOverlays = (OverlayDesc *)v7;
+  this->pOverlays = (OverlayDesc *)v7;
   if ( v7 == (void *)v3 )
     Error("OverlayDescriptionList::load - Out of Memory!");
 
-  memset(v7, v3, 8 * v2->uNumOverlays);
+  memset(v7, v3, 8 * this->uNumOverlays);
   v8 = File;
-  v2->uNumOverlays = v3;
+  this->uNumOverlays = v3;
   fseek(v8, v3, v3);
   for ( i = fgets(&Buf, 490, File); i; i = fgets(&Buf, 490, File) )
   {
@@ -259,25 +223,17 @@
     memcpy(&v19, txt_file_frametable_parser(&Buf, &v18), sizeof(v19));
     if ( v19.uPropCount && *v19.pProperties[0] != 47 )
     {
-      v10 = atoi(v19.pProperties[0]);
-      v11 = v19.pProperties[1];
-      v2->pOverlays[v2->uNumOverlays].uOverlayID = v10;
-      if ( _stricmp(v11, "center") )
+      this->pOverlays[this->uNumOverlays].uOverlayID = atoi(v19.pProperties[0]);
+      if ( _stricmp(v19.pProperties[1], "center") )
       {
-        v12 = _stricmp(v19.pProperties[1], "transparent");
-        v13 = v2->pOverlays;
-        v14 = v12 == 0;
-        v15 = v2->uNumOverlays;
-        if ( v14 )
-          v13[v15].uOverlayType = 2;
+        if ( !_stricmp(v19.pProperties[1], "transparent") )
+          this->pOverlays[this->uNumOverlays].uOverlayType = 2;
         else
-          v13[v15].uOverlayType = 1;
+          this->pOverlays[this->uNumOverlays].uOverlayType = 1;
       }
       else
-      {
-        v2->pOverlays[v2->uNumOverlays].uOverlayType = 0;
-      }
-      v2->pOverlays[v2->uNumOverlays++].uSpriteFramesetID = pSpriteFrameTable->FastFindSprite(
+        this->pOverlays[this->uNumOverlays].uOverlayType = 0;
+      this->pOverlays[this->uNumOverlays++].uSpriteFramesetID = pSpriteFrameTable->FastFindSprite(
                                                               (char *)v19.pProperties[2]);
     }
   }
@@ -285,7 +241,6 @@
   return 1;
 }
 
-
 //----- (0045855F) --------------------------------------------------------
 void OtherOverlay::Reset()
 {
@@ -303,11 +258,12 @@
 //----- (004584B8) --------------------------------------------------------
 OtherOverlay::OtherOverlay()
 {
-  this->field_A = 0;
-  this->field_8 = 0;
+  this->field_0 = 0;
+  this->field_2 = 0;
+  this->field_4 = 0;
   this->field_6 = 0;
-  this->field_4 = 0;
-  this->field_2 = 0;
+  this->field_8 = 0;
+  this->field_A = 0;
   this->field_C = 0;
   this->field_E = 0;
   this->field_10 = 65536;
--- a/Party.cpp	Sun Feb 23 03:07:46 2014 +0100
+++ b/Party.cpp	Mon Feb 24 16:19:01 2014 +0600
@@ -159,7 +159,7 @@
   v12 = 0;
   if ( pParty->bTurnBasedModeOn == 1 )
   {
-    if ( pTurnEngine->turn_stage != 2 || PID_TYPE(pTurnEngine->pQueue[0].uPackedID) != OBJECT_Player)
+    if ( pTurnEngine->turn_stage != TE_ATTACK || PID_TYPE(pTurnEngine->pQueue[0].uPackedID) != OBJECT_Player)
       return 0;
     v2 = PID_ID(pTurnEngine->pQueue[0].uPackedID);
     return v2 + 1;
--- a/Player.cpp	Sun Feb 23 03:07:46 2014 +0100
+++ b/Player.cpp	Mon Feb 24 16:19:01 2014 +0600
@@ -4275,7 +4275,7 @@
   //thisb = this;
   playerAffected = &pParty->pPlayers[player_num-1];
   v73 = 1;
-  if ( pParty->bTurnBasedModeOn == 1 && (pTurnEngine->turn_stage == 1 || pTurnEngine->turn_stage == 3) )
+  if ( pParty->bTurnBasedModeOn == true && (pTurnEngine->turn_stage == TE_WAIT || pTurnEngine->turn_stage == TE_MOVEMENT) )
       return;
   if ( pParty->pPickedItem.GetItemEquipType() == EQUIP_REAGENT )
   {
--- a/TurnEngine.cpp	Sun Feb 23 03:07:46 2014 +0100
+++ b/TurnEngine.cpp	Mon Feb 24 16:19:01 2014 +0600
@@ -21,1188 +21,1111 @@
 
 //----- (00404544) --------------------------------------------------------
 void stru262_TurnBased::SortTurnQueue()
-    {
-
-    int active_actors;
-    TurnBased_QueueElem *current_top; // eax@16
-    TurnBased_QueueElem *test_element; // ecx@18
-    TurnBased_QueueElem temp_elem;
-    int i,j;
-    unsigned int p_type;
-    unsigned int p_id;
-
-    active_actors = this->uActorQueueSize;
-    //set non active actors in queue initiative that not allow them to paticipate 
-    for( i=0; i<uActorQueueSize; ++i) 
-        {
-        p_type = PID_TYPE(pQueue[i].uPackedID);
-        p_id   = PID_ID(pQueue[i].uPackedID);
+{
+  int active_actors;
+  TurnBased_QueueElem *current_top; // eax@16
+  TurnBased_QueueElem *test_element; // ecx@18
+  TurnBased_QueueElem temp_elem;
+  int i,j;
+  unsigned int p_type;
+   unsigned int p_id;
 
-        if ( p_type == OBJECT_Actor )
-            {
-            pActors[p_id].uAttributes |= 0x80u;
-            if ( !pActors[p_id].CanAct() )
-                {
-                --active_actors;
-                pQueue[i].actor_initiative = 1001;
-                pActors[p_id].uAttributes &= ~0x80;
-                }
-            }
-        else if ( p_type == OBJECT_Player)
-            {
-            if ( !pParty->pPlayers[p_id].CanAct() )
-                {
-                --active_actors;
-                pQueue[i].actor_initiative = 1001;
-                }
-            }
-        }
-     //sort
-if (uActorQueueSize>0)
+  active_actors = this->uActorQueueSize;
+  //set non active actors in queue initiative that not allow them to paticipate 
+  for( i = 0; i < uActorQueueSize; ++i) 
+  {
+    p_type = PID_TYPE(pQueue[i].uPackedID);
+    p_id   = PID_ID(pQueue[i].uPackedID);
+
+    if ( p_type == OBJECT_Actor )
+    {
+      pActors[p_id].uAttributes |= 0x80;
+      if ( !pActors[p_id].CanAct() )
+      {
+        --active_actors;
+        pQueue[i].actor_initiative = 1001;
+        pActors[p_id].uAttributes &= ~0x80;
+      }
+    }
+    else if ( p_type == OBJECT_Player)
     {
-    for( i=0; i<uActorQueueSize-1; ++i) 
-        {
-       current_top=&pQueue[i];
-        for(j=i+1; j<uActorQueueSize;++j )
-            {  
-            test_element=&pQueue[j];           
-            if ( test_element->actor_initiative < current_top->actor_initiative  || // if less initiative -> top
-                   ((test_element->actor_initiative == current_top->actor_initiative) && 
-                       (
-                          ((PID_TYPE(test_element->uPackedID) == OBJECT_Player) && (PID_TYPE(current_top->uPackedID) == OBJECT_Actor)) || //player preferable
-                          ((PID_TYPE(test_element->uPackedID) == PID_TYPE(current_top->uPackedID)) && (PID_ID(test_element->uPackedID) < PID_ID(current_top->uPackedID)))  //less id preferable    
-                       ) 
-                   )
-                )
-                { //swap
-                memcpy(&temp_elem,current_top,sizeof(TurnBased_QueueElem));
-                memcpy(current_top,test_element, sizeof(TurnBased_QueueElem));
-                memcpy(test_element, &temp_elem, sizeof(TurnBased_QueueElem));
-                }
-            }
+      if ( !pParty->pPlayers[p_id].CanAct() )
+      {
+        --active_actors;
+        pQueue[i].actor_initiative = 1001;
+      }
+    }
+  }
+  //sort
+  if (uActorQueueSize > 0)
+  {
+    for( i = 0; i < uActorQueueSize-1; ++i) 
+    {
+      current_top=&pQueue[i];
+      for ( j = i+1; j < uActorQueueSize; ++j )
+      {
+        test_element=&pQueue[j];
+        if ( test_element->actor_initiative < current_top->actor_initiative  || // if less initiative -> top
+           ((test_element->actor_initiative == current_top->actor_initiative) && 
+           (((PID_TYPE(test_element->uPackedID) == OBJECT_Player) && (PID_TYPE(current_top->uPackedID) == OBJECT_Actor)) || //player preferable
+            ((PID_TYPE(test_element->uPackedID) == PID_TYPE(current_top->uPackedID)) && (PID_ID(test_element->uPackedID) < PID_ID(current_top->uPackedID))))))  //less id preferable
+        { //swap
+          memcpy(&temp_elem,current_top,sizeof(TurnBased_QueueElem));
+          memcpy(current_top,test_element, sizeof(TurnBased_QueueElem));
+          memcpy(test_element, &temp_elem, sizeof(TurnBased_QueueElem));
         }
+      }
     }
-    uActorQueueSize = active_actors;
-    if ( PID_TYPE(pQueue[0].uPackedID) == OBJECT_Player) //we have player at queue top
-        {
-        uActiveCharacter = PID_ID(pQueue[0].uPackedID)+1;
-        field_18 |= TE_PLAYER_TURN;
-        }
-    else
-        {
-        uActiveCharacter = 0;
-        field_18 &= ~TE_PLAYER_TURN;
-        }
-    for(i=0; i<uActorQueueSize; ++i)
-        {
-        if ( PID_TYPE(pQueue[i].uPackedID) == OBJECT_Player) //set recovery times
-            pParty->pPlayers[PID_ID(pQueue[i].uPackedID)].uTimeToRecovery = (unsigned __int16)((double)pQueue[i].actor_initiative * 0.46875);
-        }
-
-
-    }
-
+  }
+  uActorQueueSize = active_actors;
+  if ( PID_TYPE(pQueue[0].uPackedID) == OBJECT_Player) //we have player at queue top
+  {
+    uActiveCharacter = PID_ID(pQueue[0].uPackedID)+1;
+    field_18 |= TE_PLAYER_TURN;
+  }
+  else
+  {
+    uActiveCharacter = 0;
+    field_18 &= ~TE_PLAYER_TURN;
+  }
+  for ( i = 0; i < uActorQueueSize; ++i)
+  {
+    if ( PID_TYPE(pQueue[i].uPackedID) == OBJECT_Player) //set recovery times
+      pParty->pPlayers[PID_ID(pQueue[i].uPackedID)].uTimeToRecovery = (unsigned __int16)((double)pQueue[i].actor_initiative * 0.46875);
+  }
+}
 //----- (0040471C) --------------------------------------------------------
 void stru262_TurnBased::ApplyPlayerAction()
-    {
-    if ( pParty->bTurnBasedModeOn == 1 )
-        {
-        if ( pTurnEngine->turn_stage == 2 )
-            _406457(0);
-        }
-    }
+{
+  if ( pParty->bTurnBasedModeOn == 1 )
+  {
+    if ( pTurnEngine->turn_stage == TE_ATTACK )
+      _406457(0);
+  }
+}
 
 //----- (004059DB) --------------------------------------------------------
 void stru262_TurnBased::Start()
-    {
+{
+  int v17; // edx@22
+  AIDirection v30; // [sp+Ch] [bp-68h]@10
+  AIDirection v31; // [sp+28h] [bp-4Ch]@10
+  AIDirection a3; // [sp+44h] [bp-30h]@10
+  int activ_players[4];
+  int players_recovery_time[4];
+  int a_players_count;
+  int i,j;
+  int temp;
 
-    int v3; // esi@1
-    unsigned int actor_id; // esi@7
-    unsigned int v8; // edx@10
-    int v17; // edx@22
-    AIDirection v30; // [sp+Ch] [bp-68h]@10
-    AIDirection v31; // [sp+28h] [bp-4Ch]@10
-    AIDirection a3; // [sp+44h] [bp-30h]@10
-    Player *pPlayer; // [sp+6Ch] [bp-8h]@1
-    int v40b;
-    int activ_players[4];
-    int players_recovery_time[4];
-    int a_players_count;
-    int i,j;
-    int temp;
+  pTurnEngine->field_18 &= ~TE_HAVE_PENDING_ACTIONS;
+  pEventTimer->TrackGameTime();
+  pAudioPlayer->StopChannels(-1, -1);
+  pAudioPlayer->PlaySound(SOUND_207, 0, 0, -1, 0, 0, 0, 0);
+  //pPlayer = pParty->pPlayers.data();
+  dword_50C998_turnbased_icon_1A = 8 * pIconsFrameTable->pIcons[uIconID_TurnStart].uAnimLength;
+  dword_50C994 = 0;
 
-    pTurnEngine->field_18 &= ~TE_HAVE_PENDING_ACTIONS;
-    pEventTimer->TrackGameTime();
-    pAudioPlayer->StopChannels(-1, -1);
-    pAudioPlayer->PlaySound(SOUND_207, 0, 0, -1, 0, 0, 0, 0);
-    pPlayer = pParty->pPlayers.data();
-    dword_50C998_turnbased_icon_1A = 8 * pIconsFrameTable->pIcons[uIconID_TurnStart].uAnimLength;
-    dword_50C994 = 0;
+  this->turn_initiative = 100;
+  this->turns_count = 0;
+  this->ai_turn_timer = 64;
+  this->turn_stage = TE_WAIT;
+  this->uActorQueueSize = 0;
 
-    this->turn_initiative = 100;
-    this->turns_count = 0;
-    this->ai_turn_timer = 64;
-    this->turn_stage = 1;
-    this->uActorQueueSize = 0;
+  for ( uint pl_id = 0; pl_id < 4 ; ++pl_id )
+  {
+    if ( pParty->pPlayers[pl_id].CanAct() )
+    {
+      this->pQueue[this->uActorQueueSize].uPackedID = PID(OBJECT_Player,pl_id);
+      this->pQueue[this->uActorQueueSize].AI_action_type = TE_AI_PURSUE;
+      this->pQueue[this->uActorQueueSize].uActionLength = 0;
+      pParty->pTurnBasedPlayerRecoveryTimes[this->uActorQueueSize] = 0;
+      ++this->uActorQueueSize;
+    }
+  }
 
-    for ( v3 = 0; v3 < 4 ; ++v3 )
-        {
-        if ( pParty->pPlayers[v3].CanAct() )
-            {
-            this->pQueue[this->uActorQueueSize].uPackedID = PID(OBJECT_Player,v3);
-            this->pQueue[this->uActorQueueSize].AI_action_type = TE_AI_PURSUE;
-            this->pQueue[this->uActorQueueSize].uActionLength = 0;
-            pParty->pTurnBasedPlayerRecoveryTimes[this->uActorQueueSize] = 0;
-            ++this->uActorQueueSize;
-            }
-        }
+  for ( int i = 0; i < ai_arrays_size ; ++i )
+  {
+    if (ai_near_actors_ids[i] == 10)
+      continue;
+    if ( pActors[ai_near_actors_ids[i]].CanAct() )
+    {
+      if ( pActors[ai_near_actors_ids[i]].uAttributes & 0x8000 )
+      {
+        pActors[ai_near_actors_ids[i]].uAttributes |= 0x80;
+        Actor::GetDirectionInfo(PID(OBJECT_Actor,ai_near_actors_ids[i]), ai_near_actors_targets_pid[ai_near_actors_ids[i]], &v31, 0);
+        memcpy(&v30, &v31, sizeof(AIDirection));
+        Actor::AI_StandOrBored(ai_near_actors_ids[i], 4, 32, &v30);
+        this->pQueue[this->uActorQueueSize].uPackedID = PID(OBJECT_Actor,ai_near_actors_ids[i]);
+        this->pQueue[this->uActorQueueSize].AI_action_type = TE_AI_PURSUE;
+        this->pQueue[this->uActorQueueSize].uActionLength = 0;
+        ++this->uActorQueueSize;
+      }
+    }
+  }
 
-    for ( v3 = 0; v3 < ai_arrays_size ; ++v3 )
-        { 
-        actor_id = ai_near_actors_ids[v3];
-        if (actor_id == 10)
-            continue;
-        if ( pActors[actor_id].CanAct() )
-            {
-            if ( pActors[actor_id].uAttributes & 0x8000 )
-                {
-                v8 = ai_near_actors_targets_pid[actor_id];
-                pActors[actor_id].uAttributes |= 0x80;
-                Actor::GetDirectionInfo(PID(OBJECT_Actor,actor_id), v8, &v31, 0);
-                memcpy(&v30, &v31, sizeof(AIDirection));
-                Actor::AI_StandOrBored(actor_id, 4, 32, &v30);
-                this->pQueue[this->uActorQueueSize].uPackedID = PID(OBJECT_Actor,actor_id);
-                this->pQueue[this->uActorQueueSize].AI_action_type = TE_AI_PURSUE;
-                this->pQueue[this->uActorQueueSize].uActionLength = 0;
-                ++this->uActorQueueSize;
-                }
-            }
+  a_players_count = 0;
+  for ( int k = 0; k < this->uActorQueueSize; ++k )
+  {
+    //set initial initiative for turn actors
+    if ( PID_TYPE(this->pQueue[k].uPackedID) == OBJECT_Player )
+    {
+      if ( pPlayers[PID_ID(this->pQueue[k].uPackedID) + 1]->uTimeToRecovery != 0 )
+        this->pQueue[k].actor_initiative = (signed int)((double)pPlayers[PID_ID(this->pQueue[k].uPackedID) + 1]->uTimeToRecovery * 0.46875);
+      else
+      {
+        activ_players[a_players_count] = k;
+        ++a_players_count;
+      }
+    }
+    else if ( PID_TYPE(this->pQueue[k].uPackedID) == OBJECT_Actor )
+    {
+      v17 = rand() % 99;
+      if ( v17 < 33 )
+        this->pQueue[k].actor_initiative = 1;
+      else 
+        this->pQueue[k].actor_initiative= (v17 >= 66)? 5 : 3; 
+    }
+    else //fot non player and actor
+      this->pQueue[k].actor_initiative = 666;
+    this->pQueue[k].actor_initiative += 16;
+  }
+
+  if ( a_players_count > 0 )
+  {
+    for ( i = 0; i < a_players_count; ++i)
+      players_recovery_time[i] = pParty->pPlayers[PID_ID(this->pQueue[activ_players[i]].uPackedID)].GetAttackRecoveryTime(0);
+    //sort players by recovery time
+    for ( i = 0; i < a_players_count-1; ++i)
+    {
+      for ( j = i + 1; j < a_players_count; ++j )
+      {
+        if (players_recovery_time[j] < players_recovery_time[i]) //swap values
+        {
+          temp = players_recovery_time[i];
+          players_recovery_time[i] = players_recovery_time[j];
+          players_recovery_time[j] = temp;
+          temp = activ_players[i];
+          activ_players[i] = activ_players[j];
+          activ_players[j] = temp;
         }
-
-    a_players_count=0;
-    for ( v40b = 0; v40b < this->uActorQueueSize; ++v40b )
-        {
-        //set initial initiative for turn actors
-        if ( PID_TYPE(this->pQueue[v40b].uPackedID) == OBJECT_Player )
-            {
-            if ( pPlayers[PID_ID(this->pQueue[v40b].uPackedID) + 1]->uTimeToRecovery != 0 )
-                {
-                this->pQueue[v40b].actor_initiative = (signed int)((double)pPlayers[PID_ID(this->pQueue[v40b].uPackedID) + 1]->uTimeToRecovery * 0.46875);
-                }
-            else
-                {   
-                activ_players[a_players_count] = v40b;
-                ++a_players_count;
-                }
-            }
-        else if ( PID_TYPE(this->pQueue[v40b].uPackedID) == OBJECT_Actor )
-            {
-            v17 = rand() % 99;
-            if ( v17 < 33 )
-                this->pQueue[v40b].actor_initiative = 1;
-            else 
-                this->pQueue[v40b].actor_initiative= (v17 >= 66)? 5 : 3; 
-            }
-        else 
-            {  //fot non player and actor
-            this->pQueue[v40b].actor_initiative = 666;
-            }
-        this->pQueue[v40b].actor_initiative += 16;
-        }
-
-    if ( a_players_count > 0 )
-        {
-        for (i=0; i<a_players_count; ++i)
-            players_recovery_time[i] = pParty->pPlayers[PID_ID(this->pQueue[activ_players[i]].uPackedID)].GetAttackRecoveryTime(0);
-        //sort players by recovery time
-        for (i=0; i < a_players_count-1; ++i)
-            {  
-            for(j=i+1; j<a_players_count;++j )
-                {       
-                if (players_recovery_time[j] < players_recovery_time[i]) //swap values
-                    {
-                    temp = players_recovery_time[i];
-                    players_recovery_time[i] = players_recovery_time[j];
-                    players_recovery_time[j] = temp;
-
-                    temp = activ_players[i];
-                    activ_players[i] = activ_players[j];
-                    activ_players[j] = temp;
-                    }
-                }
-            }
-
-        for (i=0; i<a_players_count; ++i)
-            {
-            this->pQueue[activ_players[i]].actor_initiative = i+2;
-            }
-        }
-    this->SortTurnQueue();
+      }
     }
-
-
+    for ( i = 0; i < a_players_count; ++i)
+      this->pQueue[activ_players[i]].actor_initiative = i + 2;
+  }
+  this->SortTurnQueue();
+}
 
 //----- (00405CFF) --------------------------------------------------------
 void stru262_TurnBased::End(bool bPlaySound)
-    {
-   
-    ObjectType objType; // eax@13
-    int objID; // esi@13
-    int i; 
-
-    this->turn_stage = 0;
+{
+  ObjectType objType; // eax@13
+  int objID; // esi@13
+  int i; 
 
-    for( i=0; i<uActorQueueSize; ++i) 
-        { 
-        if ( PID_TYPE(pQueue[i].uPackedID) == OBJECT_Actor )
-            pActors[PID_ID(pQueue[i].uPackedID)].uAttributes &= ~0x80;
-        }
+  this->turn_stage = TE_NONE;
+  for( i = 0; i < uActorQueueSize; ++i) 
+  {
+    if ( PID_TYPE(pQueue[i].uPackedID) == OBJECT_Actor )
+      pActors[PID_ID(pQueue[i].uPackedID)].uAttributes &= ~0x80;
+  }
 
-    for( i=0; i<uNumSpriteObjects; ++i) 
-        {
-         if (pSpriteObjects[i].uAttributes & 4)
-             pSpriteObjects[i].uAttributes &= ~0x04;
-        }
+  for( i = 0; i < uNumSpriteObjects; ++i) 
+  {
+    if (pSpriteObjects[i].uAttributes & 4)
+      pSpriteObjects[i].uAttributes &= ~0x04;
+  }
 
-    for( i=0; i<uActorQueueSize; ++i) 
-        { 
-        objType = (ObjectType)PID_TYPE(pQueue[i].uPackedID);
-        objID = PID_ID(pQueue[i].uPackedID);
-        if ( objType == OBJECT_Player )
-            {
-            pPlayers[objID + 1]->uTimeToRecovery = (unsigned __int16)((double)pQueue[i].actor_initiative * 2.133333333333333);
-            }
-        else if ( objType == OBJECT_Actor )
-            {
-             pActors[objID].pMonsterInfo.uRecoveryTime = (unsigned __int16)((double)pQueue[i].actor_initiative * 2.133333333333333);
-            }
-        }
-   
-    pAudioPlayer->StopChannels(-1, -1);
-    if ( bPlaySound != 0 )
-        pAudioPlayer->PlaySound(SOUND_206, 0, 0, -1, 0, 0, 0, 0);
-    pTurnEngine->field_18 &= ~TE_HAVE_PENDING_ACTIONS;
-    pEventTimer->StopGameTime();
-    dword_50C994 = 0;
-    dword_50C998_turnbased_icon_1A = 0;
-    }
+  for( i = 0; i < uActorQueueSize; ++i) 
+  {
+    objType = (ObjectType)PID_TYPE(pQueue[i].uPackedID);
+    objID = PID_ID(pQueue[i].uPackedID);
+    if ( objType == OBJECT_Player )
+      pPlayers[objID + 1]->uTimeToRecovery = (unsigned __int16)((double)pQueue[i].actor_initiative * 2.133333333333333);
+    else if ( objType == OBJECT_Actor )
+      pActors[objID].pMonsterInfo.uRecoveryTime = (unsigned __int16)((double)pQueue[i].actor_initiative * 2.133333333333333);
+  }
+  pAudioPlayer->StopChannels(-1, -1);
+  if ( bPlaySound != 0 )
+    pAudioPlayer->PlaySound(SOUND_206, 0, 0, -1, 0, 0, 0, 0);
+  pTurnEngine->field_18 &= ~TE_HAVE_PENDING_ACTIONS;
+  pEventTimer->StopGameTime();
+  dword_50C994 = 0;
+  dword_50C998_turnbased_icon_1A = 0;
+}
 // 50C994: using guessed type int dword_50C994;
 // 50C998: using guessed type int dword_50C998_turnbased_icon_1A;
 
 //----- (00405E14) --------------------------------------------------------
 void stru262_TurnBased::AITurnBasedAction()
+{
+  AIDirection v6; // esi@21
+  AIDirection a3; // [sp+4h] [bp-68h]@21
+  AIDirection v14; // [sp+20h] [bp-4Ch]@21
+  AIDirection v15; // [sp+3Ch] [bp-30h]@21
+  Actor *curr_actor; // [sp+58h] [bp-14h]@2
+  int target_pid; // [sp+5Ch] [bp-10h]@6
+  int shrinked;
+  int i, j;
+
+  for (i = 0; i < uNumActors; ++i )
+  {
+    curr_actor=&pActors[i];
+    shrinked=pActors[i].pActorBuffs[ACTOR_BUFF_SHRINK].uExpireTime > 0;
+    for (j = 0; j < 22; ++j) //check expired spell Buffs
     {
-    AIDirection v6; // esi@21
-    int v7; // eax@21
-    AIDirection a3; // [sp+4h] [bp-68h]@21
-    AIDirection v14; // [sp+20h] [bp-4Ch]@21
-    AIDirection v15; // [sp+3Ch] [bp-30h]@21
-    Actor *curr_actor; // [sp+58h] [bp-14h]@2
-    int target_pid; // [sp+5Ch] [bp-10h]@6
-    int shrinked;
-    int i,j;
-
-    for (i =0; i<uNumActors; ++i )
+      if (j != 10)
+        pActors[i].pActorBuffs[j].IsBuffExpiredToTime(pParty->uTimePlayed);
+    }
+    if (shrinked && pActors[i].pActorBuffs[ACTOR_BUFF_SHRINK].uExpireTime <= 0) //buff 3 expired
+      pActors[i].uActorHeight = pMonsterList->pMonsters[pActors[i].pMonsterInfo.uID - 1].uMonsterHeight;
+    if (!(curr_actor->uAttributes & 0x80) && (!curr_actor->pActorBuffs[ACTOR_BUFF_STONED].uExpireTime) &&
+       (!curr_actor->pActorBuffs[ACTOR_BUFF_PARALYZED].uExpireTime)) 
+    {
+      curr_actor->uCurrentActionTime += pMiscTimer->uTimeElapsed;
+      if (curr_actor->uCurrentActionTime>=curr_actor->uCurrentActionLength)
+      {
+        target_pid = ai_near_actors_targets_pid[i];
+        Actor::GetDirectionInfo(PID(OBJECT_Actor,i), target_pid, &v6, 0);
+        memcpy(&v15, &v6, sizeof(AIDirection));
+        memcpy(&v14, &v15, sizeof(AIDirection));
+        if ( curr_actor->uAIState == Dying )
         {
-        curr_actor=&pActors[i];
-        shrinked=pActors[i].pActorBuffs[ACTOR_BUFF_SHRINK].uExpireTime > 0;
-        for (j =0; j<22; ++j) //check expired spell Buffs
-            {
-            if(j != 10)
-                pActors[i].pActorBuffs[j].IsBuffExpiredToTime(pParty->uTimePlayed);
-            }
-        if (shrinked && pActors[i].pActorBuffs[ACTOR_BUFF_SHRINK].uExpireTime <=0) //buff 3 expired
-            {
-            pActors[i].uActorHeight = pMonsterList->pMonsters[pActors[i].pMonsterInfo.uID - 1].uMonsterHeight;
-            }
-        if(!(curr_actor->uAttributes&0x80)&&
-              (!curr_actor->pActorBuffs[ACTOR_BUFF_STONED].uExpireTime)&&
-              (!curr_actor->pActorBuffs[ACTOR_BUFF_PARALYZED].uExpireTime)) 
-            {
-            curr_actor->uCurrentActionTime += pMiscTimer->uTimeElapsed;
-            if (curr_actor->uCurrentActionTime>=curr_actor->uCurrentActionLength)
-                {
-                target_pid = ai_near_actors_targets_pid[i];
-                Actor::GetDirectionInfo(PID(OBJECT_Actor,i), target_pid, &v6, 0);  
-                memcpy(&v15, &v6, sizeof(AIDirection));   
-                memcpy(&v14, &v15, sizeof(AIDirection));
-                v7 = curr_actor->uAIState;
-                if(v7==Dying)
-                    {
-                    curr_actor->uCurrentActionTime = 0;
-                    curr_actor->uCurrentActionLength = 0;
-                    curr_actor->uAIState = Dead;
-                    curr_actor->UpdateAnimation();
-                    }
-                else  if ( (v7 > AIState::Removed)&&(v7 < AIState::Disabled))
-                    {
-                     Actor::AI_StandOrBored(i, target_pid, 32, &v14);
-                    }
-                }
-            }
+          curr_actor->uCurrentActionTime = 0;
+          curr_actor->uCurrentActionLength = 0;
+          curr_actor->uAIState = Dead;
+          curr_actor->UpdateAnimation();
         }
-    
-    if ( turn_stage == 1 )
-        {
-        if ( ai_turn_timer == 64 )
-            ActorAISetMovementDecision();
-        else  if ( ai_turn_timer > 0 )
-            ActorAIDoAdditionalMove();
-        else
-            {
-             ActorAIStopMovement();
-             turn_initiative = 100;
-            }
-        ai_turn_timer -= pEventTimer->uTimeElapsed;
-        }
-    else if ( turn_stage == 2 )
-        {
-        if ( !(field_18 &TE_FLAG_1))
-            {
-            if ( turn_initiative == 100 )
-                {
-                StartTurn();
-                SetAIRecoveryTimes();
-                return;
-                }
-            if ( turn_initiative > 0 || pQueue[0].actor_initiative <= 0 )
-                {
-                _4065B0();
-                SetAIRecoveryTimes();
-                }
-            }
-        NextTurn();
-        }
-    else if ( turn_stage == 3 )
-        {
-        if ( (uActionPointsLeft > 0) && (!(field_18 & TE_FLAG_8)) )
-           ActorAIChooseNewTargets();
-        else
-            { 
-            field_18 &= ~TE_FLAG_8;
-            turn_stage = 1;
-            ai_turn_timer = 64; 
-            }
-        }
+        else  if ( (curr_actor->uAIState > AIState::Removed) && (curr_actor->uAIState < AIState::Disabled))
+          Actor::AI_StandOrBored(i, target_pid, 32, &v14);
+      }
+    }
+  }
+  if ( turn_stage == TE_WAIT )
+  {
+    if ( ai_turn_timer == 64 )
+      ActorAISetMovementDecision();
+    else  if ( ai_turn_timer > 0 )
+      ActorAIDoAdditionalMove();
+    else
+    {
+      ActorAIStopMovement();
+      turn_initiative = 100;
     }
+    ai_turn_timer -= pEventTimer->uTimeElapsed;
+  }
+  else if ( turn_stage == TE_ATTACK )
+  {
+    if ( !(field_18 &TE_FLAG_1))
+    {
+      if ( turn_initiative == 100 )
+      {
+        StartTurn();
+        SetAIRecoveryTimes();
+        return;
+      }
+      if ( turn_initiative > 0 || pQueue[0].actor_initiative <= 0 )
+      {
+        _4065B0();
+        SetAIRecoveryTimes();
+        return;
+      }
+    }
+    NextTurn();
+  }
+  else if ( turn_stage == TE_MOVEMENT )
+  {
+    if ( (uActionPointsLeft > 0) && (!(field_18 & TE_FLAG_8)) )
+      ActorAIChooseNewTargets();
+    else
+    {
+      field_18 &= ~TE_FLAG_8;
+      turn_stage = TE_WAIT;
+      ai_turn_timer = 64; 
+    }
+  }
+}
 
 
 //----- (00406051) --------------------------------------------------------
- void stru262_TurnBased::StartTurn()
-    {
-    int player_num, actor_num, i, j;
+void stru262_TurnBased::StartTurn()
+{
+  int player_num, actor_num, i, j;
 
-    pending_actions = 0;
-    //add player to queue if he can act
-    for(player_num=0; player_num<4; ++player_num) 
-        {
-        for(j=0; j<uActorQueueSize; ++j) 
-            {
-            if (PID_TYPE(pQueue[j].uPackedID)== OBJECT_Player)
-                {
-                if (pPlayers[PID_ID(pQueue[j].uPackedID) + 1]->CanAct() && (player_num != PID_ID(pQueue[j].uPackedID)) )
-                    break;
-                }
-            }
-         if (j==uActorQueueSize )
-             {
-             pQueue[uActorQueueSize].uPackedID = PID(OBJECT_Player,player_num);
-             pQueue[uActorQueueSize].actor_initiative = 100;
-             pQueue[uActorQueueSize].uActionLength = 0;
-             pQueue[uActorQueueSize].AI_action_type = TE_AI_STAND;
-             ++uActorQueueSize;
-             }
-        }
-    //add new arrived actors
-    for(actor_num=0; actor_num<ai_arrays_size; ++actor_num) 
-        {
-        for(j=0; j<uActorQueueSize; ++j) 
-            {
-            if ((PID_TYPE(pQueue[j].uPackedID)== OBJECT_Actor)&&
-                 ai_near_actors_ids[actor_num] == PID_ID(pQueue[j].uPackedID))
-                    break;
-            }
-        if (j==uActorQueueSize )
-            {
-            pQueue[uActorQueueSize].uPackedID = PID(OBJECT_Actor,ai_near_actors_ids[actor_num]);
-            pQueue[uActorQueueSize].actor_initiative = 1;
-            pQueue[uActorQueueSize].uActionLength = 0;
-            pQueue[uActorQueueSize].AI_action_type = TE_AI_STAND;
-            ++uActorQueueSize;
-            }
-        }
-
-    ++turns_count;
-    turn_initiative = 100;
-
-    for(i=0; i<uActorQueueSize; ++i) 
-        {
-        if (pQueue[i].actor_initiative == 0 )
-            pQueue[i].actor_initiative = 100;
-        }
-
-    StepTurnQueue();
-    for(i=0; i<uActorQueueSize; ++i) 
-        {
-        if ((PID_TYPE(pQueue[i].uPackedID)==OBJECT_Player)||(pQueue[i].actor_initiative > 0))
-            break;
-        AI_Action_(i);
-        }
+  pending_actions = 0;
+  //add player to queue if he can act
+  for ( player_num = 0; player_num < 4; ++player_num)
+  {
+    for ( j = 0; j < uActorQueueSize; ++j )
+    {
+      if (PID_TYPE(pQueue[j].uPackedID) == OBJECT_Player)
+      {
+        if (pPlayers[PID_ID(pQueue[j].uPackedID) + 1]->CanAct() && (player_num != PID_ID(pQueue[j].uPackedID)) )
+          break;
+      }
+    }
+    if ( j == uActorQueueSize )
+    {
+      pQueue[uActorQueueSize].uPackedID = PID(OBJECT_Player,player_num);
+      pQueue[uActorQueueSize].actor_initiative = 100;
+      pQueue[uActorQueueSize].uActionLength = 0;
+      pQueue[uActorQueueSize].AI_action_type = TE_AI_STAND;
+      ++uActorQueueSize;
     }
+  }
+  //add new arrived actors
+  for ( actor_num = 0; actor_num < ai_arrays_size; ++actor_num )
+  {
+    for ( j = 0; j < uActorQueueSize; ++j )
+    {
+      if ((PID_TYPE(pQueue[j].uPackedID)== OBJECT_Actor)&&
+           ai_near_actors_ids[actor_num] == PID_ID(pQueue[j].uPackedID))
+        break;
+    }
+    if ( j == uActorQueueSize )
+    {
+      pQueue[uActorQueueSize].uPackedID = PID(OBJECT_Actor,ai_near_actors_ids[actor_num]);
+      pQueue[uActorQueueSize].actor_initiative = 1;
+      pQueue[uActorQueueSize].uActionLength = 0;
+      pQueue[uActorQueueSize].AI_action_type = TE_AI_STAND;
+      ++uActorQueueSize;
+    }
+  }
+  ++turns_count;
+  turn_initiative = 100;
+  for ( i = 0; i < uActorQueueSize; ++i )
+  {
+    if (pQueue[i].actor_initiative == 0 )
+      pQueue[i].actor_initiative = 100;
+  }
+  StepTurnQueue();
+  for ( i = 0; i < uActorQueueSize; ++i )
+  {
+    if ((PID_TYPE(pQueue[i].uPackedID) == OBJECT_Player) || (pQueue[i].actor_initiative > 0))
+      break;
+    AI_Action_(i);
+  }
+}
 // 4F75D8: using guessed type int ai_arrays_size;
 
  //----- (004061CA) --------------------------------------------------------
  void stru262_TurnBased::NextTurn()
-     {
-     Actor *curr_actor; // eax@9
-     int ai_state; // ecx@9
-     int v13; // [sp+10h] [bp-4h]@7
-     int i;
-     int monster_ai_state;
-     int monster; // eax@5
+{
+  int v13; // [sp+10h] [bp-4h]@7
+  int monster_id; // eax@5
 
-     SortTurnQueue();
-     if (PID_TYPE(pQueue[0].uPackedID) == OBJECT_Player)
-         uActiveCharacter = PID_ID(pQueue[0].uPackedID) + 1;
-     else
-         uActiveCharacter = 0;
-     viewparams->bRedrawGameUI = 1;
+  SortTurnQueue();
+  if (PID_TYPE(pQueue[0].uPackedID) == OBJECT_Player)
+    uActiveCharacter = PID_ID(pQueue[0].uPackedID) + 1;
+  else
+    uActiveCharacter = 0;
+  viewparams->bRedrawGameUI = true;
 
-     if ( pending_actions )
-         {
-         pTurnEngine->field_18 |= TE_HAVE_PENDING_ACTIONS;
-         return;
-         }
-     pTurnEngine->field_18 &= ~TE_HAVE_PENDING_ACTIONS;
-     if ( pQueue[0].actor_initiative <= 0 )
-         return;
-
-     v13 = 0;
-     if (uActorQueueSize > 0 )
-         {   
+  if ( pending_actions )
+  {
+    pTurnEngine->field_18 |= TE_HAVE_PENDING_ACTIONS;
+    return;
+  }
+  pTurnEngine->field_18 &= ~TE_HAVE_PENDING_ACTIONS;
+  if ( pQueue[0].actor_initiative <= 0 )
+    return;
 
-         for (i=0; i<uActorQueueSize; ++i )
-             {
-             if (PID_TYPE(pQueue[i].uPackedID) == OBJECT_Actor)
-                 {
-                 curr_actor = &pActors[PID_ID(pQueue[i].uPackedID)];
-                 ai_state = curr_actor->uAIState;
-                 if ( (ai_state == AIState::Dying) || (ai_state == AIState::Stunned) || (ai_state == AIState::AttackingMelee) ||
-                     (ai_state == AIState::AttackingRanged1) || (ai_state == AIState::AttackingRanged2) || 
-                     (ai_state == AIState::AttackingRanged3) || (ai_state == AIState::AttackingRanged4) || (ai_state ==AIState::Summoned))
-                     {
-                     curr_actor->uCurrentActionTime += pEventTimer->uTimeElapsed;
-                     if ( curr_actor->uCurrentActionTime < curr_actor->uCurrentActionLength )
-                         {
-                         v13 = 1;
-                         }
-                     else if ( ai_state == AIState::Dying )// Dying
-                         {
-                         curr_actor->uAIState = AIState::Dead;
-                         curr_actor->uCurrentActionTime = 0;
-                         curr_actor->uCurrentActionLength = 0;
-                         curr_actor->UpdateAnimation();
-                         }
-                     else
-                         {
-                         if ( ai_state == AIState::Stunned ) //Stunned
-                             Actor::AI_StandOrBored(PID_ID(pQueue[i].uPackedID), ai_near_actors_targets_pid[PID_ID(pQueue[i].uPackedID)], 32, 0);
-                         }
-                     }
-                 }
-             }
-         if ( v13 != 0 )
-             {
-             field_18 |= TE_FLAG_1;
-             return;
-             }
-         }
+  v13 = 0;
+  if (uActorQueueSize > 0 )
+  {
+    for ( int i = 0; i < uActorQueueSize; ++i )
+    {
+      if (PID_TYPE(pQueue[i].uPackedID) == OBJECT_Actor)
+      {
+        monster_id = PID_ID(pQueue[i].uPackedID);
+        if ( (pActors[monster_id].uAIState == AIState::Dying) || (pActors[monster_id].uAIState == AIState::Stunned)
+          || (pActors[monster_id].uAIState == AIState::AttackingMelee) || (pActors[monster_id].uAIState == AIState::AttackingRanged1)
+          || (pActors[monster_id].uAIState == AIState::AttackingRanged2) || (pActors[monster_id].uAIState == AIState::AttackingRanged3)
+          || (pActors[monster_id].uAIState == AIState::AttackingRanged4) || (pActors[monster_id].uAIState ==AIState::Summoned))
+        {
+          pActors[monster_id].uCurrentActionTime += pEventTimer->uTimeElapsed;
+          if ( pActors[monster_id].uCurrentActionTime < pActors[monster_id].uCurrentActionLength )
+            v13 = 1;
+          else if ( pActors[monster_id].uAIState == AIState::Dying )// Dying
+          {
+            pActors[monster_id].uAIState = AIState::Dead;
+            pActors[monster_id].uCurrentActionTime = 0;
+            pActors[monster_id].uCurrentActionLength = 0;
+            pActors[monster_id].UpdateAnimation();
+          }
+          else
+          {
+            if ( pActors[monster_id].uAIState == AIState::Stunned ) //Stunned
+              Actor::AI_StandOrBored(monster_id, ai_near_actors_targets_pid[monster_id], 32, 0);
+          }
+        }
+      }
+    }
+    if ( v13 != 0 )
+    {
+      field_18 |= TE_FLAG_1;
+      return;
+    }
+  }
 
-     field_18 &= ~TE_FLAG_1;   
-     //set all actors to stay
-     for (i=0; i<uActorQueueSize; ++i )
-         {      
-         if(PID_TYPE(pQueue[i].uPackedID) == OBJECT_Actor) 
-             {
-             monster=PID_ID(pQueue[i].uPackedID);
-             monster_ai_state=pActors[monster].uAIState;
-             if ((monster_ai_state != AIState::Dead) && 
-                 (monster_ai_state != AIState::Dying) &&
-                 (monster_ai_state != AIState::Removed) &&
-                 (monster_ai_state != AIState::Summoned) &&
-                 (monster_ai_state != AIState::Disabled))
-                 {
-                 pQueue[i].uActionLength = 0;
-                 Actor::AI_StandOrBored(monster, ai_near_actors_targets_pid[monster], 32, nullptr);
-                 }
-             }
-         }
-     // turn tick
-     turn_stage = 3;
-     pParty->uTimePlayed += 213i64;
-     _494035_timed_effects__water_walking_damage__etc();
-     uActionPointsLeft = 130;
-     }
+  field_18 &= ~TE_FLAG_1;
+  //set all actors to stay
+  for ( int i = 0; i < uActorQueueSize; ++i )
+  {
+    if(PID_TYPE(pQueue[i].uPackedID) == OBJECT_Actor) 
+    {
+      monster_id = PID_ID(pQueue[i].uPackedID);
+      if ((pActors[monster_id].uAIState != AIState::Dead) && (pActors[monster_id].uAIState != AIState::Dying) &&
+          (pActors[monster_id].uAIState != AIState::Removed) && (pActors[monster_id].uAIState != AIState::Summoned) &&
+          (pActors[monster_id].uAIState != AIState::Disabled))
+      {
+        pQueue[i].uActionLength = 0;
+        Actor::AI_StandOrBored(monster_id, ai_near_actors_targets_pid[monster_id], 32, nullptr);
+      }
+    }
+  }
+  // turn tick
+  turn_stage = TE_MOVEMENT;
+  pParty->uTimePlayed += 213i64;
+  _494035_timed_effects__water_walking_damage__etc();
+  uActionPointsLeft = 130;
+}
 
- //----- (004063A1) --------------------------------------------------------
- bool stru262_TurnBased::StepTurnQueue()
- {
-     int v9; // dx@12 
-     int j;
+//----- (004063A1) --------------------------------------------------------
+bool stru262_TurnBased::StepTurnQueue()
+{
+  int v9; // dx@12 
+  int j;
 
-     SortTurnQueue();
-     viewparams->bRedrawGameUI = 1;
-     if ( pQueue[0].actor_initiative!=0 )
-         {
-         if (PID_TYPE(pQueue[0].uPackedID) == OBJECT_Player)
-             {
-             do
-                 {
-                 for (j=0; j<uActorQueueSize; ++j )
-                     {      
-                     --pQueue[j].actor_initiative;
-                     }
-                 --turn_initiative;
-                 if (turn_initiative == 0)
-                     return true;
-                 }
-                 while (pQueue[0].actor_initiative != 0);
-             }
-         else
-             {
-             if ( pQueue[0].actor_initiative>0 )
-                 {            
-             v9 = pActors[PID_ID(pQueue[0].uPackedID)].uAIState;
-             if (!(v9 == AIState::Dying || v9 == AIState::Dead || 
-                   v9 == AIState::Disabled || v9 == AIState::Removed))
-                 {
-                    do
-                     {
-                     for (j=0; j<uActorQueueSize; ++j )
-                         {      
-                         --pQueue[j].actor_initiative;
-                         if (pQueue[j].actor_initiative == 0)
-                             pQueue[j].uActionLength = 0;
-                         }
-                     --turn_initiative;
-                     if (turn_initiative == 0)
-                         return true;
-                     }
-                     while (pQueue[0].actor_initiative > 0); 
-                 }
-                 }
-             }
-         }
-     return false;
-     }
+  SortTurnQueue();
+  viewparams->bRedrawGameUI = 1;
+  if ( pQueue[0].actor_initiative != 0 )
+  {
+    if (PID_TYPE(pQueue[0].uPackedID) == OBJECT_Player)
+    {
+      do
+      {
+        for (j = 0; j < uActorQueueSize; ++j )
+          --pQueue[j].actor_initiative;
+        --turn_initiative;
+        if (turn_initiative == 0)
+          return true;
+      }
+      while (pQueue[0].actor_initiative != 0);
+    }
+    else
+    {
+      if ( pQueue[0].actor_initiative > 0 )
+      {
+        v9 = pActors[PID_ID(pQueue[0].uPackedID)].uAIState;
+        if (!(v9 == AIState::Dying || v9 == AIState::Dead || 
+              v9 == AIState::Disabled || v9 == AIState::Removed))
+        {
+          do
+          {
+            for ( j = 0; j < uActorQueueSize; ++j )
+            {
+              --pQueue[j].actor_initiative;
+              if (pQueue[j].actor_initiative == 0)
+                pQueue[j].uActionLength = 0;
+            }
+            --turn_initiative;
+            if (turn_initiative == 0)
+              return true;
+          }
+          while (pQueue[0].actor_initiative > 0); 
+        }
+      }
+    }
+  }
+  return false;
+}
 
 //----- (00406457) --------------------------------------------------------
 void stru262_TurnBased::_406457( int a2 )
-    {
-    signed int v4; // ecx@2
-    signed int v6; // eax@2
-    int i;
-    v6=0;
-    if (  PID_TYPE(pQueue[a2].uPackedID) == OBJECT_Player)
-        {
-        v4 = PID_ID(pQueue[a2].uPackedID);
-        if ( pParty->pTurnBasedPlayerRecoveryTimes[v4] )
-            pParty->pTurnBasedPlayerRecoveryTimes[v4] = 0;
-        else
-            v6 = pPlayers[v4 + 1]->GetAttackRecoveryTime(0);
-        if ( v6 < 30 )
-            v6 = 30;
-        }
+{
+  signed int v4; // ecx@2
+  signed int v6; // eax@2
+  int i;
+  v6 = 0;
+  if (  PID_TYPE(pQueue[a2].uPackedID) == OBJECT_Player)
+  {
+    v4 = PID_ID(pQueue[a2].uPackedID);
+    if ( pParty->pTurnBasedPlayerRecoveryTimes[v4] )
+      pParty->pTurnBasedPlayerRecoveryTimes[v4] = 0;
     else
-        {
-        v6 = pMonsterStats->pInfos[pActors[PID_ID(pQueue[a2].uPackedID)].pMonsterInfo.uID].uRecoveryTime;
-        }
+      v6 = pPlayers[v4 + 1]->GetAttackRecoveryTime(0);
+    if ( v6 < 30 )
+      v6 = 30;
+  }
+  else
+    v6 = pMonsterStats->pInfos[pActors[PID_ID(pQueue[a2].uPackedID)].pMonsterInfo.uID].uRecoveryTime;
 
-    pQueue[a2].actor_initiative = v6;
-    SortTurnQueue();
-    if (PID_TYPE(pQueue[0].uPackedID) == OBJECT_Player)
-        uActiveCharacter = PID_ID(pQueue[0].uPackedID) + 1;
-    else
-        uActiveCharacter = 0;
-    viewparams->bRedrawGameUI = 1;
-
-    while ( (pQueue[0].actor_initiative > 0)&&(turn_initiative > 0) )
-        {
-        for (i=0; i<uActorQueueSize; ++i)
-            {
-            --pQueue[i].actor_initiative;
-            if (pQueue[i].actor_initiative==0)
-                pQueue[i].uActionLength=0;
-            }
-        --turn_initiative;
-        }
+  pQueue[a2].actor_initiative = v6;
+  SortTurnQueue();
+  if (PID_TYPE(pQueue[0].uPackedID) == OBJECT_Player)
+    uActiveCharacter = PID_ID(pQueue[0].uPackedID) + 1;
+  else
+    uActiveCharacter = 0;
+  viewparams->bRedrawGameUI = 1;
+  while ( (pQueue[0].actor_initiative > 0) && (turn_initiative > 0) )
+  {
+    for ( i = 0; i < uActorQueueSize; ++i)
+    {
+      --pQueue[i].actor_initiative;
+      if (pQueue[i].actor_initiative == 0)
+        pQueue[i].uActionLength=0;
     }
+    --turn_initiative;
+  }
+}
 
 //----- (0040652A) --------------------------------------------------------
 void stru262_TurnBased::SetAIRecoveryTimes()
-    {
-    int i;
-    int monster_ai_state;
-    Actor *monster; // eax@5
+{
+  int i;
+  int monster_ai_state;
+  Actor *monster; // eax@5
 
-    for (i=0; i<uActorQueueSize; ++i )
-        {
-        if (pQueue[i].actor_initiative == 0)
-            {
-            if(PID_TYPE(pQueue[i].uPackedID) == OBJECT_Player) 
-                break;
-            monster=&pActors[PID_ID(pQueue[i].uPackedID)];
-            monster_ai_state=monster->uAIState;
-            if (monster_ai_state == AIState::Standing || 
-                monster_ai_state == AIState::Fleeing || 
-                monster_ai_state == AIState::Fidgeting)
-                {
-                pQueue[i].actor_initiative = pMonsterStats->pInfos[monster->pMonsterInfo.uID].uRecoveryTime;
-                if (monster->pActorBuffs[ACTOR_BUFF_SLOWED].uExpireTime > 0)
-                    pQueue[i].actor_initiative*=2;
-                }
-            }
-        }
+  for ( i = 0; i < uActorQueueSize; ++i )
+  {
+    if (pQueue[i].actor_initiative == 0)
+    {
+      if(PID_TYPE(pQueue[i].uPackedID) == OBJECT_Player) 
+        break;
+      monster=&pActors[PID_ID(pQueue[i].uPackedID)];
+      monster_ai_state=monster->uAIState;
+      if (monster_ai_state == AIState::Standing || 
+          monster_ai_state == AIState::Fleeing || 
+          monster_ai_state == AIState::Fidgeting)
+      {
+        pQueue[i].actor_initiative = pMonsterStats->pInfos[monster->pMonsterInfo.uID].uRecoveryTime;
+        if (monster->pActorBuffs[ACTOR_BUFF_SLOWED].uExpireTime > 0)
+          pQueue[i].actor_initiative*=2;
+      }
     }
+  }
+}
 
 //----- (004065B0) --------------------------------------------------------
 void stru262_TurnBased::_4065B0()
 {
-    int i;
+  int i;
 
-    SortTurnQueue();
-    if (pQueue[0].actor_initiative <= 0)
-        {  
-        for (i=0; i<uActorQueueSize; ++i )
-            {
-            if ((PID_TYPE(pQueue[i].uPackedID)==OBJECT_Player)|| (pQueue[i].actor_initiative > 0) )
-                break;
-            if ((pQueue[i].uActionLength<=0) && (PID_TYPE(pQueue[i].uPackedID)==OBJECT_Actor))
-                AI_Action_(i);
-            }
-        }
+  SortTurnQueue();
+  if (pQueue[0].actor_initiative <= 0)
+  {
+    for ( i = 0; i < uActorQueueSize; ++i )
+    {
+      if ((PID_TYPE(pQueue[i].uPackedID) == OBJECT_Player)|| (pQueue[i].actor_initiative > 0) )
+        break;
+      if ((pQueue[i].uActionLength <= 0) && (PID_TYPE(pQueue[i].uPackedID) == OBJECT_Actor))
+        AI_Action_(i);
+    }
+  }
+  else
+  {
+    StepTurnQueue();
+    if (PID_TYPE(pQueue[0].uPackedID) == OBJECT_Player) 
+      uActiveCharacter = PID_ID(pQueue[0].uPackedID) + 1;
     else
-        {
-        StepTurnQueue();
-        if (PID_TYPE(pQueue[0].uPackedID) == OBJECT_Player) 
-            uActiveCharacter = PID_ID(pQueue[0].uPackedID) + 1;
-        else
-            uActiveCharacter = 0;
-        viewparams->bRedrawGameUI = 1;
-        }
-
-    for (i=0; i<uActorQueueSize; ++i )
-        AIAttacks(i);
+      uActiveCharacter = 0;
+    viewparams->bRedrawGameUI = 1;
+  }
+  for ( i = 0; i < uActorQueueSize; ++i )
+    AIAttacks(i);
 }
 
 //----- (00406648) --------------------------------------------------------
 void stru262_TurnBased::AIAttacks( unsigned int queue_index )
 {
-    TurnBased_QueueElem *v1; // ecx@1
-    int v3; // eax@1
-    unsigned int v4; // ebx@2
-    Actor *v5; // esi@2
-    char v19; // al@24
-    AIDirection a3; // [sp+Ch] [bp-3Ch]@2
-    AIDirection a4; // [sp+28h] [bp-20h]@2
-    TurnBased_QueueElem *v28; // [sp+44h] [bp-4h]@1
-    unsigned int a2a; // [sp+50h] [bp+8h]@2
+  //TurnBased_QueueElem *v1; // ecx@1
+  //int v3; // eax@1
+  unsigned int actor_id; // ebx@2
+  //Actor *v5; // esi@2
+  char v19; // al@24
+  AIDirection a3; // [sp+Ch] [bp-3Ch]@2
+  AIDirection a4; // [sp+28h] [bp-20h]@2
+  //TurnBased_QueueElem *v28; // [sp+44h] [bp-4h]@1
+  //unsigned int a2a; // [sp+50h] [bp+8h]@2
 
-    v1 = &pQueue[queue_index];
-    v28 = v1;
-    v3 = v1->uPackedID;
-    if (PID_TYPE(pQueue[queue_index].uPackedID) == OBJECT_Actor)
+  //v1 = &pQueue[queue_index];
+  //v28 = v1;
+  //v3 = pQueue[queue_index].uPackedID;
+  if (PID_TYPE(pQueue[queue_index].uPackedID) == OBJECT_Actor)
+  {
+    actor_id = PID_ID(pQueue[queue_index].uPackedID);
+    //a2a = ai_near_actors_targets_pid[v4];
+    Actor::GetDirectionInfo(pQueue[queue_index].uPackedID, ai_near_actors_targets_pid[actor_id], &a3, 0);
+    memcpy(&a4, &a3, sizeof(a4));
+    //v5 = &pActors[v4];
+    //LOWORD(v3) = v5->uAIState;
+    if (( pActors[actor_id].uAIState != AIState::Dead ) && ( pActors[actor_id].uAIState != AIState::Disabled )
+      &&( pActors[actor_id].uAIState != AIState::Removed ))
+    {
+      pActors[actor_id].uCurrentActionTime += pEventTimer->uTimeElapsed;
+      if ( (signed int)pActors[actor_id].uCurrentActionTime >= pActors[actor_id].uCurrentActionLength )
+      {
+        switch (pActors[actor_id].uAIState)
         {
-        v4 = PID_ID(v3);
-        a2a = ai_near_actors_targets_pid[PID_ID(pQueue[queue_index].uPackedID)];
-        Actor::GetDirectionInfo(v1->uPackedID, ai_near_actors_targets_pid[PID_ID(v3)], &a3, 0);
-        memcpy(&a4, &a3, sizeof(a4));
-        v5 = &pActors[PID_ID(v3)];
-        LOWORD(v3) = v5->uAIState;
-        if (( (short)v3 != AIState::Dead )&& ( (short)v3 != AIState::Disabled )&&( (short)v3 != AIState::Removed ))  
-                    {
-                    v5->uCurrentActionTime += pEventTimer->uTimeElapsed;
-                    if ( (signed int)v5->uCurrentActionTime >= v5->uCurrentActionLength )
-                        {
-                         switch (v3)
-                         {
-                           case  AIState::AttackingMelee:
-                             v19 = pActors[v4].special_ability_use_check(v4);
-                             AttackerInfo.Add( v28->uPackedID,  5120,  v5->vPosition.x, v5->vPosition.y, v5->vPosition.z + ((signed int)v5->uActorHeight >> 1), v19,  1);
-                             Actor::AI_Stand(v4, a2a, 0, &a4);
-                             break;
-                           case AIState::AttackingRanged1:
-                             Actor::AI_RangedAttack(v4, &a4, v5->pMonsterInfo.uMissleAttack1Type, 0);
-                             Actor::AI_Stand(v4, a2a, 0,&a4);
-                             break;
-                           case AIState::Dying:
-                             v5->uCurrentActionTime = 0;
-                             v5->uCurrentActionLength = 0;
-                             v5->uAIState = Dead;
-                             pActors[v4].UpdateAnimation();
-                             break;
-                           case AIState::Stunned:
-                              Actor::AI_Stand(v4, a2a, 0,&a4);
-                              break;
-                           case AIState::AttackingRanged2:
-                             Actor::AI_RangedAttack(v4, &a4, v5->pMonsterInfo.uMissleAttack2Type, 1);
-                             Actor::AI_Stand(v4, a2a, 0,&a4);
-                             break;
-                           case AIState::AttackingRanged3:
-                             Actor::AI_SpellAttack(v4, &a4, v5->pMonsterInfo.uSpell1ID, 2, v5->pMonsterInfo.uSpellSkillAndMastery1);
-                             Actor::AI_Stand(v4, a2a, 0, &a4);
-                             break;
-                           case AIState::AttackingRanged4:
-                             Actor::AI_SpellAttack(v4, &a4, v5->pMonsterInfo.uSpell2ID, 3, v5->pMonsterInfo.uSpellSkillAndMastery2);
-                             Actor::AI_Stand(v4, a2a, 0, &a4);
-                             break;
-                           default:
-                             if ( !(rand() % 2) )
-                               Actor::AI_Bored(v4, a2a, &a4);
-                             else
-                               Actor::AI_Stand(v4, a2a, 64,&a4);
-                         }
-                    }
+          case  AIState::AttackingMelee:
+            v19 = pActors[actor_id].special_ability_use_check(actor_id);
+            AttackerInfo.Add( pQueue[queue_index].uPackedID,  5120,  pActors[actor_id].vPosition.x, pActors[actor_id].vPosition.y,
+                              pActors[actor_id].vPosition.z + ((signed int)pActors[actor_id].uActorHeight >> 1), v19,  1);
+            Actor::AI_Stand(actor_id, ai_near_actors_targets_pid[actor_id], 0, &a4);
+            break;
+          case AIState::AttackingRanged1:
+            Actor::AI_RangedAttack(actor_id, &a4, pActors[actor_id].pMonsterInfo.uMissleAttack1Type, 0);
+            Actor::AI_Stand(actor_id, ai_near_actors_targets_pid[actor_id], 0,&a4);
+            break;
+          case AIState::Dying:
+            pActors[actor_id].uCurrentActionTime = 0;
+            pActors[actor_id].uCurrentActionLength = 0;
+            pActors[actor_id].uAIState = Dead;
+            pActors[actor_id].UpdateAnimation();
+            break;
+          case AIState::Stunned:
+            Actor::AI_Stand(actor_id, ai_near_actors_targets_pid[actor_id], 0,&a4);
+            break;
+          case AIState::AttackingRanged2:
+            Actor::AI_RangedAttack(actor_id, &a4, pActors[actor_id].pMonsterInfo.uMissleAttack2Type, 1);
+            Actor::AI_Stand(actor_id, ai_near_actors_targets_pid[actor_id], 0,&a4);
+            break;
+          case AIState::AttackingRanged3:
+            Actor::AI_SpellAttack(actor_id, &a4, pActors[actor_id].pMonsterInfo.uSpell1ID, 2, pActors[actor_id].pMonsterInfo.uSpellSkillAndMastery1);
+            Actor::AI_Stand(actor_id, ai_near_actors_targets_pid[actor_id], 0, &a4);
+            break;
+          case AIState::AttackingRanged4:
+            Actor::AI_SpellAttack(actor_id, &a4, pActors[actor_id].pMonsterInfo.uSpell2ID, 3, pActors[actor_id].pMonsterInfo.uSpellSkillAndMastery2);
+            Actor::AI_Stand(actor_id, ai_near_actors_targets_pid[actor_id], 0, &a4);
+            break;
+          default:
+            if ( !(rand() % 2) )
+              Actor::AI_Bored(actor_id, ai_near_actors_targets_pid[actor_id], &a4);
+            else
+              Actor::AI_Stand(actor_id, ai_near_actors_targets_pid[actor_id], 64,&a4);
         }
-
-        }
-        
+      }
     }
+  }
+}
 // 50FE08: using guessed type stru298 AttackerInfo;
 
 //----- (0040680F) --------------------------------------------------------
 void stru262_TurnBased::AI_Action_( int queue_index )
-    {
-    TurnBased_QueueElem *v2; // eax@1
-    unsigned int v3; // eax@1
-    unsigned int actor_id; // edi@2
-    Actor *v5; // ebx@2
-    AIDirection v7; // esi@10
-    int v8; // eax@10
-    int v9; // ecx@10
-    signed int v10; // eax@13
-    int v14; // eax@29
-    AIDirection a3; // [sp+Ch] [bp-44h]@10
-    AIDirection v18; // [sp+28h] [bp-28h]@10
-    int a2a; // [sp+44h] [bp-Ch]@2
-    int v20; // [sp+48h] [bp-8h]@10
-    TurnBased_QueueElem *v21; // [sp+4Ch] [bp-4h]@1
-    signed int v22; // [sp+58h] [bp+8h]@10
-
-    v2 = &pQueue[queue_index];
-    v21 = v2;
-    v2->uActionLength = 0;
-    v3 = v2->uPackedID;
-     if (PID_TYPE(pQueue[queue_index].uPackedID) == OBJECT_Actor)
-        {
-   
-        actor_id = PID_ID(pQueue[queue_index].uPackedID);
-        a2a = v3;
-        v5 = &pActors[actor_id];
-        v3 = v5->uAIState;
-        if (!(v3 == AIState::Dying || v3 == AIState::Dead ||  v3 == AIState::Summoned ||
-            v3 == AIState::Disabled || v3 == AIState::Removed))
-            {
-                
-                Actor::_SelectTarget(actor_id, &ai_near_actors_targets_pid[actor_id], true);
-                v22 = ai_near_actors_targets_pid[actor_id];
-                if ( v5->pMonsterInfo.uHostilityType && !v22)
-                    v5->pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Friendly;
-                Actor::GetDirectionInfo(PID(OBJECT_Actor,actor_id), v22, &v7, 0);
-                v8 = v5->uActorRadius;
-                memcpy(&a3, &v7, sizeof(AIDirection));
-                memcpy(&v18, &a3, sizeof(AIDirection));
-                v9 = a3.uDistance - v8;
-                v20 = a3.uDistance - v8;
-                if ( v20 < 0 )
-                    {
-                    v9 = 0;
-                    v20 = 0;
-                    }
-
-                if (PID_TYPE(v22) == OBJECT_Actor)
-                    //v10 = (unsigned __int8)*(&byte_5C8D1A[89 * (pMonsterStats->pInfos[pActors[PID_ID(v22)].pMonsterInfo.uID].uID - 1) / 3] + (v5->pMonsterInfo.uID - 1) / 3);
-                    v10 = pFactionTable->relations[(pMonsterStats->pInfos[pActors[PID_ID(v22)].pMonsterInfo.uID].uID) / 3 + 1][(v5->pMonsterInfo.uID - 1) / 3 + 1];
-                else
-                    v10 = 4;
+{
+  //TurnBased_QueueElem *v2; // eax@1
+  //unsigned int v3; // eax@1
+  unsigned int actor_id; // edi@2
+  //Actor *v5; // ebx@2
+  AIDirection v7; // esi@10
+  //int v8; // eax@10
+  int v9; // ecx@10
+  signed int v10; // eax@13
+  int v14; // eax@29
+  AIDirection a3; // [sp+Ch] [bp-44h]@10
+  AIDirection v18; // [sp+28h] [bp-28h]@10
+  //int a2a; // [sp+44h] [bp-Ch]@2
+  //int v20; // [sp+48h] [bp-8h]@10
+  //TurnBased_QueueElem *v21; // [sp+4Ch] [bp-4h]@1
+  signed int v22; // [sp+58h] [bp+8h]@10
 
-               switch (v10)
-                   {
-               case 1:
-                    if ( (double)(signed int)v20 < 307.2 )
-                        v5->pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Long;
-                   break;
-               case 2:
-                   if ( v20 < 1024 )
-                       v5->pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Long;
-                   break;
-               case 3:
-                   if ( v20 < 2560 )
-                       v5->pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Long;
-                   break;
-               case 4:
-                   if ( v20 < 5120 )
-                       v5->pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Long;
-                   break;
-                   }
-                
-                if ( v5->pMonsterInfo.uHostilityType == 4 && v22 && (signed int)v9 < 5120 )
-                    {
-                    v14 = v5->special_ability_use_check(actor_id);
-                    v21->AI_action_type = TE_AI_STAND;
-                    switch (v14)
-                        {
-                    case 1:
-                        if ( v5->pMonsterInfo.uMissleAttack2Type )
-                            {
-                            Actor::AI_MissileAttack2(actor_id, v22, &v18);
-                            v21->AI_action_type = TE_AI_RANGED_ATTACK;
-                            }   
-                        break;
-                    case 2:
-                        if(v5->pMonsterInfo.uSpell1ID)
-                            {
-                             Actor::AI_SpellAttack1(actor_id, v22, &v18);
-                            v21->AI_action_type = TE_AI_RANGED_ATTACK;
-                            }        
-                        break;
-                    case 3:
-                        if(v5->pMonsterInfo.uSpell2ID)
-                            {
-                            Actor::AI_SpellAttack2(actor_id, v22, &v18);
-                            v21->AI_action_type = TE_AI_RANGED_ATTACK;
-                            }
-                            
-                        break;
-                    default:
-                        if ( v5->pMonsterInfo.uMissleAttack1Type )
-                            {
-                            Actor::AI_MissileAttack1(actor_id, v22, &v18);
-                            v21->AI_action_type = TE_AI_RANGED_ATTACK;
-                            }
-                        }
-                     if (!v21->AI_action_type)
-                        if ( (double)v20 < 307.2)
-                            {
-                            Actor::AI_MeleeAttack(actor_id, v22, &v18);
-                            v21->AI_action_type = TE_AI_MELEE_ATTACK;
-                            }
-                        else
-                            {
-                            Actor::AI_Stand(actor_id, v22, 64, &v18);
-                            v21->AI_action_type = TE_AI_STAND;
-                            }             
+  //v2 = &pQueue[queue_index];
+  //v21 = v2;
+  pQueue[queue_index].uActionLength = 0;
+  //v3 = pQueue[queue_index].uPackedID;
+  if (PID_TYPE(pQueue[queue_index].uPackedID) == OBJECT_Actor)
+  {
+    actor_id = PID_ID(pQueue[queue_index].uPackedID);
+    //a2a = pQueue[queue_index].uPackedID;
+    //v5 = &pActors[actor_id];
+    //v3 = v5->uAIState;
+    if (!(pActors[actor_id].uAIState == AIState::Dying || pActors[actor_id].uAIState == AIState::Dead || pActors[actor_id].uAIState == AIState::Summoned ||
+          pActors[actor_id].uAIState == AIState::Disabled || pActors[actor_id].uAIState == AIState::Removed))
+    {
+      Actor::_SelectTarget(actor_id, &ai_near_actors_targets_pid[actor_id], true);
+      v22 = ai_near_actors_targets_pid[actor_id];
+      if ( pActors[actor_id].pMonsterInfo.uHostilityType && !v22)
+        pActors[actor_id].pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Friendly;
+      Actor::GetDirectionInfo(PID(OBJECT_Actor,actor_id), v22, &v7, 0);
+      //v8 = pActors[actor_id].uActorRadius;
+      memcpy(&a3, &v7, sizeof(AIDirection));
+      memcpy(&v18, &a3, sizeof(AIDirection));
+      v9 = a3.uDistance - pActors[actor_id].uActorRadius;
+      //v20 = a3.uDistance - pActors[actor_id].uActorRadius;
+      if ( v9 < 0 )
+      {
+        v9 = 0;
+        //v20 = 0;
+      }
+      if (PID_TYPE(v22) == OBJECT_Actor)
+        //v10 = (unsigned __int8)*(&byte_5C8D1A[89 * (pMonsterStats->pInfos[pActors[PID_ID(v22)].pMonsterInfo.uID].uID - 1) / 3] + (v5->pMonsterInfo.uID - 1) / 3);
+        v10 = pFactionTable->relations[(pMonsterStats->pInfos[pActors[PID_ID(v22)].pMonsterInfo.uID].uID) / 3 + 1][(pActors[actor_id].pMonsterInfo.uID - 1) / 3 + 1];
+      else
+        v10 = 4;
+      switch (v10)
+      {
+        case 1:
+          if ( (double)(signed int)v9 < 307.2 )
+            pActors[actor_id].pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Long;
+          break;
+        case 2:
+          if ( v9 < 1024 )
+            pActors[actor_id].pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Long;
+          break;
+        case 3:
+          if ( v9 < 2560 )
+            pActors[actor_id].pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Long;
+          break;
+        case 4:
+          if ( v9 < 5120 )
+            pActors[actor_id].pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Long;
+          break;
+      }
+      if ( pActors[actor_id].pMonsterInfo.uHostilityType == 4 && v22 && (signed int)v9 < 5120 )
+      {
+        v14 = pActors[actor_id].special_ability_use_check(actor_id);
+        pQueue[queue_index].AI_action_type = TE_AI_STAND;
+        switch (v14)
+        {
+          case 1:
+            if ( pActors[actor_id].pMonsterInfo.uMissleAttack2Type )
+            {
+              Actor::AI_MissileAttack2(actor_id, v22, &v18);
+              pQueue[queue_index].AI_action_type = TE_AI_RANGED_ATTACK;
             }
-                else
-                    {
-                    Actor::AI_Stand(actor_id, v22, 64, &v18);
-                    v21->AI_action_type = TE_AI_STAND;
-                    }
-               v21->uActionLength = v5->uCurrentActionLength;
+            break;
+          case 2:
+            if ( pActors[actor_id].pMonsterInfo.uSpell1ID )
+            {
+              Actor::AI_SpellAttack1(actor_id, v22, &v18);
+              pQueue[queue_index].AI_action_type = TE_AI_RANGED_ATTACK;
+            }
+            break;
+          case 3:
+            if (pActors[actor_id].pMonsterInfo.uSpell2ID)
+            {
+              Actor::AI_SpellAttack2(actor_id, v22, &v18);
+              pQueue[queue_index].AI_action_type = TE_AI_RANGED_ATTACK;
+            }
+            break;
+          default:
+            if ( pActors[actor_id].pMonsterInfo.uMissleAttack1Type )
+            {
+              Actor::AI_MissileAttack1(actor_id, v22, &v18);
+              pQueue[queue_index].AI_action_type = TE_AI_RANGED_ATTACK;
+            }
         }
-        }
+        if (!pQueue[queue_index].AI_action_type)
+          if ( (double)v9 < 307.2)
+          {
+            Actor::AI_MeleeAttack(actor_id, v22, &v18);
+            pQueue[queue_index].AI_action_type = TE_AI_MELEE_ATTACK;
+          }
+          else
+          {
+            Actor::AI_Stand(actor_id, v22, 64, &v18);
+            pQueue[queue_index].AI_action_type = TE_AI_STAND;
+          }
+      }
+      else
+      {
+        Actor::AI_Stand(actor_id, v22, 64, &v18);
+        pQueue[queue_index].AI_action_type = TE_AI_STAND;
+      }
+      pQueue[queue_index].uActionLength = pActors[actor_id].uCurrentActionLength;
     }
+  }
+}
 
 //----- (00406A63) --------------------------------------------------------
 void stru262_TurnBased::ActorAISetMovementDecision()
-    {
-  
-    AIDirection a3; // [sp+8h] [bp-44h]@5
-    AIDirection v7; // [sp+24h] [bp-28h]@5
-    unsigned int target_pid; // [sp+40h] [bp-Ch]@5
-    int i;
+{
+  AIDirection a3; // [sp+8h] [bp-44h]@5
+  AIDirection v7; // [sp+24h] [bp-28h]@5
+  unsigned int target_pid; // [sp+40h] [bp-Ch]@5
+  int i;
 
-    this->ai_turn_timer = 64;
-    dword_50C994 = 0;
-    uActiveCharacter = 0;
-    for (i=0; i<uActorQueueSize; ++i )
-        {
-        if (PID_TYPE(pQueue[i].uPackedID) == OBJECT_Actor)
-            {
-            target_pid = ai_near_actors_targets_pid[PID_ID(pQueue[i].uPackedID)];
-            Actor::GetDirectionInfo(pQueue[i].uPackedID, target_pid, &v7, 0);
-            if ( !ActorMove(i) )
-                Actor::AI_Stand(PID_ID(pQueue[i].uPackedID), target_pid, 32, &v7);
-            }
-        }   
+  this->ai_turn_timer = 64;
+  dword_50C994 = 0;
+  uActiveCharacter = 0;
+  for ( i = 0; i < uActorQueueSize; ++i )
+  {
+    if (PID_TYPE(pQueue[i].uPackedID) == OBJECT_Actor)
+    {
+      target_pid = ai_near_actors_targets_pid[PID_ID(pQueue[i].uPackedID)];
+      Actor::GetDirectionInfo(pQueue[i].uPackedID, target_pid, &v7, 0);
+      if ( !ActorMove(i) )
+        Actor::AI_Stand(PID_ID(pQueue[i].uPackedID), target_pid, 32, &v7);
     }
+  }
+}
 // 50C994: using guessed type int dword_50C994;
 
 //----- (00406AFE) --------------------------------------------------------
 void stru262_TurnBased::ActorAIStopMovement()
-    {
-    AIDirection a3; // [sp+4h] [bp-48h]@5
-    AIDirection v7; // [sp+20h] [bp-2Ch]@5
-    unsigned int target_pid; 
-    int i;
+{
+  AIDirection a3; // [sp+4h] [bp-48h]@5
+  AIDirection v7; // [sp+20h] [bp-2Ch]@5
+  unsigned int target_pid; 
+  int i;
 
-    for (i=0; i<uActorQueueSize; ++i )
-        {
-        if (PID_TYPE(pQueue[i].uPackedID) == OBJECT_Actor)
-            {
-            target_pid = ai_near_actors_targets_pid[PID_ID(pQueue[i].uPackedID)];
-            Actor::GetDirectionInfo(pQueue[i].uPackedID, target_pid, &v7, 0);
-            Actor::AI_Stand(PID_ID(pQueue[i].uPackedID), target_pid, 32, &v7);
-            pQueue[i].AI_action_type = TE_AI_STAND;
-            pQueue[i].uActionLength = 0;
-            }
-        }   
-    turn_stage = 2;
-    ai_turn_timer = 100;
-
+  for ( i = 0; i < uActorQueueSize; ++i )
+  {
+    if (PID_TYPE(pQueue[i].uPackedID) == OBJECT_Actor)
+    {
+      target_pid = ai_near_actors_targets_pid[PID_ID(pQueue[i].uPackedID)];
+      Actor::GetDirectionInfo(pQueue[i].uPackedID, target_pid, &v7, 0);
+      Actor::AI_Stand(PID_ID(pQueue[i].uPackedID), target_pid, 32, &v7);
+      pQueue[i].AI_action_type = TE_AI_STAND;
+      pQueue[i].uActionLength = 0;
     }
+  }
+  turn_stage = TE_ATTACK;
+  ai_turn_timer = 100;
+}
 
 //----- (00406B9F) --------------------------------------------------------
 void stru262_TurnBased::ActorAIDoAdditionalMove()
+{
+  AIDirection a3; // [sp+0h] [bp-50h]@15
+  AIDirection v9; // [sp+1Ch] [bp-34h]@15
+  unsigned int v13; // [sp+44h] [bp-Ch]@8
+  unsigned int monster_id;
+
+  for ( int i = 0; i < uActorQueueSize; ++i )
+  {
+    if (PID_TYPE(pQueue[i].uPackedID) == OBJECT_Actor)
     {
-    Actor *v6; // ebx@5
-    AIDirection a3; // [sp+0h] [bp-50h]@15
-    AIDirection v9; // [sp+1Ch] [bp-34h]@15
-    unsigned int v13; // [sp+44h] [bp-Ch]@8
-    int i;
-
-    for (i=0; i<uActorQueueSize; ++i )
+      monster_id = PID_ID(pQueue[i].uPackedID);
+      if ( !(pActors[monster_id].pActorBuffs[ACTOR_BUFF_STONED].uExpireTime > 0|| (pActors[monster_id].pActorBuffs[ACTOR_BUFF_PARALYZED].uExpireTime > 0) || 
+             pActors[monster_id].uAIState == AIState::Dead || pActors[monster_id].uAIState == AIState::Removed || pActors[monster_id].uAIState == AIState::Disabled) )
+      {
+        v13 = ai_near_actors_targets_pid[PID_ID(pQueue[i].uPackedID)];
+        Actor::GetDirectionInfo(pQueue[i].uPackedID, v13, &v9, 0);
+        if ( pActors[monster_id].uAIState == AIState::Pursuing || pActors[monster_id].uAIState == AIState::Tethered ) 
         {
-        if (PID_TYPE(pQueue[i].uPackedID) == OBJECT_Actor)
+          if ( (double)(signed int)v9.uDistance < 307.2 )
+            Actor::AI_Stand(PID_ID(pQueue[i].uPackedID), v13, 32, &v9);
+        }
+        else
+        {
+          pActors[monster_id].uCurrentActionTime += pEventTimer->uTimeElapsed;
+          if ( pActors[monster_id].uCurrentActionTime > pActors[monster_id].uCurrentActionLength )
+          {
+            if ( pActors[monster_id].uAIState == AIState::Dying )
             {
-            v6 = &pActors[PID_ID(pQueue[i].uPackedID)];
-            if ( !(v6->pActorBuffs[ACTOR_BUFF_STONED].uExpireTime > 0|| (v6->pActorBuffs[ACTOR_BUFF_PARALYZED].uExpireTime > 0) || 
-                    v6->uAIState == AIState::Dead || v6->uAIState == AIState::Removed || v6->uAIState == AIState::Disabled) )
-                {
-                v13 = ai_near_actors_targets_pid[PID_ID(pQueue[i].uPackedID)];
-                Actor::GetDirectionInfo(pQueue[i].uPackedID, v13, &v9, 0);
-                if ( v6->uAIState == AIState::Pursuing || v6->uAIState == AIState::Tethered ) 
-                    {
-                    if ( (double)(signed int)v9.uDistance < 307.2 )
-                        Actor::AI_Stand(PID_ID(pQueue[i].uPackedID), v13, 32, &v9);
-                    }
-                else
-                    {           
-                    v6->uCurrentActionTime += pEventTimer->uTimeElapsed;
-                    if ( v6->uCurrentActionTime > v6->uCurrentActionLength )
-                        {
-                        if ( v6->uAIState == AIState::Dying )
-                            {
-                            v6->uCurrentActionTime = 0;
-                            v6->uCurrentActionLength = 0;
-                            v6->uAIState = AIState::Dead;
-                            v6->UpdateAnimation();
-                            }
-                        if ( !ActorMove(i) )
-                            Actor::AI_Stand(PID_ID(pQueue[i].uPackedID), v13, 32, &v9);
-                        }
-                    }
-                }
+              pActors[monster_id].uCurrentActionTime = 0;
+              pActors[monster_id].uCurrentActionLength = 0;
+              pActors[monster_id].uAIState = AIState::Dead;
+              pActors[monster_id].UpdateAnimation();
             }
+            if ( !ActorMove(i) )
+              Actor::AI_Stand(PID_ID(pQueue[i].uPackedID), v13, 32, &v9);
+          }
         }
+      }
     }
+  }
+}
 
 //----- (00406D10) --------------------------------------------------------
 bool stru262_TurnBased::ActorMove(signed int queue_position)
-    {
-    int v2; // ecx@1
-    //int v3; // ecx@2
-    Actor *actor; // ebx@2
-
-    AIDirection v9; // esi@10
-    int v10; // eax@10
-    int v11; // ecx@10
-    unsigned __int8 pHostileType; // al@12
-    AIDirection a3; // [sp+Ch] [bp-48h]@10
-    AIDirection pDir; // [sp+28h] [bp-2Ch]@10
-    int v28; // [sp+48h] [bp-Ch]@10
-    TurnBased_QueueElem *v29; // [sp+4Ch] [bp-8h]@7
-    unsigned int uActorID; // [sp+50h] [bp-4h]@2
-    unsigned int a2a; // [sp+5Ch] [bp+8h]@7
-
-    // __debugbreak();//срабатывает при пошаговом режиме после пяти шагов
-    v2 = pQueue[queue_position].uPackedID;
-    if (PID_TYPE(v2) == OBJECT_Player)
-        return 0;
-    uActorID = PID_ID(v2);
-    //uActorID = v3;
-    actor = &pActors[uActorID];
-    //v5 = v4->uAIState;
-    if ( actor->uAIState == AIState::Dead || actor->uAIState ==  AIState::Dying || 
-         actor->uAIState == AIState::Removed|| actor->uAIState == AIState::Disabled || 
-         actor->uAIState == AIState::Summoned  )
-        return 1;
-    v29 = &pTurnEngine->pQueue[queue_position];
-    a2a = ai_near_actors_targets_pid[uActorID];
-    Actor::_SelectTarget(uActorID, &ai_near_actors_targets_pid[uActorID], true);
-    if ( actor->pMonsterInfo.uHostilityType && !ai_near_actors_targets_pid[uActorID] )
-        actor->pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Friendly;
-    Actor::GetDirectionInfo(pQueue[queue_position].uPackedID, ai_near_actors_targets_pid[uActorID], &v9, 0);
-    v10 = actor->uActorRadius;
-    memcpy(&a3, &v9, sizeof(AIDirection));
-    memcpy(&pDir, &a3, sizeof(AIDirection));
-    v11 = a3.uDistance - v10;
-    v28 = a3.uDistance - v10;
-    if ( v28 < 0 )
-        {
-        v11 = 0;
-        v28 = 0;
-        }
-    pHostileType = actor->pMonsterInfo.uHostilityType;
-   
-    switch (pHostileType)
-        {
-    case 1:
-        if ( (double)v28 < 307.2 )
-            actor->pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Long;
-        break;
-    case 2:
-        if ( v28 < 1024 )
-            actor->pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Long;
-        break;
-    case 3:
-        if ( v28 < 2560 )
-            actor->pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Long;
-        break;
-        }
-
-    if ( actor->pActorBuffs[ACTOR_BUFF_AFRAID].uExpireTime > 0 )
-        {
-        if (v11 < 10240 )
-            {
-            Actor::AI_Flee(uActorID, a2a, 0, &pDir);
-            v29->AI_action_type = 4;
-            }
-        else
-            {
-             Actor::AI_RandomMove(uActorID, a2a, 1024, 0);
-             v29->AI_action_type = TE_AI_PURSUE;
-            }         
-    
-        v29->uActionLength = actor->uCurrentActionLength;
-        return 1;
-        }
+{
+  //int v2; // ecx@1
+  //int v3; // ecx@2
+  //Actor *actor; // ebx@2
+  AIDirection v9; // esi@10
+  //int v10; // eax@10
+  int v11; // ecx@10
+  unsigned __int8 pHostileType; // al@12
+  AIDirection a3; // [sp+Ch] [bp-48h]@10
+  AIDirection pDir; // [sp+28h] [bp-2Ch]@10
+  //int v28; // [sp+48h] [bp-Ch]@10
+  //TurnBased_QueueElem *v29; // [sp+4Ch] [bp-8h]@7
+  unsigned int uActorID; // [sp+50h] [bp-4h]@2
+  //unsigned int a2a; // [sp+5Ch] [bp+8h]@7
 
-    if ( actor->pMonsterInfo.uHostilityType == MonsterInfo::Hostility_Long )
-  {     
-    if ( !(actor->uAttributes & 0x020000) || actor->pMonsterInfo.uAIType == 1 )
+  // __debugbreak();//срабатывает при пошаговом режиме после пяти шагов
+  //v2 = pQueue[queue_position].uPackedID;
+  if (PID_TYPE(pQueue[queue_position].uPackedID) == OBJECT_Player)
+    return 0;
+  uActorID = PID_ID(pQueue[queue_position].uPackedID);
+  //uActorID = v3;
+  //actor = &pActors[uActorID];
+  //v5 = v4->uAIState;
+  if ( pActors[uActorID].uAIState == AIState::Dead || pActors[uActorID].uAIState ==  AIState::Dying || 
+       pActors[uActorID].uAIState == AIState::Removed|| pActors[uActorID].uAIState == AIState::Disabled || 
+       pActors[uActorID].uAIState == AIState::Summoned  )
+    return 1;
+  //v29 = &pTurnEngine->pQueue[queue_position];
+  //a2a = ai_near_actors_targets_pid[uActorID];
+  Actor::_SelectTarget(uActorID, &ai_near_actors_targets_pid[uActorID], true);
+  if ( pActors[uActorID].pMonsterInfo.uHostilityType && !ai_near_actors_targets_pid[uActorID] )
+    pActors[uActorID].pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Friendly;
+  Actor::GetDirectionInfo(pQueue[queue_position].uPackedID, ai_near_actors_targets_pid[uActorID], &v9, 0);
+  //v10 = pActors[uActorID].uActorRadius;
+  memcpy(&a3, &v9, sizeof(AIDirection));
+  memcpy(&pDir, &a3, sizeof(AIDirection));
+  v11 = a3.uDistance - pActors[uActorID].uActorRadius;
+  //v28 = a3.uDistance - pActors[uActorID].uActorRadius;
+  if ( v11 < 0 )
+  {
+    v11 = 0;
+    //v28 = 0;
+  }
+  pHostileType = pActors[uActorID].pMonsterInfo.uHostilityType;
+  switch (pHostileType)
+  {
+    case 1:
+      if ( (double)v11 < 307.2 )
+        pActors[uActorID].pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Long;
+      break;
+    case 2:
+      if ( v11 < 1024 )
+        pActors[uActorID].pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Long;
+      break;
+    case 3:
+      if ( v11 < 2560 )
+        pActors[uActorID].pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Long;
+      break;
+  }
+  if ( pActors[uActorID].pActorBuffs[ACTOR_BUFF_AFRAID].uExpireTime > 0 )
+  {
+    if (v11 < 10240 )
+    {
+      Actor::AI_Flee(uActorID, ai_near_actors_targets_pid[uActorID], 0, &pDir);
+      pTurnEngine->pQueue[queue_position].AI_action_type = 4;
+    }
+    else
+    {
+      Actor::AI_RandomMove(uActorID, ai_near_actors_targets_pid[uActorID], 1024, 0);
+      pTurnEngine->pQueue[queue_position].AI_action_type = TE_AI_PURSUE;
+    }
+    pTurnEngine->pQueue[queue_position].uActionLength = pActors[uActorID].uCurrentActionLength;
+    return true;
+  }
+  if ( pActors[uActorID].pMonsterInfo.uHostilityType == MonsterInfo::Hostility_Long )
+  {
+    if ( !(pActors[uActorID].uAttributes & 0x020000) || pActors[uActorID].pMonsterInfo.uAIType == 1 )
+    {
+      if ( pActors[uActorID].pMonsterInfo.uAIType == 1 )
+      {
+        if ( pActors[uActorID].pMonsterInfo.uMovementType == MONSTER_MOVEMENT_TYPE_STAIONARY )
+          Actor::AI_Stand(uActorID, ai_near_actors_targets_pid[uActorID], 32, 0);
+        else
+          Actor::AI_Flee(uActorID, ai_near_actors_targets_pid[uActorID], 32, 0);
+        pTurnEngine->pQueue[queue_position].AI_action_type = TE_AI_FLEE;
+        pTurnEngine->pQueue[queue_position].uActionLength = pActors[uActorID].uCurrentActionLength;
+        return true;
+      }
+      if ( pActors[uActorID].pMonsterInfo.uAIType == 2 )
+      {
+        if (((double)pActors[uActorID].pMonsterInfo.uHP * 0.2) > (double)pActors[uActorID].sCurrentHP && (v11 < 10240 ) )
         {
-        if ( actor->pMonsterInfo.uAIType == 1 )
-            {
-            if ( actor->pMonsterInfo.uMovementType == MONSTER_MOVEMENT_TYPE_STAIONARY )
-                Actor::AI_Stand(uActorID, a2a, 32, 0);
-            else
-                Actor::AI_Flee(uActorID, a2a, 32, 0);
-            v29->AI_action_type = TE_AI_FLEE;
-            v29->uActionLength = actor->uCurrentActionLength;
-            return 1;
-            }
-        if ( actor->pMonsterInfo.uAIType == 2 )
-            {
-           
-            if (((double)actor->pMonsterInfo.uHP * 0.2) > (double)actor->sCurrentHP && (v11 < 10240 ) )
-                {
-                if ( actor->pMonsterInfo.uMovementType == MONSTER_MOVEMENT_TYPE_STAIONARY )
-                    Actor::AI_Stand(uActorID, a2a, 32, 0);
-                else
-                     Actor::AI_Flee(uActorID, a2a, 32, 0);
-                v29->AI_action_type = TE_AI_FLEE;
-                v29->uActionLength = actor->uCurrentActionLength;
-                return 1;
-                }
-            }
-        if ( actor->pMonsterInfo.uAIType == 3 )
-            {
-
-            if ( ((double)actor->pMonsterInfo.uHP * 0.1) > (double)actor->sCurrentHP && (v11 < 10240 ))
-                {
-                if ( actor->pMonsterInfo.uMovementType == MONSTER_MOVEMENT_TYPE_STAIONARY )
-                    Actor::AI_Stand(uActorID, a2a, 32, 0);
-                else
-                     Actor::AI_Flee(uActorID, a2a, 32, 0);
-                v29->AI_action_type = TE_AI_FLEE;
-                v29->uActionLength = actor->uCurrentActionLength;
-                return 1;
-                }
-
-            }
+          if ( pActors[uActorID].pMonsterInfo.uMovementType == MONSTER_MOVEMENT_TYPE_STAIONARY )
+            Actor::AI_Stand(uActorID, ai_near_actors_targets_pid[uActorID], 32, 0);
+          else
+            Actor::AI_Flee(uActorID, ai_near_actors_targets_pid[uActorID], 32, 0);
+          pTurnEngine->pQueue[queue_position].AI_action_type = TE_AI_FLEE;
+          pTurnEngine->pQueue[queue_position].uActionLength = pActors[uActorID].uCurrentActionLength;
+          return true;
+        }
+      }
+      if ( pActors[uActorID].pMonsterInfo.uAIType == 3 )
+      {
+        if ( ((double)pActors[uActorID].pMonsterInfo.uHP * 0.1) > (double)pActors[uActorID].sCurrentHP && (v11 < 10240 ))
+        {
+          if ( pActors[uActorID].pMonsterInfo.uMovementType == MONSTER_MOVEMENT_TYPE_STAIONARY )
+            Actor::AI_Stand(uActorID, ai_near_actors_targets_pid[uActorID], 32, 0);
+          else
+            Actor::AI_Flee(uActorID, ai_near_actors_targets_pid[uActorID], 32, 0);
+          pTurnEngine->pQueue[queue_position].AI_action_type = TE_AI_FLEE;
+          pTurnEngine->pQueue[queue_position].uActionLength = pActors[uActorID].uCurrentActionLength;
+          return true;
         }
-
-    if ( (double)(signed int)v28 < 307.2 )
-        return 0;
+      }
+    }
+    if ( (double)(signed int)v11 < 307.2 )
+      return 0;
     if ( (signed int)v11 < 5120 )
-        {
-        if ( actor->pMonsterInfo.uMissleAttack1Type && (signed int)v11 < 1024 )
-            Actor::AI_Pursue1(uActorID, a2a, uActorID, 32, &pDir);
-        else
-            Actor::AI_Pursue2(uActorID, a2a, 32, &pDir, 307);
-        v29->AI_action_type = TE_AI_PURSUE;
-        v29->uActionLength = actor->uCurrentActionLength;
-        return 1;
-        }
-        }
-    switch(actor->pMonsterInfo.uMovementType)
-        {
-        case MONSTER_MOVEMENT_TYPE_SHORT: 
-            Actor::AI_RandomMove(uActorID, a2a, 1024, 32);
-            break;
-        case MONSTER_MOVEMENT_TYPE_MEDIUM:
-             Actor::AI_RandomMove(uActorID, a2a, 2560, 32);
-             break;
-         case MONSTER_MOVEMENT_TYPE_LONG:
-             Actor::AI_RandomMove(uActorID, a2a, 5120, 32);
-             break;
-         case MONSTER_MOVEMENT_TYPE_FREE:
-             Actor::AI_RandomMove(uActorID, a2a, 10240, 32);
-             break;
-         case MONSTER_MOVEMENT_TYPE_STAIONARY:
-             Actor::AI_Stand(uActorID, a2a, 32, 0);
-              break;
-         default:
-             return 1;
-        }
-    v29->AI_action_type = TE_AI_PURSUE;
-    v29->uActionLength = actor->uCurrentActionLength;
-    return 1;
+    {
+      if ( pActors[uActorID].pMonsterInfo.uMissleAttack1Type && (signed int)v11 < 1024 )
+        Actor::AI_Pursue1(uActorID, ai_near_actors_targets_pid[uActorID], uActorID, 32, &pDir);
+      else
+        Actor::AI_Pursue2(uActorID, ai_near_actors_targets_pid[uActorID], 32, &pDir, 307);
+      pTurnEngine->pQueue[queue_position].AI_action_type = TE_AI_PURSUE;
+      pTurnEngine->pQueue[queue_position].uActionLength = pActors[uActorID].uCurrentActionLength;
+      return true;
     }
+  }
+  switch(pActors[uActorID].pMonsterInfo.uMovementType)
+  {
+    case MONSTER_MOVEMENT_TYPE_SHORT: 
+      Actor::AI_RandomMove(uActorID, ai_near_actors_targets_pid[uActorID], 1024, 32);
+      break;
+    case MONSTER_MOVEMENT_TYPE_MEDIUM:
+      Actor::AI_RandomMove(uActorID, ai_near_actors_targets_pid[uActorID], 2560, 32);
+      break;
+    case MONSTER_MOVEMENT_TYPE_LONG:
+      Actor::AI_RandomMove(uActorID, ai_near_actors_targets_pid[uActorID], 5120, 32);
+      break;
+    case MONSTER_MOVEMENT_TYPE_FREE:
+      Actor::AI_RandomMove(uActorID, ai_near_actors_targets_pid[uActorID], 10240, 32);
+      break;
+    case MONSTER_MOVEMENT_TYPE_STAIONARY:
+      Actor::AI_Stand(uActorID, ai_near_actors_targets_pid[uActorID], 32, 0);
+      break;
+    default:
+      return true;
+  }
+  pTurnEngine->pQueue[queue_position].AI_action_type = TE_AI_PURSUE;
+  pTurnEngine->pQueue[queue_position].uActionLength = pActors[uActorID].uCurrentActionLength;
+  return true;
+}
 
     //----- (00406FA8) --------------------------------------------------------
 void stru262_TurnBased::ActorAIChooseNewTargets()
+{
+  Actor *curr_acror; // ebx@4
+  AIDirection a3; // [sp+Ch] [bp-6Ch]@8
+  AIDirection v9; // [sp+28h] [bp-50h]@8
+  AIDirection a4; // [sp+44h] [bp-34h]@8
+  unsigned int target_pid; // [sp+60h] [bp-18h]@1
+  int uActorID; // [sp+68h] [bp-10h]@4
+  int i;
+
+  for ( i = 0; i < uActorQueueSize; ++i )
+  {
+    if (PID_TYPE(pQueue[i].uPackedID) == OBJECT_Actor)
     {
-    Actor *curr_acror; // ebx@4
-    AIDirection a3; // [sp+Ch] [bp-6Ch]@8
-    AIDirection v9; // [sp+28h] [bp-50h]@8
-    AIDirection a4; // [sp+44h] [bp-34h]@8
-    unsigned int target_pid; // [sp+60h] [bp-18h]@1
-    int uActorID; // [sp+68h] [bp-10h]@4
-    int i;
-
-    for (i=0; i<uActorQueueSize; ++i )
+      uActorID=PID_ID(pQueue[i].uPackedID);
+      curr_acror = &pActors[uActorID];
+      if ( !( curr_acror->uAIState == AIState::Summoned|| curr_acror->uAIState == AIState::Dead ||
+              curr_acror->uAIState == AIState::Removed || curr_acror->uAIState == AIState::Disabled) )
+      {
+        target_pid = ai_near_actors_targets_pid[uActorID];
+        Actor::_SelectTarget(uActorID, &ai_near_actors_targets_pid[uActorID], true);
+        Actor::GetDirectionInfo(pQueue[i].uPackedID, target_pid, &v9, 0);
+        memcpy(&a4, &v9, sizeof(AIDirection));
+        curr_acror->uCurrentActionTime += pEventTimer->uTimeElapsed;
+        if ( curr_acror->uCurrentActionTime > curr_acror->uCurrentActionLength )
         {
-        if (PID_TYPE(pQueue[i].uPackedID) == OBJECT_Actor)
-            {
-            uActorID=PID_ID(pQueue[i].uPackedID);
-            curr_acror = &pActors[uActorID];
-            if ( !( curr_acror->uAIState == AIState::Summoned|| curr_acror->uAIState == AIState::Dead ||
-                    curr_acror->uAIState == AIState::Removed || curr_acror->uAIState == AIState::Disabled) )
-                { 
-                target_pid = ai_near_actors_targets_pid[uActorID];      
-                Actor::_SelectTarget(uActorID, &ai_near_actors_targets_pid[uActorID], true);  
-                Actor::GetDirectionInfo(pQueue[i].uPackedID, target_pid, &v9, 0);
-                memcpy(&a4, &v9, sizeof(AIDirection));     
-                curr_acror->uCurrentActionTime += pEventTimer->uTimeElapsed;
-                if ( curr_acror->uCurrentActionTime > curr_acror->uCurrentActionLength )
-                    {
-                    if ( curr_acror->uAIState == AIState::Dying )
-                        {
-                        curr_acror->uCurrentActionTime = 0;
-                        curr_acror->uCurrentActionLength = 0;
-                        curr_acror->uAIState = AIState::Dead;
-                        curr_acror->UpdateAnimation();
-                        break;
-                        }
-                    if ( rand() % 2 )
-                        Actor::AI_Stand(uActorID, target_pid, 64, &a4);
-                    else
-                        Actor::AI_Bored(uActorID, target_pid, &a4);
-                    }
-                }
-            }
+          if ( curr_acror->uAIState == AIState::Dying )
+          {
+            curr_acror->uCurrentActionTime = 0;
+            curr_acror->uCurrentActionLength = 0;
+            curr_acror->uAIState = AIState::Dead;
+            curr_acror->UpdateAnimation();
+            break;
+          }
+          if ( rand() % 2 )
+            Actor::AI_Stand(uActorID, target_pid, 64, &a4);
+          else
+            Actor::AI_Bored(uActorID, target_pid, &a4);
         }
+      }
     }
+  }
+}
 
--- a/TurnEngine.h	Sun Feb 23 03:07:46 2014 +0100
+++ b/TurnEngine.h	Mon Feb 24 16:19:01 2014 +0600
@@ -2,23 +2,29 @@
 
 
 enum TURN_ENGINE_FLAGS
-    {
-    TE_FLAG_1 =1,
-    TE_HAVE_PENDING_ACTIONS =2,
-    TE_PLAYER_TURN =4,
-    TE_FLAG_8 =8
-    };
+{
+  TE_FLAG_1               = 1,
+  TE_HAVE_PENDING_ACTIONS = 2,
+  TE_PLAYER_TURN          = 4,
+  TE_FLAG_8               = 8
+};
 
 enum TURN_ENGINE_AI_ACTION
-    {
-    TE_AI_STAND         =0,
-    TE_AI_RANGED_ATTACK =1,
-    TE_AI_PURSUE        =2,
-    TE_AI_MELEE_ATTACK  =3,
-    TE_AI_FLEE          =4
-    };
+{
+  TE_AI_STAND         = 0,
+  TE_AI_RANGED_ATTACK = 1,
+  TE_AI_PURSUE        = 2,
+  TE_AI_MELEE_ATTACK  = 3,
+  TE_AI_FLEE          = 4
+};
 
-
+enum TURN_ENGINE_TURN_STAGE
+{
+  TE_NONE             = 0,
+  TE_WAIT             = 1,
+  TE_ATTACK           = 2,
+  TE_MOVEMENT         = 3,
+};
 
 /*  299 */
 #pragma pack(push, 1)
--- a/UI/UiGame.cpp	Sun Feb 23 03:07:46 2014 +0100
+++ b/UI/UiGame.cpp	Mon Feb 24 16:19:01 2014 +0600
@@ -1771,7 +1771,7 @@
   }
   if ( pParty->bTurnBasedModeOn == 1 )
   {
-    if ( pTurnEngine->turn_stage != 1 )
+    if ( pTurnEngine->turn_stage != TE_WAIT )
     {
       if (PID_TYPE(pTurnEngine->pQueue[0].uPackedID) == OBJECT_Player)
       {
--- a/Viewport.cpp	Sun Feb 23 03:07:46 2014 +0100
+++ b/Viewport.cpp	Mon Feb 24 16:19:01 2014 +0600
@@ -471,7 +471,7 @@
         pMessageQueue_50CBD0->AddMessage(UIMSG_StartNPCDialogue, mon_id, 0);
         return;
       }
-      if ( pParty->bTurnBasedModeOn == 1 && pTurnEngine->turn_stage == 3 )
+      if ( pParty->bTurnBasedModeOn == true && pTurnEngine->turn_stage == TE_MOVEMENT )
       {
         pTurnEngine->field_18 |= TE_FLAG_8;
         return;
@@ -480,7 +480,7 @@
     }
     else
     {
-      if ( pParty->bTurnBasedModeOn == 1 && pTurnEngine->turn_stage == 3 )
+      if ( pParty->bTurnBasedModeOn == true && pTurnEngine->turn_stage == TE_MOVEMENT )
       {
         pParty->uFlags |= PARTY_FLAGS_1_FALLING;
         return;
--- a/mm7_3.cpp	Sun Feb 23 03:07:46 2014 +0100
+++ b/mm7_3.cpp	Mon Feb 24 16:19:01 2014 +0600
@@ -705,7 +705,7 @@
       {
         v8 *= 2;
       }
-      if ( pParty->bTurnBasedModeOn == 1 && pTurnEngine->turn_stage == 1 )
+      if ( pParty->bTurnBasedModeOn == true && pTurnEngine->turn_stage == TE_WAIT )
         v8 *= flt_6BE3AC_debug_recmod1_x_1_6;
       if ( v8 > 1000 )
         v8 = 1000;
@@ -854,7 +854,7 @@
       switch ( PID_TYPE(stru_721530.uFaceID) )
       {
         case OBJECT_Actor:
-          if ( pTurnEngine->turn_stage != 2 && pTurnEngine->turn_stage != 3 || pParty->bTurnBasedModeOn != 1 )
+          if ( pTurnEngine->turn_stage != TE_ATTACK && pTurnEngine->turn_stage != TE_MOVEMENT || pParty->bTurnBasedModeOn != TE_WAIT )
           {
 			//if(pParty->bTurnBasedModeOn == 1)
 				//v34 = 0;
--- a/mm7_6.cpp	Sun Feb 23 03:07:46 2014 +0100
+++ b/mm7_6.cpp	Mon Feb 24 16:19:01 2014 +0600
@@ -638,7 +638,7 @@
   {
     char icon_name[32];
     sprintf(icon_name, "turn%u", i);
-    pIconIDs_Turn[i] = pIconsFrameTable->FindIcon("turn0");
+    pIconIDs_Turn[i] = pIconsFrameTable->FindIcon(icon_name);
     pIconsFrameTable->InitializeAnimation(pIconIDs_Turn[i]);
   }
 
@@ -914,7 +914,7 @@
               pPartyActionQueue->Add(partyAction);
               break;
             }
-            if (pTurnEngine->turn_stage != 1 && pTurnEngine->turn_stage != 2 && pTurnEngine->uActionPointsLeft > 0 )
+            if (pTurnEngine->turn_stage != TE_WAIT && pTurnEngine->turn_stage != TE_ATTACK && pTurnEngine->uActionPointsLeft > 0 )
             {
               pTurnEngine->uActionPointsLeft -= 26;
               if ( pParty->uFlags2 & PARTY_FLAGS_2_RUNNING)
@@ -937,7 +937,7 @@
               pPartyActionQueue->Add(partyAction);
               break;
             }
-            if ( pTurnEngine->turn_stage != 1 && pTurnEngine->turn_stage != 2 && pTurnEngine->uActionPointsLeft > 0 )
+            if ( pTurnEngine->turn_stage != TE_WAIT && pTurnEngine->turn_stage != TE_ATTACK && pTurnEngine->uActionPointsLeft > 0 )
             {
               pTurnEngine->uActionPointsLeft -= 26;
               if ( pParty->uFlags2 & 2 )
@@ -957,7 +957,7 @@
               pPartyActionQueue->Add(partyAction);
               break;
             }
-            if ( pTurnEngine->turn_stage == 1 || pTurnEngine->turn_stage == 2 || pTurnEngine->uActionPointsLeft <= 0 )
+            if ( pTurnEngine->turn_stage == TE_WAIT || pTurnEngine->turn_stage == TE_ATTACK || pTurnEngine->uActionPointsLeft <= 0 )
               break;
             pTurnEngine->uActionPointsLeft -= 26;
             partyAction = PARTY_StrafeLeft;
@@ -972,7 +972,7 @@
               pPartyActionQueue->Add(partyAction);
               break;
             }
-            if ( pTurnEngine->turn_stage == 1 || pTurnEngine->turn_stage == 2 || pTurnEngine->uActionPointsLeft <= 0 )
+            if ( pTurnEngine->turn_stage == TE_WAIT || pTurnEngine->turn_stage == TE_ATTACK || pTurnEngine->uActionPointsLeft <= 0 )
               break;
             pTurnEngine->uActionPointsLeft -= 26;
             partyAction = PARTY_StrafeRight;
@@ -985,7 +985,7 @@
             {
               if (pParty->bTurnBasedModeOn)
               {
-                if ( pTurnEngine->turn_stage == 1 || pTurnEngine->turn_stage == 2 || pTurnEngine->uActionPointsLeft <= 0 )
+                if ( pTurnEngine->turn_stage == TE_WAIT || pTurnEngine->turn_stage == TE_ATTACK || pTurnEngine->uActionPointsLeft <= 0 )
                   break;
                 pTurnEngine->uActionPointsLeft -= 26;
               }
@@ -1009,7 +1009,7 @@
             {
               if (pParty->bTurnBasedModeOn)
               {
-                if ( pTurnEngine->turn_stage == 1 || pTurnEngine->turn_stage == 2 || pTurnEngine->uActionPointsLeft <= 0 )
+                if ( pTurnEngine->turn_stage == TE_WAIT || pTurnEngine->turn_stage == TE_ATTACK || pTurnEngine->uActionPointsLeft <= 0 )
                   break;
                 pTurnEngine->uActionPointsLeft -= 26;
               }
@@ -1042,7 +1042,7 @@
           case INPUT_Pass:
             if ( pCurrentScreen )
               break;
-            if (pParty->bTurnBasedModeOn && pTurnEngine->turn_stage == 3)
+            if (pParty->bTurnBasedModeOn && pTurnEngine->turn_stage == TE_MOVEMENT)
             {
               pTurnEngine->field_18 |= TE_FLAG_8;
               break;
@@ -1063,7 +1063,7 @@
             {
               if (pParty->bTurnBasedModeOn)
               {
-                if (pTurnEngine->turn_stage == 3 || PID_TYPE(pTurnEngine->pQueue[0].uPackedID) == OBJECT_Player)
+                if (pTurnEngine->turn_stage == TE_MOVEMENT || PID_TYPE(pTurnEngine->pQueue[0].uPackedID) == OBJECT_Player)
                 {
                   pParty->bTurnBasedModeOn = 0;
                   pTurnEngine->End(true);
@@ -1079,7 +1079,7 @@
           case INPUT_CastReady:
             if (pCurrentScreen != SCREEN_GAME)
               break;
-            if (pParty->bTurnBasedModeOn && pTurnEngine->turn_stage == 3)
+            if (pParty->bTurnBasedModeOn && pTurnEngine->turn_stage == TE_MOVEMENT)
             {
               pTurnEngine->field_18 |= TE_FLAG_8;
               break;
@@ -1105,7 +1105,7 @@
           case INPUT_Attack:
             if (pCurrentScreen != SCREEN_GAME)
               break;
-            if (pParty->bTurnBasedModeOn == 1 && pTurnEngine->turn_stage == 3)
+            if (pParty->bTurnBasedModeOn == true && pTurnEngine->turn_stage == TE_MOVEMENT)
             {
               pTurnEngine->field_18 |= TE_FLAG_8;
               break;