#include "MM7.h"
#include "mm7_data.h"
#include "Actor.h"
#include "Player.h"
#include "Party.h"
#include "AudioPlayer.h"
#include "SpriteObject.h"
#include "Time.h"
#include "stru298.h"
#include "IconFrameTable.h"
#include "Viewport.h"
#include "FactionTable.h"

#include "TurnEngine.h"


#include "TurnEngine.h"
struct stru262_TurnBased *pTurnEngine = new stru262_TurnBased;


//----- (00404544) --------------------------------------------------------
void stru262_TurnBased::SortTurnQueue()
    {

    int active_actors;
    TurnBased_QueueElem *v7; // eax@16
    TurnBased_QueueElem *v8; // ecx@18
    TurnBased_QueueElem temp_elem;
    int i,j;
    unsigned int p_type;
    unsigned int p_id;

    active_actors = this->uActorQueueSize;

    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 |= 0x80u;
            if ( !pActors[p_id].CanAct() )
                {
                --active_actors;
                pQueue[i].field_4 = 1001;
                pActors[p_id].uAttributes &= ~0x80;
                }
            }
        else if ( p_type == OBJECT_Player)
            {
            if ( !pParty->pPlayers[p_id].CanAct() )
                {
                --active_actors;
                pQueue[i].field_4 = 1001;
                }
            }
        }
     //sort
if (uActorQueueSize>0)
    {

    for( i=0; i<uActorQueueSize-1; ++i) 
        {
       v7=&pQueue[i];
        for(j=i+1; j<uActorQueueSize;++j )
            {  
            v8=&pQueue[j];           
            if ( v8->field_4 < v7->field_4  || 
                   ((v8->field_4 == v7->field_4) && 
                       (
                          ((PID_TYPE(v8->uPackedID) == OBJECT_Player) && (PID_TYPE(v7->uPackedID) == OBJECT_Actor)) || 
                          ((PID_TYPE(v8->uPackedID) == PID_TYPE(v7->uPackedID)) && (PID_ID(v8->uPackedID) < PID_ID(v7->uPackedID)))      
                       ) 
                   )
                )
                {
                memcpy(&temp_elem,v7,sizeof(TurnBased_QueueElem));
                memcpy(v7,v8, sizeof(TurnBased_QueueElem));
                memcpy(v8, &temp_elem, sizeof(TurnBased_QueueElem));
                }
            }
        }
    }
   
    uActorQueueSize = active_actors;

    if ( PID_TYPE(pQueue[0].uPackedID) == OBJECT_Player)
        {
        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)
            pParty->pPlayers[PID_ID(pQueue[i].uPackedID)].uTimeToRecovery = (signed __int64)((double)pQueue[i].field_4 * 0.46875);
        }


    }

//----- (0040471C) --------------------------------------------------------
void stru262_TurnBased::_40471C()
    {
    if ( pParty->bTurnBasedModeOn == 1 )
        {
        if ( pTurnEngine->field_4 == 2 )
            _406457(0);
        }
    }

//----- (004059DB) --------------------------------------------------------
void stru262_TurnBased::Start()
    {
    //stru262_TurnBased *v1; // ebx@1
    int v3; // esi@1
    int v4; // eax@5
    unsigned int actor_id; // esi@7
    Actor *pActor; // edi@7
    unsigned int v7; // eax@9
    unsigned int v8; // edx@10
    //unsigned __int8 v9; // zf@14
    //unsigned __int8 v10; // sf@14
    //unsigned __int8 v11; // of@14
    //char *v12; // esi@15
    //int v13; // ecx@16
    //unsigned __int16 v14; // ax@17
    int v15; // ecx@18
    signed __int64 v16; // qax@19
    int v17; // edx@22
    unsigned int v18; // esi@27
    char *v19; // esi@32
    int v20; // edx@33
    char *v21; // eax@33
    int v22; // ecx@33
    int v23; // eax@34
    char *v24; // eax@34
    char *v25; // ecx@34
    int v26; // edx@34
    int v27; // eax@38
    int v28; // ecx@38
    AIDirection v30; // [sp+Ch] [bp-68h]@10
    AIDirection v31; // [sp+28h] [bp-4Ch]@10
    AIDirection a3; // [sp+44h] [bp-30h]@10
    //int v33; // [sp+60h] [bp-14h]@10
    int *v34; // [sp+64h] [bp-10h]@6
    int v35; // [sp+68h] [bp-Ch]@5
    Player *pPlayer; // [sp+6Ch] [bp-8h]@1
    int v40b;
    unsigned int v37; // [sp+70h] [bp-4h]@7
    int activ_players[4];
    int players_recovery_time[4];
    int a_players_count;
    int i,j;
    int temp;


    pTurnEngine->field_18 &= ~TE_FLAG_2;
    //v1 = this;
    pEventTimer->TrackGameTime();
    pAudioPlayer->StopChannels(-1, -1);
    pAudioPlayer->PlaySound(SOUND_207, 0, 0, -1, 0, 0, 0, 0);
    pPlayer = pParty->pPlayers;
    dword_50C998_turnbased_icon_1A = 8 * pIconsFrameTable->pIcons[uIconID_TurnStart].uAnimLength;
    dword_50C994 = 0;

    this->field_10 = 100;
    this->field_0 = 0;
    this->field_8 = 64;
    this->field_4 = 1;
    this->uActorQueueSize = 0;

    for ( v3 = 0; v3 < 4 ; ++v3 )
        {
        if ( pParty->pPlayers[v3].CanAct() )
            {
            this->pQueue[this->uActorQueueSize].uPackedID = PID(OBJECT_Player,v3);
            this->pQueue[this->uActorQueueSize].field_C = 2;
            this->pQueue[this->uActorQueueSize].uActionLength = 0;
            pParty->pTurnBasedPlayerRecoveryTimes[this->uActorQueueSize] = 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;
                memcpy(&v31, Actor::GetDirectionInfo(PID(OBJECT_Actor,actor_id), v8, &a3, 0), sizeof(AIDirection));
                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].field_C = 2;
                this->pQueue[this->uActorQueueSize].uActionLength = 0;
                ++this->uActorQueueSize;
                }
            }
        }

    a_players_count=0;
    for ( v40b = 0; v40b < this->uActorQueueSize; ++v40b )
        {
        //v13 = PID_TYPE(this->pQueue[0].uPackedID);
        if ( PID_TYPE(this->pQueue[v40b].uPackedID) == OBJECT_Player )
            {
            if ( pPlayers[PID_ID(this->pQueue[v40b].uPackedID) + 1]->uTimeToRecovery != 0 )
                {
                //v33 = pPlayers[(this->pQueue[0].uPackedID >> 3) + 1]->uTimeToRecovery;
                v16 = (signed int)((double)pPlayers[PID_ID(this->pQueue[v40b].uPackedID) + 1]->uTimeToRecovery * 0.46875);
                this->pQueue[v40b].field_4 = v16;
                }
            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].field_4 = 1;
            else 
                this->pQueue[v40b].field_4= (v17 >= 66)? 5 : 3; 
            }
        else 
            {
            this->pQueue[v40b].field_4 = 666;
            }
        this->pQueue[v40b].field_4 += 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]].field_4 = i+2;
            }
        }
    this->SortTurnQueue();
    }



//----- (00405CFF) --------------------------------------------------------
void stru262_TurnBased::End(bool bPlaySound)
    {
   
    ObjectType objType; // eax@13
    int objID; // esi@13
    int i; 

    this->field_4 = 0;

    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<uActorQueueSize; ++i) 
        { 
        objType = (ObjectType)PID_TYPE(pQueue[i].uPackedID);
        objID = PID_ID(pQueue[i].uPackedID);
        if ( objType == OBJECT_Player )
            {
            pPlayers[objID + 1]->uTimeToRecovery = (signed __int64)((double)pQueue[i].field_4 * 2.133333333333333);
            }
        else if ( objType == OBJECT_Actor )
            {
             pActors[objID].pMonsterInfo.uRecoveryTime = (signed __int64)((double)pQueue[i].field_4 * 2.133333333333333);
            }
        }
   
    pAudioPlayer->StopChannels(-1, -1);
    if ( bPlaySound != 0 )
        pAudioPlayer->PlaySound(SOUND_206, 0, 0, -1, 0, 0, 0, 0);
    pTurnEngine->field_18 &= ~TE_FLAG_2;
    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::_405E14()
    {
    stru262_TurnBased *v1; // esi@1
    int v2; // ecx@1
    SpellBuff *v3; // edi@2
    Actor *v4; // ebx@3
    signed int v5; // edx@20
    AIDirection *v6; // esi@21
    int v7; // eax@21
    int v8; // eax@21
    int v9; // eax@22
    int v10; // eax@23
    int v11; // eax@37
    int v12; // eax@44
    AIDirection a3; // [sp+4h] [bp-68h]@21
    AIDirection v14; // [sp+20h] [bp-4Ch]@21
    AIDirection v15; // [sp+3Ch] [bp-30h]@21
    Actor *v16; // [sp+58h] [bp-14h]@2
    int v17; // [sp+5Ch] [bp-10h]@6
    stru262_TurnBased *v18; // [sp+60h] [bp-Ch]@1
    int v19; // [sp+64h] [bp-8h]@8
    unsigned int v20; // [sp+68h] [bp-4h]@1

    v1 = this;
    v2 = 0;
    v18 = v1;
    v20 = 0;
    if ( (signed int)uNumActors > 0 )
        {
        //v3 = pActors;//[0].pActorBuffs;
        v16 = pActors.data();//[0].pActorBuffs;
        v3 = v16->pActorBuffs;
        do
            {
            v4 = v16;
            if ( SHIDWORD(v3[3].uExpireTime) < v2 || SHIDWORD(v3[3].uExpireTime) <= v2 && LODWORD(v3[3].uExpireTime) <= v2 )
                v17 = v2;
            else
                v17 = 1;
            v19 = v2;
            do
                {
                if ( v19 != 10 )
                    {
                    v3->_4585CA(pParty->uTimePlayed);
                    v2 = 0;
                    }
                ++v19;
                ++v3;
                }
                while ( v19 < 22 );
                if ( v17 != 0
                    && SHIDWORD(v4->pActorBuffs[3].uExpireTime) <= 0
                    && (SHIDWORD(v4->pActorBuffs[3].uExpireTime) < 0 || LODWORD(v4->pActorBuffs[3].uExpireTime) <= 0) )
                    v4->uActorHeight = pMonsterList->pMonsters[v4->pMonsterInfo.uID - 1].uMonsterHeight;
                if ( !(v4->uAttributes & 0x80) )
                    {
                    if ( !v4->pActorBuffs[5].uExpireTime )
                        {
                        if ( !v4->pActorBuffs[6].uExpireTime )
                            {
                            v5 = v4->uCurrentActionLength;
                            v4->uCurrentActionTime += pMiscTimer->uTimeElapsed;
                            if ( (signed int)v4->uCurrentActionTime >= v5 )
                                {
                                v17 = ai_near_actors_targets_pid[v20];
                                v6 = Actor::GetDirectionInfo(PID(OBJECT_Actor,v20), v17, &a3, 0);
                                v7 = v4->uAIState;
                                memcpy(&v15, v6, sizeof(v15));
                                v8 = v7 - 4;
                                memcpy(&v14, &v15, sizeof(v14));
                                if ( v8 )
                                    {
                                    v9 = v8 - 1;
                                    if ( v9 )
                                        {
                                        v10 = v9 - 6;
                                        if ( v10 )
                                            {
                                            if ( v10 != 8 )
                                                Actor::AI_StandOrBored(v20, v17, 32, &v14);
                                            }
                                        }
                                    }
                                else
                                    {
                                    v4->uCurrentActionTime = 0;
                                    v4->uCurrentActionLength = 0;
                                    v4->uAIState = Dead;
                                    v4->UpdateAnimation();
                                    }
                                v1 = v18;
                                v2 = 0;
                                }
                            }
                        }
                    }
                ++v20;
                v3 = v16[1].pActorBuffs;
                ++v16;
            }
            while ( (signed int)v20 < (signed int)uNumActors );
        }
    if ( v1->field_4 == 1 )
        {
        v12 = v1->field_8;
        if ( v12 == 64 )
            {
            v1->_406A63();
            }
        else
            {
            if ( v12 > 0 )
                {
                v1->_406B9F();
                }
            else
                {
                v1->_406AFE();
                v1->field_10 = 100;
                }
            }
        v1->field_8 -= pEventTimer->uTimeElapsed;
        return;
        }
    if ( v1->field_4 == 2 )
        {
        if ( !(v1->field_18 & TE_FLAG_1) )
            {
            v11 = v1->field_10;
            if ( v11 == 100 )
                {
                v1->StartTurn();
LABEL_39:
                v1->_40652A();
                return;
                }
            if ( v11 > 0 || v1->pQueue[0].field_4 <= 0 )
                {
                v1->_4065B0();
                goto LABEL_39;
                }
            }
        v1->NextTurn();
        return;
        }
    if ( v1->field_4 == 3 )
        {
        if ( v1->uActionPointsLeft <= 0 || v1->field_18 & TE_FLAG_8 )
            {
            v1->field_18 &= ~TE_FLAG_8;
            v1->field_4 = 1;
            v1->field_8 = 64;
            }
        else
            {
            v1->_406FA8();
            }
        }
    }


//----- (00406051) --------------------------------------------------------
__int16 stru262_TurnBased::StartTurn()
    {
    stru262_TurnBased *v1; // esi@1
    int v2; // ecx@1
    int v3; // ebx@1
    char *v4; // edi@1
    int v5; // eax@4
    int v6; // eax@12
    char *v7; // eax@15
    TurnBased_QueueElem *v8; // edi@17
    unsigned int v9; // edx@23
    char *v10; // eax@26
    int v11; // eax@30
    int v12; // ebx@30
    char *v13; // edi@31
    int v15; // [sp+Ch] [bp-10h]@5
    TurnBased_QueueElem *v16; // [sp+10h] [bp-Ch]@3
    int v17; // [sp+14h] [bp-8h]@2
    int v18; // [sp+14h] [bp-8h]@16
    signed int v19; // [sp+18h] [bp-4h]@1
    int v20; // [sp+18h] [bp-4h]@14

    v1 = this;
    v2 = 0;
    v19 = 0;
    v3 = v1->uActorQueueSize;
    v1->field_1C = 0;
    v4 = (char *)&v1->pQueue[v3].field_4;
    do
        {
        v17 = v2;
        if ( v1->uActorQueueSize <= v2 )
            goto LABEL_11;
        v16 = v1->pQueue;
        while ( 1 )
            {
            v5 = v16->uPackedID;
            if ( PID_TYPE(v16->uPackedID) == OBJECT_Player)
                break;
LABEL_8:
            ++v17;
            ++v16;
            if ( v17 >= v1->uActorQueueSize )
                goto LABEL_11;
            }
        v15 = PID_ID(v5);
        if ( !pPlayers[(PID_ID(v5)) + 1]->CanAct() || v19 != v15 )
            {
            v2 = 0;
            goto LABEL_8;
            }
        v2 = 0;
LABEL_11:
        if ( v17 == v1->uActorQueueSize )
            {
            *(int *)v4 = 100;
            v6 = 8 * v19;
            LOBYTE(v6) = PID(OBJECT_Player,v19);
            *((int *)v4 + 2) = v2;
            *((int *)v4 - 1) = v6;
            *((int *)v4 + 1) = v2;
            ++v3;
            v4 += 16;
            }
        ++v19;
        }
        while ( v19 < 4 );
        v1->uActorQueueSize = v3;
        v20 = v2;
        if ( ai_arrays_size > v2 )
            {
            v7 = (char *)&v1->pQueue[v3].field_4;
            do
                {
                v18 = v2;
                if ( v1->uActorQueueSize > v2 )
                    {
                    v8 = v1->pQueue;
                    do
                        {
                        if ( PID_TYPE(v8->uPackedID) == OBJECT_Actor && ai_near_actors_ids[v20] == PID_ID(v8->uPackedID) )
                            break;
                        ++v18;
                        ++v8;
                        }
                        while ( v18 < v1->uActorQueueSize );
                        v2 = 0;
                    }
                if ( v18 == v1->uActorQueueSize )
                    {
                    v9 = ai_near_actors_ids[v20];
                    *(int *)v7 = 1;
                    *((int *)v7 + 2) = v2;
                    *((int *)v7 - 1) = PID(OBJECT_Actor,v9);
                    *((int *)v7 + 1) = v2;
                    ++v3;
                    v7 += 16;
                    }
                ++v20;
                }
                while ( v20 < ai_arrays_size );
            }
        ++v1->field_0;
        v1->uActorQueueSize = v3;
        v1->field_10 = 100;
        if ( v3 > 0 )
            {
            v10 = (char *)&v1->pQueue[0].field_4;
            do
                {
                if ( *(int *)v10 <= 0 )
                    *(int *)v10 = 100;
                ++v2;
                v10 += 16;
                }
                while ( v2 < v1->uActorQueueSize );
            }
        LOWORD(v11) = v1->_4063A1();
        v12 = 0;
        if ( v1->uActorQueueSize > 0 )
            {
            v13 = (char *)&v1->pQueue[0].field_4;
            do
                {
                v11 = PID_TYPE(*((int *)v13 - 1));
                if ( (char)v11 == 4 )
                    break;
                if ( *(int *)v13 > 0 )
                    break;
                LOWORD(v11) = v1->_40680F(v12++);
                v13 += 16;
                }
                while ( v12 < v1->uActorQueueSize );
            }
        return v11;
    }
// 4F75D8: using guessed type int ai_arrays_size;

//----- (004061CA) --------------------------------------------------------
void stru262_TurnBased::NextTurn()
    {
    stru262_TurnBased *v1; // esi@1
    TurnBased_QueueElem *v2; // ebp@1
    int v3; // ebx@1
    int v4; // edi@7
    Actor *v5; // eax@9
    int v6; // ecx@9
    signed int v7; // ebx@17
    int v8; // ebp@27
    TurnBased_QueueElem *v9; // edi@28
    int v10; // ecx@30
    unsigned __int16 v11; // ax@30
    signed int v12; // edx@35
    signed int v13; // [sp+10h] [bp-4h]@7

    v1 = this;
    SortTurnQueue();
    v2 = v1->pQueue;
    v3 = 0;
    if (PID_TYPE(v1->pQueue[0].uPackedID) == OBJECT_Player)
        uActiveCharacter = PID_ID(v1->pQueue[0].uPackedID) + 1;
    else
        uActiveCharacter = 0;
    viewparams->bRedrawGameUI = 1;
    if ( v1->field_1C )
        {
        pTurnEngine->field_18 |= TE_FLAG_2;
        return;
        }
    pTurnEngine->field_18 &= ~TE_FLAG_2;
    if ( v1->pQueue[0].field_4 <= 0 )
        return;
    v4 = 0;
    v13 = 0;
    if ( v1->uActorQueueSize <= 0 )
        goto LABEL_27;
    do
        {
        if (PID_TYPE(v2->uPackedID) != OBJECT_Player)
            {
            v5 = &pActors[PID_ID(v2->uPackedID)];
            LOWORD(v6) = v5->uAIState;
            if ( (short)v6 == 4
                || (short)v6 == 8
                || (short)v6 == 2
                || (short)v6 == 3
                || (short)v6 == 12
                || (short)v6 == 13
                || (short)v6 == 18
                || (short)v6 == 17 )
                {
                v7 = v5->uCurrentActionLength;
                v5->uCurrentActionTime += pEventTimer->uTimeElapsed;
                if ( (signed int)v5->uCurrentActionTime < v7 )
                    {
                    v13 = 1;
LABEL_19:
                    v3 = 0;
                    goto LABEL_20;
                    }
                v6 = (signed __int16)v6;
                if ( (signed __int16)v6 == 4 )
                    {
                    v3 = 0;
                    v5->uAIState = Dead;
                    v5->uCurrentActionTime = 0;
                    v5->uCurrentActionLength = 0;
                    v5->UpdateAnimation();
                    }
                else
                    {
                    if ( v6 != 8 )
                        goto LABEL_19;
                    v3 = 0;
                    Actor::AI_StandOrBored(PID_ID(v2->uPackedID), ai_near_actors_targets_pid[PID_ID(v2->uPackedID)], 32, 0);
                    }
                }
            }
LABEL_20:
        ++v4;
        ++v2;
        }
   while ( v4 < v1->uActorQueueSize );

        if ( v13 != v3 )
            {
            v1->field_18 |= TE_FLAG_1;
            return;
            }
LABEL_27:
        v1->field_18 &= ~TE_FLAG_1;
        v8 = 0;
        if ( v1->uActorQueueSize > v3 )
            {
            v9 = v1->pQueue;
            do
                {
                if (PID_TYPE(v9->uPackedID) != OBJECT_Player)
                    {
                    v10 = PID_ID(v9->uPackedID);
                    v11 = pActors[v10].uAIState;
                    if ( v11 != 5 )
                        {
                        if ( v11 != 4 && v11 != 11 && v11 != 19 )
                            {
                            if ( v11 != 17 )
                                {
                                v12 = ai_near_actors_targets_pid[v10];
                                v9->uActionLength = v3;
                                Actor::AI_StandOrBored(v10, v12, 32, (AIDirection *)v3);
                                }
                            }
                        }
                    }
                ++v8;
                ++v9;
                }
                while ( v8 < v1->uActorQueueSize );
            }
        v1->field_4 = 3;
        pParty->uTimePlayed += __PAIR__(v3, 213);
        _494035_timed_effects__water_walking_damage__etc();
        v1->uActionPointsLeft = 130;
    }

//----- (004063A1) --------------------------------------------------------
int stru262_TurnBased::_4063A1()
    {
    stru262_TurnBased *v1; // esi@1
    int v2; // ebp@1
    signed int result; // eax@1
    int v4; // edx@1
    int v5; // edx@3
    int v6; // edi@4
    int v7; // ecx@5
    Actor *v8; // ecx@11
    unsigned __int16 v9; // dx@12
    int v10; // edi@16
    int v11; // edx@17
    char v12; // zf@18

    v1 = this;
    SortTurnQueue();
    v2 = (int)&v1->pQueue[0].field_4;
    result = 1;
    viewparams->bRedrawGameUI = 1;
    v4 = v1->pQueue[0].field_4;
    if ( v4 )
        {
        if (PID_TYPE(v1->pQueue[0].uPackedID) == OBJECT_Player)
            {
            v5 = v1->uActorQueueSize;
            while ( 1 )
                {
                v6 = 0;
                if ( v5 > 0 )
                    {
                    v7 = (int)&v1->pQueue[0].field_4;
                    do
                        {
                        --*(int *)v7;
                        v5 = v1->uActorQueueSize;
                        ++v6;
                        v7 += 16;
                        }
                        while ( v6 < v5 );
                    }
                --v1->field_10;
                if ( v1->field_10 <= 0 )
                    break;
                if ( !*(int *)v2 )
                    goto LABEL_9;
                }
LABEL_24:
            result = 1;
            }
        else
            {
            v8 = &pActors[PID_ID(v1->pQueue[0].uPackedID)];
            if ( v4 > 0 )
                {
                do
                    {
                    v9 = v8->uAIState;
                    if ( v9 == 5 )
                        break;
                    if ( v9 == 4 || v9 == 19 || v9 == 11 )
                        break;
                    v10 = 0;
                    if ( v1->uActorQueueSize > 0 )
                        {
                        v11 = (int)&v1->pQueue[0].field_4;
                        do
                            {
                            v12 = (*(int *)v11)-- == 1;
                            if ( v12 )
                                *(int *)(v11 + 4) = 0;
                            ++v10;
                            v11 += 16;
                            }
                            while ( v10 < v1->uActorQueueSize );
                        }
                    --v1->field_10;
                    if ( v1->field_10 <= 0 )
                        goto LABEL_24;
                    }
                    while ( *(int *)v2 > 0 );
                }
LABEL_9:
            result = 0;
            }
        }
    return result;
    }

//----- (00406457) --------------------------------------------------------
int stru262_TurnBased::_406457(int a2)
    {
    stru262_TurnBased *v2; // esi@1
    signed int v3; // eax@1
    signed int v4; // ecx@2
    char *v5; // edx@2
    signed int v6; // eax@2
    int result; // eax@11
    int v8; // edx@13
    int v9; // ecx@14
    char v10; // zf@15

    v2 = this;
    v3 = *(&this->field_0 + 4 * (a2 + 2));
    if ( (*((char *)&this->field_0 + 16 * PID_TYPE(a2 + 2))) == OBJECT_Player)
        {
        v4 = PID_ID(v3);
        v5 = (char *)&pParty->pTurnBasedPlayerRecoveryTimes[PID_ID(v3)];
        v6 = *(int *)v5;
        if ( *(int *)v5 )
            *(int *)v5 = 0;
        else
            v6 = pPlayers[v4 + 1]->GetAttackRecoveryTime(0);
        if ( v6 < 30 )
            v6 = 30;
        }
    else
        {
        v6 = pMonsterStats->pInfos[pActors[PID_ID(v3)].pMonsterInfo.uID].uRecoveryTime;
        }
    v2->pQueue[a2].field_4 = v6;
    v2->SortTurnQueue();
    if (PID_TYPE(v2->pQueue[0].uPackedID) == OBJECT_Player)
        uActiveCharacter = PID_ID(v2->pQueue[0].uPackedID) + 1;
    else
        uActiveCharacter = 0;
    result = (int)&v2->pQueue[0].field_4;
    viewparams->bRedrawGameUI = 1;
    while ( *(int *)result > 0 )
        {
        if ( v2->field_10 <= 0 )
            break;
        v8 = 0;
        if ( v2->uActorQueueSize > 0 )
            {
            v9 = (int)&v2->pQueue[0].field_4;
            do
                {
                v10 = (*(int *)v9)-- == 1;
                if ( v10 )
                    *(int *)(v9 + 4) = 0;
                ++v8;
                v9 += 16;
                }
                while ( v8 < v2->uActorQueueSize );
            }
        --v2->field_10;
        if ( v2->field_10 <= 0 )
            break;
        }
    return result;
    }

//----- (0040652A) --------------------------------------------------------
void stru262_TurnBased::_40652A()
    {
    int *v1; // edx@2
    Actor *v2; // eax@5
    unsigned __int16 v3; // si@5
    unsigned int v4; // esi@8
    int v5; // [sp+Ch] [bp-4h]@1

    v5 = 0;
    if ( this->uActorQueueSize > 0 )
        {
        v1 = &this->pQueue[0].field_4;
        do
            {
            if ( !*(int *)v1 )
                {
                if ( PID_TYPE(*(v1 - 4)) == OBJECT_Player)
                    return;
                v2 = &pActors[PID_ID(*(v1 - 1))];
                v3 = v2->uAIState;
                if (v3 == Standing || v3 == Fleeing || v3 == Fidgeting)
                    {
                    v4 = pMonsterStats->pInfos[v2->pMonsterInfo.uID].uRecoveryTime;
                    *(int *)v1 = v4;
                    if ( (signed __int64)v2->pActorBuffs[7].uExpireTime > 0 )
                        *(int *)v1 = 2 * v4;
                    }
                }
            ++v5;
            v1 += 16;
            }
            while ( v5 < this->uActorQueueSize );
        }
    }

//----- (004065B0) --------------------------------------------------------
void stru262_TurnBased::_4065B0()
    {
    stru262_TurnBased *v1; // esi@1
    signed int v2; // eax@1
    int v3; // ebx@6
    int v4; // edi@7
    unsigned int v5; // edi@14

    v1 = this;
    SortTurnQueue();
    if ( v1->pQueue[0].field_4 <= 0
        || ((_4063A1(), v2 = v1->pQueue[0].uPackedID, PID_TYPE(v1->pQueue[0].uPackedID) != OBJECT_Player) ? 
        (uActiveCharacter = 0) : (v2 = (PID_ID(v2)) + 1, uActiveCharacter = v2),
        viewparams->bRedrawGameUI = 1,
        v1->pQueue[0].field_4 <= 0) )
        {
        v3 = 0;
        if ( v1->uActorQueueSize > 0 )
            {
            v4 = (int)v1->pQueue;
            do
                {
                v2 = *(int *)v4;
                if ( PID_TYPE(*(char *)v4) == OBJECT_Player || *(int *)(v4 + 4) > 0 )
                    break;
                if ( *(int *)(v4 + 8) <= 0 )
                    {
                    LOWORD(v2) = v2 & 3;
                    if ( (char)v2 == 3 )
                        LOWORD(v2) = v1->_40680F(v3);
                    }
                ++v3;
                v4 += 16;
                }
                while ( v3 < v1->uActorQueueSize );
            }
        }
    v5 = 0;
    if ( v1->uActorQueueSize > 0 )
        {
        do
        v1->_406648(v5++);
        while ( (signed int)v5 < v1->uActorQueueSize );
        }
    }

//----- (00406648) --------------------------------------------------------
void stru262_TurnBased::_406648(unsigned int a2)
    {
    TurnBased_QueueElem *v1; // ecx@1
    int v3; // eax@1
    unsigned int v4; // ebx@2
    Actor *v5; // esi@2
    signed int v6; // edi@5
    int v7; // ecx@6
    int v8; // eax@6
    int v9; // eax@7
    int v10; // eax@8
    int v11; // eax@9
    int v12; // eax@10
    int v13; // eax@11
    int v14; // eax@14
    unsigned int v15; // ecx@14
    unsigned int v16; // edx@14
    int v17; // eax@17
    int v18; // eax@20
    char v19; // al@24
    unsigned int v21; // [sp-8h] [bp-50h]@16
    int v22; // [sp-8h] [bp-50h]@17
    AIDirection *v23; // [sp-4h] [bp-4Ch]@14
    unsigned int v24; // [sp-4h] [bp-4Ch]@17
    char v25; // [sp-4h] [bp-4Ch]@20
    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 = (TurnBased_QueueElem *)((char *)this + 16 * (a2 + 2));
    v28 = v1;
    v3 = v1->uPackedID;
    if (PID_TYPE(v1->uPackedID) != OBJECT_Player)
        {
        v4 = PID_ID(v3);
        a2a = ai_near_actors_targets_pid[PID_ID(v3)];
        memcpy(&a3, Actor::GetDirectionInfo(v1->uPackedID, ai_near_actors_targets_pid[PID_ID(v3)], &a3, 0), sizeof(a3));
        memcpy(&a4, &a3, sizeof(a4));
        v5 = &pActors[PID_ID(v3)];
        LOWORD(v3) = v5->uAIState;
        if ( (short)v3 != Dead )
            {
            if ( (short)v3 != Disabled )
                {
                if ( (short)v3 != Removed )
                    {
                    v6 = v5->uCurrentActionLength;
                    v5->uCurrentActionTime += pEventTimer->uTimeElapsed;
                    if ( (signed int)v5->uCurrentActionTime >= v6 )
                        {
                        v7 = (signed __int16)v3;
                        v8 = (signed __int16)v3 - 2;
                        if ( !v8 )
                            {
                            v19 = stru_50C198.special_ability_use_check(&pActors[v4], v4);
                            stru_50FE08.Add(
                                v28->uPackedID,
                                5120,
                                v5->vPosition.x,
                                v5->vPosition.y,
                                v5->vPosition.z + ((signed int)v5->uActorHeight >> 1),
                                v19,
                                1);
                            goto LABEL_25;
                            }
                        v9 = v8 - 1;
                        if ( v9 )
                            {
                            v10 = v9 - 1;
                            if ( !v10 )
                                goto LABEL_21;
                            v11 = v10 - 4;
                            if ( !v11 )
                                goto LABEL_25;
                            v12 = v11 - 4;
                            if ( v12 )
                                {
                                v13 = v12 - 1;
                                if ( v13 )
                                    {
                                    if ( v13 != Dead )
                                        {
                                        if ( v7 != 4 )
                                            {
                                            v14 = rand();
                                            v15 = v4;
                                            v23 = &a4;
                                            v16 = a2a;
                                            if ( !(v14 % 2) )
                                                {
                                                Actor::AI_Bored(v4, a2a, &a4);
                                                return;
                                                }
                                            v21 = 64;
LABEL_26:
                                            Actor::AI_Stand(v15, v16, v21, v23);
                                            return;
                                            }
LABEL_21:
                                        v5->uCurrentActionTime = 0;
                                        v5->uCurrentActionLength = 0;
                                        v5->uAIState = Dead;
                                        pActors[v4].UpdateAnimation();
                                        return;
                                        }
                                    v24 = v5->pMonsterInfo.uSpellSkillAndMastery2;
                                    v22 = 3;
                                    v17 = v5->pMonsterInfo.uSpell2ID;
                                    }
                                else
                                    {
                                    v24 = v5->pMonsterInfo.uSpellSkillAndMastery1;
                                    v22 = 2;
                                    v17 = v5->pMonsterInfo.uSpell1ID;
                                    }
                                Actor::AI_SpellAttack(v4, &a4, v17, v22, v24);
LABEL_25:
                                v16 = a2a;
                                v23 = &a4;
                                v21 = 0;
                                v15 = v4;
                                goto LABEL_26;
                                }
                            v18 = v5->pMonsterInfo.uMissleAttack2Type;
                            v25 = 1;
                            }
                        else
                            {
                            v18 = v5->pMonsterInfo.uMissleAttack1Type;
                            v25 = 0;
                            }
                        Actor::AI_RangedAttack(v4, &a4, v18, v25);
                        goto LABEL_25;
                        }
                    }
                }
            }
        }
    }
// 50FE08: using guessed type stru298 stru_50FE08;

//----- (0040680F) --------------------------------------------------------
__int16 stru262_TurnBased::_40680F(int a2)
    {
    TurnBased_QueueElem *v2; // eax@1
    unsigned int v3; // eax@1
    unsigned int v4; // edi@2
    Actor *v5; // ebx@2
    unsigned int *v6; // esi@7
    AIDirection *v7; // esi@10
    int v8; // eax@10
    unsigned int v9; // ecx@10
    signed int v10; // eax@13
    unsigned __int8 v11; // sf@19
    unsigned __int8 v12; // of@19
    int v13; // esi@29
    bool v14; // eax@29
    unsigned __int8 v15; // cl@33
    AIDirection a3; // [sp+Ch] [bp-44h]@10
    AIDirection v18; // [sp+28h] [bp-28h]@10
    int a2a; // [sp+44h] [bp-Ch]@2
    unsigned int v20; // [sp+48h] [bp-8h]@10
    TurnBased_QueueElem *v21; // [sp+4Ch] [bp-4h]@1
    signed int v22; // [sp+58h] [bp+8h]@10

    v2 = (TurnBased_QueueElem *)((char *)this + 16 * (a2 + 2));
    v21 = v2;
    v2->uActionLength = 0;
    v3 = v2->uPackedID;
    if ( (unsigned __int8)v3 & 3 )
        {
        v3 = PID_ID(v3);
        v4 = v3;
        a2a = v3;
        v5 = &pActors[v3];
        LOWORD(v3) = v5->uAIState;
        if ( (short)v3 != 5 )
            {
            if ( (short)v3 != 4 && (short)v3 != 11 && (short)v3 != 19 && (short)v3 != 17 )
                {
                v6 = (unsigned int *)&ai_near_actors_targets_pid[(int)v4];
                Actor::_SelectTarget((unsigned int)v4, &ai_near_actors_targets_pid[(int)v4], true);
                if ( v5->pMonsterInfo.uHostilityType && !*v6 )
                    v5->pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Friendly;
                v22 = *v6;
                v7 = Actor::GetDirectionInfo(PID(OBJECT_Actor,(int)v4), *v6, &a3, 0);
                v8 = v5->uActorRadius;
                memcpy(&a3, v7, sizeof(a3));
                memcpy(&v18, &a3, sizeof(v18));
                v9 = a3.uDistance - v8;
                v20 = a3.uDistance - v8;
                if ( ((a3.uDistance - v8) & 0x80000000u) != 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;
                if ( v10 == 1 )
                    {
                    if ( (double)(signed int)v20 < 307.2 )
                        goto LABEL_25;
                    }
                else
                    {
                    if ( v10 == 2 )
                        {
                        v12 = __OFSUB__(v9, 1024);
                        v11 = ((v9 - 1024) & 0x80000000u) != 0;
                        }
                    else
                        {
                        if ( v10 == 3 )
                            {
                            v12 = __OFSUB__(v9, 2560);
                            v11 = ((v9 - 2560) & 0x80000000u) != 0;
                            }
                        else
                            {
                            if ( v10 != 4 )
                                goto LABEL_26;
                            v12 = __OFSUB__(v9, 5120);
                            v11 = ((v9 - 5120) & 0x80000000u) != 0;
                            }
                        }
                    if ( v11 ^ v12 )
                        {
LABEL_25:
                        v5->pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Long;
                        goto LABEL_26;
                        }
                    }
LABEL_26:
                if ( v5->pMonsterInfo.uHostilityType != 4 || !v22 || (signed int)v9 >= 5120 )
                    {
                    v13 = a2a;
                    goto LABEL_47;
                    }
                v13 = a2a;
                v14 = stru_50C198.special_ability_use_check(v5, a2a);
                if ( v14 == 1 )
                    {
                    if ( v5->pMonsterInfo.uMissleAttack2Type )
                        {
                        Actor::AI_MissileAttack2(v13, v22, &v18);
                        goto LABEL_43;
                        }
                    }
                else
                    {
                    if ( v14 > 1 && v14 <= 3 )
                        {
                        if ( v14 == 2 )
                            v15 = v5->pMonsterInfo.uSpell1ID;
                        else
                            v15 = v5->pMonsterInfo.uSpell2ID;
                        if ( v15 )
                            {
                            if ( v14 == 2 )
                                Actor::AI_SpellAttack1(v13, v22, &v18);
                            else
                                Actor::AI_SpellAttack2(v13, v22, &v18);
                            goto LABEL_43;
                            }
                        goto LABEL_44;
                        }
                    if ( v5->pMonsterInfo.uMissleAttack1Type )
                        {
                        Actor::AI_MissileAttack1(v13, v22, &v18);
LABEL_43:
                        //v3 = v21;
                        v21->field_C = 1;
LABEL_48:
                        v21->uActionLength = v5->uCurrentActionLength;
                        //return (signed __int16)v3;
                        return (signed __int16)&v21;
                        }
                    }
LABEL_44:
                if ( (double)(signed int)v20 < 307.2 )
                    {
                    Actor::AI_MeleeAttack(v13, v22, &v18);
                    //v3 = v21;
                    v21->field_C = 3;
                    goto LABEL_48;
                    }
LABEL_47:
                Actor::AI_Stand(v13, v22, 0x40u, &v18);
                //v3 = v21;
                v21->field_C = 0;
                goto LABEL_48;
                }
            }
        }
    return (signed __int16)v3;
    }

//----- (00406A63) --------------------------------------------------------
void stru262_TurnBased::_406A63()
    {
    stru262_TurnBased *v1; // ebx@1
    int v2; // esi@1
    unsigned __int8 v3; // zf@1
    unsigned __int8 v4; // sf@1
    signed int v5; // ecx@4
    AIDirection a3; // [sp+8h] [bp-44h]@5
    AIDirection v7; // [sp+24h] [bp-28h]@5
    unsigned int v8; // [sp+40h] [bp-Ch]@5
    signed int a2; // [sp+44h] [bp-8h]@1
    TurnBased_QueueElem *v10; // [sp+48h] [bp-4h]@2

    v1 = this;
    v2 = 0;
    this->field_8 = 64;
    dword_50C994 = 0;
    uActiveCharacter = 0;
    v3 = this->uActorQueueSize == 0;
    v4 = this->uActorQueueSize < 0;
    a2 = 0;
    if ( !(v4 | v3) )
        {
        v10 = this->pQueue;
        while ( 1 )
            {
            v5 = v10->uPackedID;
            if (PID_TYPE(v10->uPackedID) == OBJECT_Actor)
                {
                v8 = ai_near_actors_targets_pid[PID_ID(v5)];
                memcpy(&v7, Actor::GetDirectionInfo(v5, v8, &a3, v2), sizeof(v7));
                if ( !v1->ActorTurn(a2) )
                    Actor::AI_Stand(PID_ID(v10->uPackedID), v8, 32, &v7);
                }
            ++a2;
            ++v10;
            if ( a2 >= v1->uActorQueueSize )
                break;
            v2 = 0;
            }
        }
    }
// 50C994: using guessed type int dword_50C994;

//----- (00406AFE) --------------------------------------------------------
void stru262_TurnBased::_406AFE()
    {
    stru262_TurnBased *v1; // edi@1
    TurnBased_QueueElem *v2; // ebx@2
    int v3; // esi@4
    int v4; // ecx@5
    AIDirection a3; // [sp+4h] [bp-48h]@5
    AIDirection v6; // [sp+20h] [bp-2Ch]@5
    stru262_TurnBased *v7; // [sp+3Ch] [bp-10h]@1
    unsigned int v8; // [sp+40h] [bp-Ch]@4
    unsigned int v9; // [sp+44h] [bp-8h]@5
    int v10; // [sp+48h] [bp-4h]@1

    v10 = 0;
    v1 = this;
    v7 = this;
    if ( this->uActorQueueSize > 0 )
        {
        v2 = this->pQueue;
        do
            {
            if (PID_TYPE(v2->uPackedID) == OBJECT_Actor)
                {
                v3 = PID_ID(v2->uPackedID);
                v8 = v3;
                if ( pActors[v3].CanAct() )
                    {
                    v4 = v2->uPackedID;
                    v9 = ai_near_actors_targets_pid[v3];
                    memcpy(&v6, Actor::GetDirectionInfo(v4, v9, &a3, 0), sizeof(v6));
                    Actor::AI_Stand(v8, v9, 32, &v6);
                    v2->field_C = 0;
                    v2->uActionLength = 0;
                    v1 = v7;
                    }
                }
            ++v10;
            ++v2;
            }
            while ( v10 < v1->uActorQueueSize );
        }
    v1->field_4 = 2;
    v1->field_8 = 100;
    }

//----- (00406B9F) --------------------------------------------------------
int stru262_TurnBased::_406B9F()
    {
    signed int result; // eax@1
    unsigned __int8 v2; // zf@1
    unsigned __int8 v3; // sf@1
    int v4; // esi@4
    unsigned int v5; // esi@5
    Actor *v6; // ebx@5
    unsigned __int16 v7; // cx@15
    AIDirection a3; // [sp+0h] [bp-50h]@15
    AIDirection v9; // [sp+1Ch] [bp-34h]@15
    signed int a1; // [sp+38h] [bp-18h]@4
    stru262_TurnBased *thisa; // [sp+3Ch] [bp-14h]@1
    unsigned int v12; // [sp+40h] [bp-10h]@5
    unsigned int v13; // [sp+44h] [bp-Ch]@8
    TurnBased_QueueElem *v14; // [sp+48h] [bp-8h]@2
    signed int a2; // [sp+4Ch] [bp-4h]@1

    result = 0;
    thisa = this;
    v2 = this->uActorQueueSize == 0;
    v3 = this->uActorQueueSize < 0;
    a2 = 0;
    if ( !(v3 | v2) )
        {
        v14 = this->pQueue;
        while ( 1 )
            {
            v4 = v14->uPackedID;
            a1 = v14->uPackedID;
            if (PID_TYPE(a1) != OBJECT_Player)
                {
                v5 = PID_ID(v4);
                v12 = v5;
                v6 = &pActors[v5];
                if ( SHIDWORD(v6->pActorBuffs[5].uExpireTime) < result
                    || SHIDWORD(v6->pActorBuffs[5].uExpireTime) <= result && LODWORD(v6->pActorBuffs[5].uExpireTime) <= result )
                    v13 = result;
                else
                    v13 = 1;
                if ( SHIDWORD(v6->pActorBuffs[6].uExpireTime) >= result
                    && (SHIDWORD(v6->pActorBuffs[6].uExpireTime) > result || LODWORD(v6->pActorBuffs[6].uExpireTime) > result) )
                    result = 1;
                if ( !(v13 != 0 || result || v6->uAIState == 5 || v6->uAIState == 11 || v6->uAIState == 19) )
                    {
                    v13 = ai_near_actors_targets_pid[v5];
                    memcpy(&v9, Actor::GetDirectionInfo(a1, v13, &a3, 0), sizeof(v9));
                    v7 = v6->uAIState;
                    if ( v7 == 6 || v7 == 1 )
                        {
                        if ( (double)(signed int)v9.uDistance < 307.2 )
                            goto LABEL_26;
                        }
                    v6->uCurrentActionTime += pEventTimer->uTimeElapsed;
                    if ( (signed int)v6->uCurrentActionTime > v6->uCurrentActionLength )
                        {
                        if ( v7 == 4 )
                            {
                            v6->uCurrentActionTime = 0;
                            v6->uCurrentActionLength = 0;
                            v6->uAIState = Dead;
                            v6->UpdateAnimation();
                            }
                        if ( !thisa->ActorTurn(a2) )
LABEL_26:
                        Actor::AI_Stand(v12, v13, 32, &v9);
                        }
                    }
                }
            ++a2;
            result = (signed int)thisa;
            ++v14;
            if ( a2 >= thisa->uActorQueueSize )
                break;
            result = 0;
            }
        }
    return result;
    }

//----- (00406D10) --------------------------------------------------------
bool stru262_TurnBased::ActorTurn(signed int a2)
    {
    int v2; // ecx@1
    //int v3; // ecx@2
    Actor *actor; // ebx@2
    //unsigned __int16 v5; // dx@2
    int *v6; // esi@7
    TurnBased_QueueElem *v7; // edi@7
    int v8; // eax@7
    AIDirection *v9; // esi@10
    int v10; // eax@10
    unsigned int v11; // ecx@10
    unsigned __int8 pHostileType; // al@12
    unsigned __int8 v13; // sf@16
    unsigned __int8 v14; // of@16
    unsigned int v15; // edx@22
    unsigned int v16; // ecx@23
    TurnBased_QueueElem *v17; // eax@25
    double v18; // st7@33
    double v19; // st6@33
    int v21; // [sp-8h] [bp-5Ch]@23
    int v22; // [sp-8h] [bp-5Ch]@26
    AIDirection *v23; // [sp-4h] [bp-58h]@23
    int v24; // [sp-4h] [bp-58h]@26
    AIDirection a3; // [sp+Ch] [bp-48h]@10
    AIDirection pDir; // [sp+28h] [bp-2Ch]@10
    int v27; // [sp+44h] [bp-10h]@33
    unsigned 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 = *(&this->field_0 + 4 * (a2 + 2));
    if (PID_TYPE(v2) == OBJECT_Player)
        return 0;
    uActorID = PID_ID(v2);
    //uActorID = v3;
    actor = &pActors[uActorID];
    //v5 = v4->uAIState;
    if ( actor->uAIState == 5 || actor->uAIState == 4 || actor->uAIState == 11 || actor->uAIState == 19 || actor->uAIState == 17 )
        return 1;
    v6 = &ai_near_actors_targets_pid[uActorID];
    v7 = &pTurnEngine->pQueue[a2];
    v8 = *v6;
    v29 = &pTurnEngine->pQueue[a2];
    a2a = v8;
    Actor::_SelectTarget(uActorID, &ai_near_actors_targets_pid[uActorID], true);
    if ( actor->pMonsterInfo.uHostilityType && !*v6 )
        actor->pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Friendly;
    v9 = Actor::GetDirectionInfo(v7->uPackedID, a2a, &a3, 0);
    v10 = actor->uActorRadius;
    memcpy(&a3, v9, sizeof(a3));
    memcpy(&pDir, &a3, sizeof(pDir));
    v11 = a3.uDistance - v10;
    v28 = a3.uDistance - v10;
    if ( ((a3.uDistance - v10) & 0x80000000u) != 0 )
        {
        v11 = 0;
        v28 = 0;
        }
    pHostileType = actor->pMonsterInfo.uHostilityType;
    if ( pHostileType == 1 )
        {
        if ( (double)(signed int)v28 >= 307.2 )
            goto LABEL_21;
        actor->pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Long;
        goto LABEL_21;
        }
    if ( pHostileType == 2 )
        {
        v14 = __OFSUB__(v11, 1024);
        v13 = ((v11 - 1024) & 0x80000000u) != 0;
        }
    else
        {
        if ( pHostileType != 3 )
            goto LABEL_21;
        v14 = __OFSUB__(v11, 2560);
        v13 = ((v11 - 2560) & 0x80000000u) != 0;
        }
    if ( v13 ^ v14 )
        {
        actor->pMonsterInfo.uHostilityType = MonsterInfo::Hostility_Long;
        }
LABEL_21:
    if ( (signed __int64)actor->pActorBuffs[4].uExpireTime > 0 )
        {
        if ( (signed int)v11 < 10240 )
            {
            Actor::AI_Flee(uActorID, a2a, 0, &pDir);
            v29->field_C = 4;
            v29->uActionLength = actor->uCurrentActionLength;
            return 1;
            }
        Actor::AI_4032B2(uActorID, a2a, 1024, 0);
        v29->field_C = 2;
        v29->uActionLength = actor->uCurrentActionLength;
        return 1;
        }
    if ( actor->pMonsterInfo.uHostilityType != 4 )
        goto LABEL_46;
    if ( !(actor->uAttributes & 0x020000) || actor->pMonsterInfo.uAIType == 1 )
        {
        if ( actor->pMonsterInfo.uAIType == 1 )
            {
            if ( actor->pMonsterInfo.uMovementType == 5 )
                {
                Actor::AI_Stand(uActorID, a2a, 32, 0);
                v29->field_C = 4;
                v29->uActionLength = actor->uCurrentActionLength;
                return 1;
                }
            Actor::AI_Flee(uActorID, a2a, 32, 0);
            v29->field_C = 4;
            v29->uActionLength = actor->uCurrentActionLength;
            return 1;
            }
        if ( actor->pMonsterInfo.uAIType == 2 )
            {
            v27 = actor->sCurrentHP;
            v18 = (double)v27;
            v19 = (double)(signed int)actor->pMonsterInfo.uHP * 0.2;
            if ( v19 > v18 && (signed int)v11 < 10240 )
                {
                if ( actor->pMonsterInfo.uMovementType == 5 )
                    {
                    Actor::AI_Stand(uActorID, a2a, 32, 0);
                    v29->field_C = 4;
                    v29->uActionLength = actor->uCurrentActionLength;
                    return 1;
                    }
                Actor::AI_Flee(uActorID, a2a, 32, 0);
                v29->field_C = 4;
                v29->uActionLength = actor->uCurrentActionLength;
                return 1;
                }
            goto LABEL_39;
            }
        if ( actor->pMonsterInfo.uAIType == 3 )
            {
            v27 = actor->sCurrentHP;
            v18 = (double)v27;
            v19 = (double)(signed int)actor->pMonsterInfo.uHP * 0.1;
            if ( v19 > v18 && (signed int)v11 < 10240 )
                {
                if ( actor->pMonsterInfo.uMovementType == 5 )
                    {
                    Actor::AI_Stand(uActorID, a2a, 32, 0);
                    v29->field_C = 4;
                    v29->uActionLength = actor->uCurrentActionLength;
                    return 1;
                    }
                Actor::AI_Flee(uActorID, a2a, 32, 0);
                v29->field_C = 4;
                v29->uActionLength = actor->uCurrentActionLength;
                return 1;
                }
            goto LABEL_39;
            }
        }
LABEL_39:
    if ( (double)(signed int)v28 < 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->field_C = 2;
        v29->uActionLength = actor->uCurrentActionLength;
        return 1;
        }
LABEL_46:
    if ( actor->pMonsterInfo.uMovementType == 0 )
        {
        Actor::AI_4032B2(uActorID, a2a, 1024, 32);
        v29->field_C = 2;
        v29->uActionLength = actor->uCurrentActionLength;
        return 1;
        }
    if ( actor->pMonsterInfo.uMovementType == 1 )
        {
        Actor::AI_4032B2(uActorID, a2a, 2560, 32);
        v29->field_C = 2;
        v29->uActionLength = actor->uCurrentActionLength;
        return 1;
        }
    if ( actor->pMonsterInfo.uMovementType == 2 )
        {
        Actor::AI_4032B2(uActorID, a2a, 5120, 32);
        v29->field_C = 2;
        v29->uActionLength = actor->uCurrentActionLength;
        return 1;
        }
    if ( actor->pMonsterInfo.uMovementType == 4 )
        {
        Actor::AI_4032B2(uActorID, a2a, 10240, 32);
        v29->field_C = 2;
        v29->uActionLength = actor->uCurrentActionLength;
        return 1;
        }
    if ( actor->pMonsterInfo.uMovementType == 5 )
        {
        Actor::AI_Stand(uActorID, a2a, 32, 0);
        v29->field_C = 2;
        v29->uActionLength = actor->uCurrentActionLength;
        return 1;
        }
    return 1;
    }

//----- (00406FA8) --------------------------------------------------------
void stru262_TurnBased::_406FA8()
    {
    unsigned __int8 v1; // zf@1
    unsigned __int8 v2; // sf@1
    TurnBased_QueueElem *v3; // edi@2
    int v4; // eax@4
    Actor *v5; // ebx@4
    unsigned __int16 v6; // cx@4
    unsigned int *v7; // edx@8
    unsigned int v8; // esi@8
    unsigned __int8 v9; // of@13
    AIDirection a3; // [sp+Ch] [bp-6Ch]@8
    AIDirection v11; // [sp+28h] [bp-50h]@8
    AIDirection a4; // [sp+44h] [bp-34h]@8
    stru262_TurnBased *v13; // [sp+60h] [bp-18h]@1
    TurnBased_QueueElem *v14; // [sp+64h] [bp-14h]@2
    int uActorID; // [sp+68h] [bp-10h]@4
    unsigned int a2; // [sp+6Ch] [bp-Ch]@8
    int v17; // [sp+70h] [bp-8h]@1
    unsigned int v18; // [sp+74h] [bp-4h]@2

    v17 = 0;
    v1 = this->uActorQueueSize == 0;
    v2 = this->uActorQueueSize < 0;
    v13 = this;
    if ( !(v2 | v1) )
        {
        v3 = this->pQueue;
        v18 = (char *)&pTurnEngine - (char *)this;
        v14 = this->pQueue;
        do
            {
            if (PID_TYPE(v3->uPackedID) != OBJECT_Player)
                {
                v4 = PID_ID(v3->uPackedID);
                uActorID = v4;
                v5 = &pActors[v4];
                v6 = v5->uAIState;
                if ( v6 != 5 )
                    {
                    if ( v6 != 11 )
                        {
                        if ( v6 != 19 )
                            {
                            if ( v6 != 17 )
                                {
                                v7 = (unsigned int *)&ai_near_actors_targets_pid[v4];
                                a2 = *v7;
                                v8 = a2;
                                Actor::_SelectTarget(v4, (int *)v7, true);
                                memcpy(&v11, Actor::GetDirectionInfo(*(int *)((char *)&v3->uPackedID + v18), v8, &a3, 0), sizeof(v11));
                                memcpy(&a4, &v11, sizeof(a4));
                                v5->uCurrentActionTime += pMiscTimer->uTimeElapsed;
                                if ( (signed int)v5->uCurrentActionTime >= v5->uCurrentActionLength )
                                    {
                                    if (v5->uAIState == Dying)
                                        {
                                        v5->uCurrentActionTime = 0;
                                        v5->uCurrentActionLength = 0;
                                        v5->uAIState = Dead;
                                        v5->UpdateAnimation();
                                        return;
                                        }
                                    if ( rand() % 2 )
                                        Actor::AI_Stand(uActorID, a2, 64, &a4);
                                    else
                                        Actor::AI_Bored(uActorID, a2, &a4);
                                    }
                                }
                            }
                        }
                    }
                }
            ++v17;
            v3 = v14 + 1;
            v9 = __OFSUB__(v17, v13->uActorQueueSize);
            v2 = v17 - v13->uActorQueueSize < 0;
            ++v14;
            }
            while ( v2 ^ v9 );
        }
    }