Структура stru262_TurnBased

#include <TurnEngine.h>

Граф связей класса stru262_TurnBased:

Открытые члены
	stru262_TurnBased ()
void	SortTurnQueue ()
void	ApplyPlayerAction ()
void	Start ()
void	End (bool bPlaySound)
void	AITurnBasedAction ()
void	StartTurn ()
void	NextTurn ()
bool	StepTurnQueue ()
void	_406457 (int a2)
void	SetAIRecoveryTimes ()
void	_4065B0 ()
void	AIAttacks (unsigned int queue_index)
void	AI_Action_ (int queue_index)
void	ActorAISetMovementDecision ()
void	ActorAIStopMovement ()
void	ActorAIDoAdditionalMove ()
bool	ActorMove (signed int a2)
void	ActorAIChooseNewTargets ()

Открытые атрибуты
int	turns_count
int	turn_stage
int	ai_turn_timer
int	uActorQueueSize
int	turn_initiative
int	uActionPointsLeft
int	field_18
int	pending_actions
TurnBased_QueueElem	pQueue [530]

Подробное описание

См. определение в файле TurnEngine.h строка 43

Конструктор(ы)

stru262_TurnBased()

stru262_TurnBased::stru262_TurnBased ( )

inline

См. определение в файле TurnEngine.h строка 44

                               {
        turns_count = 0;
        turn_stage = 0;
        ai_turn_timer = 0;
        uActorQueueSize = 0;
        turn_initiative = 0;
        uActionPointsLeft = 0;
        field_18 = 0;
        pending_actions = 0;
    }

Перекрестные ссылки ai_turn_timer, field_18, pending_actions, turn_initiative, turn_stage, turns_count, uActionPointsLeft и uActorQueueSize.

Методы

SortTurnQueue()

void stru262_TurnBased::SortTurnQueue

(

)

См. определение в файле TurnEngine.cpp строка 24

                                      {
    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);
 
        if (p_type == OBJECT_Actor) {
            pActors[p_id].uAttributes |= ACTOR_STAND_IN_QUEUE;  // 0x80
            if (!pActors[p_id].CanAct()) {
                --active_actors;
                pQueue[i].actor_initiative = 1001;
                pActors[p_id].ResetQueue();
            }
        } else if (p_type == OBJECT_Player) {
            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);
    }
}

Перекрестные ссылки TurnBased_QueueElem::actor_initiative, field_18, OBJECT_Actor, OBJECT_Player, pActors, pParty, Party::pPlayers, pQueue, TE_PLAYER_TURN, uActiveCharacter, uActorQueueSize и TurnBased_QueueElem::uPackedID.

Используется в _406457(), _4065B0(), NextTurn(), Start() и StepTurnQueue().

Граф вызова функции:

ApplyPlayerAction()

void stru262_TurnBased::ApplyPlayerAction

(

)

См. определение в файле TurnEngine.cpp строка 101

                                          {
    if (pParty->bTurnBasedModeOn) {
        if (pTurnEngine->turn_stage == TE_ATTACK) _406457(0);
    }
}

Перекрестные ссылки _406457(), Party::bTurnBasedModeOn, pParty, pTurnEngine, TE_ATTACK и turn_stage.

Используется в CastSpellInfoHelpers::_427E01_cast_spell(), Player::_42ECB5_PlayerAttacksActor(), Application::Game::EventLoop(), Keyboard::ProcessInputActions(), Actor::StealFrom() и Player::UseItem_DrinkPotion_etc().

Граф вызовов:

Граф вызова функции:

Start()

void stru262_TurnBased::Start

(

)

См. определение в файле TurnEngine.cpp строка 108

                              {
    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;
 
    pTurnEngine->field_18 &= ~TE_HAVE_PENDING_ACTIONS;
    pEventTimer->TrackGameTime();
    pAudioPlayer->StopChannels(-1, -1);
    pAudioPlayer->PlaySound(SOUND_batllest, 0, 0, -1, 0, 0);
    // pPlayer = pParty->pPlayers.data();
    dword_50C998_turnbased_icon_1A =
        pIconsFrameTable->GetIcon(uIconID_TurnStart)->GetAnimLength();
    dword_50C994 = 0;
 
    this->turn_initiative = 100;
    this->turns_count = 0;
    this->ai_turn_timer = 64;
    this->turn_stage = TE_WAIT;
    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 (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]].ActorNearby()) {
                pActors[ai_near_actors_ids[i]].uAttributes |=
                    ACTOR_STAND_IN_QUEUE;  // 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;
            }
        }
    }
 
    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 =
                    (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;
                }
            }
        }
        for (i = 0; i < a_players_count; ++i)
            this->pQueue[activ_players[i]].actor_initiative = i + 2;
    }
    this->SortTurnQueue();
}

Перекрестные ссылки TurnBased_QueueElem::actor_initiative, TurnBased_QueueElem::AI_action_type, ai_arrays_size, ai_near_actors_ids, ai_near_actors_targets_pid, Actor::AI_StandOrBored(), ai_turn_timer, dword_50C994, dword_50C998_turnbased_icon_1A, field_18, Icon::GetAnimLength(), Actor::GetDirectionInfo(), IconFrameTable::GetIcon(), OBJECT_Actor, OBJECT_Player, pActors, pAudioPlayer, pEventTimer, pIconsFrameTable, AudioPlayer::PlaySound(), pParty, pPlayers, Party::pPlayers, pQueue, Party::pTurnBasedPlayerRecoveryTimes, pTurnEngine, SortTurnQueue(), SOUND_batllest, AudioPlayer::StopChannels(), TE_AI_PURSUE, TE_HAVE_PENDING_ACTIONS, TE_WAIT, Timer::TrackGameTime(), turn_initiative, turn_stage, turns_count, TurnBased_QueueElem::uActionLength, uActorQueueSize, uIconID_TurnStart и TurnBased_QueueElem::uPackedID.

Используется в Keyboard::ProcessInputActions().

Граф вызовов:

Граф вызова функции:

End()

void stru262_TurnBased::End

(

bool

bPlaySound

)

См. определение в файле TurnEngine.cpp строка 220

                                           {
    ObjectType objType;  // eax@13
    int objID;           // esi@13
    int i;
 
    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)].ResetQueue();
    }
 
    for (uint 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_batlleen, 0, 0, -1, 0, 0);
    pTurnEngine->field_18 &= ~TE_HAVE_PENDING_ACTIONS;
    pEventTimer->StopGameTime();
    dword_50C994 = 0;
    dword_50C998_turnbased_icon_1A = 0;
}

Перекрестные ссылки TurnBased_QueueElem::actor_initiative, dword_50C994, dword_50C998_turnbased_icon_1A, field_18, OBJECT_Actor, OBJECT_Player, pActors, pAudioPlayer, pEventTimer, AudioPlayer::PlaySound(), pPlayers, pQueue, pSpriteObjects, pTurnEngine, SOUND_batlleen, AudioPlayer::StopChannels(), Timer::StopGameTime(), TE_HAVE_PENDING_ACTIONS, TE_NONE, turn_stage, uActorQueueSize и uNumSpriteObjects.

Используется в Application::Game::GameLoop() и Keyboard::ProcessInputActions().

Граф вызовов:

Граф вызова функции:

AITurnBasedAction()

void stru262_TurnBased::AITurnBasedAction

(

)

См. определение в файле TurnEngine.cpp строка 260

                                          {
    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 j;
 
    for (uint i = 0; i < uNumActors; ++i) {
        curr_actor = &pActors[i];
        shrinked = pActors[i].pActorBuffs[ACTOR_BUFF_SHRINK].Active();
        for (j = 0; j < 22; ++j) {  // check expired spell Buffs
            if (j != 10)
                pActors[i].pActorBuffs[j].IsBuffExpiredToTime(
                    pParty->GetPlayingTime());
        }
        if (shrinked && pActors[i].pActorBuffs[ACTOR_BUFF_SHRINK].Expired())
            pActors[i].uActorHeight =
                pMonsterList->pMonsters[pActors[i].pMonsterInfo.uID - 1]
                    .uMonsterHeight;
 
        if (!(curr_actor->uAttributes & 0x80) &&
            !curr_actor->pActorBuffs[ACTOR_BUFF_STONED].Expired() &&
            !curr_actor->pActorBuffs[ACTOR_BUFF_PARALYZED].Expired()) {
            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->uCurrentActionTime = 0;
                    curr_actor->uCurrentActionLength = 0;
                    curr_actor->uAIState = Dead;
                    curr_actor->UpdateAnimation();
                } else if ((curr_actor->uAIState > Removed) &&
                    (curr_actor->uAIState < 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;
        }
    }
}

Перекрестные ссылки _4065B0(), ACTOR_BUFF_PARALYZED, ACTOR_BUFF_SHRINK, ACTOR_BUFF_STONED, ActorAIChooseNewTargets(), ActorAIDoAdditionalMove(), ActorAISetMovementDecision(), ActorAIStopMovement(), ai_near_actors_targets_pid, Actor::AI_StandOrBored(), ai_turn_timer, Dead, Disabled, Dying, SpellBuff::Expired(), field_18, Actor::GetDirectionInfo(), Party::GetPlayingTime(), NextTurn(), OBJECT_Actor, Actor::pActorBuffs, pActors, pEventTimer, pMiscTimer, pMonsterList, MonsterList::pMonsters, pParty, pQueue, Removed, SetAIRecoveryTimes(), StartTurn(), TE_ATTACK, TE_FLAG_1, TE_FLAG_8, TE_MOVEMENT, TE_WAIT, turn_initiative, turn_stage, uActionPointsLeft, Actor::uAIState, Actor::uAttributes, Actor::uCurrentActionLength, Actor::uCurrentActionTime, MonsterDesc::uMonsterHeight, uNumActors, Actor::UpdateAnimation() и Timer::uTimeElapsed.

Используется в Actor::UpdateActorAI().

Граф вызовов:

Граф вызова функции:

StartTurn()

void stru262_TurnBased::StartTurn

(

)

См. определение в файле TurnEngine.cpp строка 342

                                  {
    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);
    }
}

Перекрестные ссылки TurnBased_QueueElem::actor_initiative, AI_Action_(), TurnBased_QueueElem::AI_action_type, ai_arrays_size, ai_near_actors_ids, OBJECT_Actor, OBJECT_Player, pending_actions, pPlayers, pQueue, StepTurnQueue(), TE_AI_STAND, turn_initiative, turns_count, TurnBased_QueueElem::uActionLength, uActorQueueSize и TurnBased_QueueElem::uPackedID.

Используется в AITurnBasedAction().

Граф вызовов:

Граф вызова функции:

NextTurn()

void stru262_TurnBased::NextTurn

(

)

См. определение в файле TurnEngine.cpp строка 395

                                 {
    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 = 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) {
        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 == Dying) ||
                    (pActors[monster_id].uAIState == Stunned) ||
                    (pActors[monster_id].uAIState == AttackingMelee) ||
                    (pActors[monster_id].uAIState == AttackingRanged1) ||
                    (pActors[monster_id].uAIState == AttackingRanged2) ||
                    (pActors[monster_id].uAIState == AttackingRanged3) ||
                    (pActors[monster_id].uAIState == AttackingRanged4) ||
                    (pActors[monster_id].uAIState == Summoned)) {
                    pActors[monster_id].uCurrentActionTime +=
                        pEventTimer->uTimeElapsed;
                    if (pActors[monster_id].uCurrentActionTime <
                        pActors[monster_id].uCurrentActionLength) {
                        v13 = 1;
                    } else if (pActors[monster_id].uAIState == Dying) {  // Dying
                        pActors[monster_id].uAIState = Dead;
                        pActors[monster_id].uCurrentActionTime = 0;
                        pActors[monster_id].uCurrentActionLength = 0;
                        pActors[monster_id].UpdateAnimation();
                    } else {
                        if (pActors[monster_id].uAIState == 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 (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 != Dead) &&
                (pActors[monster_id].uAIState != Dying) &&
                (pActors[monster_id].uAIState != Removed) &&
                (pActors[monster_id].uAIState != Summoned) &&
                (pActors[monster_id].uAIState != 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->GetPlayingTime().value += 213;
    _494035_timed_effects__water_walking_damage__etc();
    uActionPointsLeft = 130;
}

Перекрестные ссылки _494035_timed_effects__water_walking_damage__etc(), ai_near_actors_targets_pid, Actor::AI_StandOrBored(), AttackingMelee, AttackingRanged1, AttackingRanged2, AttackingRanged3, AttackingRanged4, ViewingParams::bRedrawGameUI, Dead, Disabled, Dying, field_18, Party::GetPlayingTime(), OBJECT_Actor, OBJECT_Player, pActors, pending_actions, pEventTimer, pParty, pQueue, pTurnEngine, Removed, SortTurnQueue(), Stunned, Summoned, TE_FLAG_1, TE_HAVE_PENDING_ACTIONS, TE_MOVEMENT, turn_stage, TurnBased_QueueElem::uActionLength, uActionPointsLeft, uActiveCharacter, uActorQueueSize, Timer::uTimeElapsed, GameTime::value и viewparams.

Используется в AITurnBasedAction().

Граф вызовов:

Граф вызова функции:

StepTurnQueue()

bool stru262_TurnBased::StepTurnQueue

(

)

См. определение в файле TurnEngine.cpp строка 477

                                      {
    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 == Dying || v9 == Dead || v9 == Disabled ||
                      v9 == 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;
}

Перекрестные ссылки TurnBased_QueueElem::actor_initiative, ViewingParams::bRedrawGameUI, Dead, Disabled, Dying, OBJECT_Player, pActors, pQueue, Removed, SortTurnQueue(), turn_initiative, TurnBased_QueueElem::uActionLength, uActorQueueSize и viewparams.

Используется в _4065B0() и StartTurn().

Граф вызовов:

Граф вызова функции:

_406457()

void stru262_TurnBased::_406457

(

int

a2

)

См. определение в файле TurnEngine.cpp строка 513

                                      {
    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]) {
            v6 = pParty->pTurnBasedPlayerRecoveryTimes[v4];
            pParty->pTurnBasedPlayerRecoveryTimes[v4] = 0;
        } else {
            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;
    }
}

Перекрестные ссылки TurnBased_QueueElem::actor_initiative, ViewingParams::bRedrawGameUI, OBJECT_Player, pActors, MonsterStats::pInfos, pMonsterStats, pParty, pPlayers, pQueue, Party::pTurnBasedPlayerRecoveryTimes, SortTurnQueue(), turn_initiative, TurnBased_QueueElem::uActionLength, uActiveCharacter, uActorQueueSize, MonsterInfo::uRecoveryTime и viewparams.

Используется в ApplyPlayerAction().

Граф вызовов:

Граф вызова функции:

SetAIRecoveryTimes()

void stru262_TurnBased::SetAIRecoveryTimes

(

)

См. определение в файле TurnEngine.cpp строка 551

                                           {
    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 == Standing || monster_ai_state == Fleeing ||
                monster_ai_state == Fidgeting) {
                pQueue[i].actor_initiative =
                    pMonsterStats->pInfos[monster->pMonsterInfo.uID]
                        .uRecoveryTime;
                if (monster->pActorBuffs[ACTOR_BUFF_SLOWED].Active())
                    pQueue[i].actor_initiative *= 2;
            }
        }
    }
}

Перекрестные ссылки SpellBuff::Active(), ACTOR_BUFF_SLOWED, TurnBased_QueueElem::actor_initiative, Fidgeting, Fleeing, OBJECT_Player, Actor::pActorBuffs, pActors, MonsterStats::pInfos, Actor::pMonsterInfo, pMonsterStats, pQueue, Standing, uActorQueueSize, Actor::uAIState, MonsterInfo::uID и MonsterInfo::uRecoveryTime.

Используется в AITurnBasedAction().

Граф вызовов:

Граф вызова функции:

_4065B0()

void stru262_TurnBased::_4065B0

(

)

См. определение в файле TurnEngine.cpp строка 574

                                {
    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);
        }
    } 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);
}

Перекрестные ссылки AI_Action_(), AIAttacks(), ViewingParams::bRedrawGameUI, OBJECT_Actor, OBJECT_Player, pQueue, SortTurnQueue(), StepTurnQueue(), uActiveCharacter, uActorQueueSize и viewparams.

Используется в AITurnBasedAction().

Граф вызовов:

Граф вызова функции:

AIAttacks()

void stru262_TurnBased::AIAttacks

(

unsigned int

queue_index

)

См. определение в файле TurnEngine.cpp строка 599

                                                          {
    // 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 = 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 != Dead) &&
            (pActors[actor_id].uAIState != Disabled) &&
            (pActors[actor_id].uAIState != Removed)) {
            pActors[actor_id].uCurrentActionTime += pEventTimer->uTimeElapsed;
            if ((signed int)pActors[actor_id].uCurrentActionTime >=
                pActors[actor_id].uCurrentActionLength) {
                switch (pActors[actor_id].uAIState) {
                    case 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 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 Dying:
                        pActors[actor_id].uCurrentActionTime = 0;
                        pActors[actor_id].uCurrentActionLength = 0;
                        pActors[actor_id].uAIState = Dead;
                        pActors[actor_id].UpdateAnimation();
                        break;
                    case Stunned:
                        Actor::AI_Stand(actor_id,
                                        ai_near_actors_targets_pid[actor_id], 0,
                                        &a4);
                        break;
                    case 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 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 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);
                }
            }
        }
    }
}

Перекрестные ссылки stru298::Add(), Actor::AI_Bored(), ai_near_actors_targets_pid, Actor::AI_RangedAttack(), Actor::AI_SpellAttack(), Actor::AI_Stand(), AttackerInfo, AttackingMelee, AttackingRanged1, AttackingRanged2, AttackingRanged3, AttackingRanged4, Dead, Disabled, Dying, Actor::GetDirectionInfo(), OBJECT_Actor, pActors, pEventTimer, pQueue, Removed, Stunned и Timer::uTimeElapsed.

Используется в _4065B0().

Граф вызовов:

Граф вызова функции:

AI_Action_()

void stru262_TurnBased::AI_Action_

(

int

queue_index

)

См. определение в файле TurnEngine.cpp строка 709

                                                  {
    unsigned int actor_id;  // edi@2
    AIDirection v7;         // esi@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
    signed int v22;         // [sp+58h] [bp+8h]@10
 
    pQueue[queue_index].uActionLength = 0;
    if (PID_TYPE(pQueue[queue_index].uPackedID) == OBJECT_Actor) {
        actor_id = PID_ID(pQueue[queue_index].uPackedID);
        if (!(pActors[actor_id].uAIState == Dying ||
              pActors[actor_id].uAIState == Dead ||
              pActors[actor_id].uAIState == Summoned ||
              pActors[actor_id].uAIState == Disabled ||
              pActors[actor_id].uAIState == 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);
            memcpy(&a3, &v7, sizeof(AIDirection));
            memcpy(&v18, &a3, sizeof(AIDirection));
            v9 = a3.uDistance - pActors[actor_id].uActorRadius;
            if (v9 < 0) v9 = 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;
                        }
                        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;
                    pQueue[queue_index].uActionLength =
                        pActors[actor_id].uCurrentActionLength;
                    return;
                } 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;
                    return;
                }
            } 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;
        }
    }
}

Перекрестные ссылки Actor::_SelectTarget(), TurnBased_QueueElem::AI_action_type, Actor::AI_MeleeAttack(), Actor::AI_MissileAttack1(), Actor::AI_MissileAttack2(), ai_near_actors_targets_pid, Actor::AI_SpellAttack1(), Actor::AI_SpellAttack2(), Actor::AI_Stand(), Dead, Disabled, Dying, Actor::GetDirectionInfo(), MonsterInfo::Hostility_Friendly, MonsterInfo::Hostility_Long, OBJECT_Actor, pActors, pFactionTable, MonsterStats::pInfos, pMonsterStats, pQueue, FactionTable::relations, Removed, Summoned, TE_AI_MELEE_ATTACK, TE_AI_RANGED_ATTACK, TE_AI_STAND, TurnBased_QueueElem::uActionLength, AIDirection::uDistance и MonsterInfo::uID.

Используется в _4065B0() и StartTurn().

Граф вызовов:

Граф вызова функции:

ActorAISetMovementDecision()

void stru262_TurnBased::ActorAISetMovementDecision

(

)

См. определение в файле TurnEngine.cpp строка 830

                                                   {
    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);
        }
    }
}

Перекрестные ссылки ActorMove(), ai_near_actors_targets_pid, Actor::AI_Stand(), ai_turn_timer, dword_50C994, Actor::GetDirectionInfo(), OBJECT_Actor, pQueue, uActiveCharacter и uActorQueueSize.

Используется в AITurnBasedAction().

Граф вызовов:

Граф вызова функции:

ActorAIStopMovement()

void stru262_TurnBased::ActorAIStopMovement

(

)

См. определение в файле TurnEngine.cpp строка 853

                                            {
    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 = TE_ATTACK;
    ai_turn_timer = 100;
}

Перекрестные ссылки TurnBased_QueueElem::AI_action_type, ai_near_actors_targets_pid, Actor::AI_Stand(), ai_turn_timer, Actor::GetDirectionInfo(), OBJECT_Actor, pQueue, TE_AI_STAND, TE_ATTACK, turn_stage, TurnBased_QueueElem::uActionLength и uActorQueueSize.

Используется в AITurnBasedAction().

Граф вызовов:

Граф вызова функции:

ActorAIDoAdditionalMove()

void stru262_TurnBased::ActorAIDoAdditionalMove

(

)

См. определение в файле TurnEngine.cpp строка 874

                                                {
    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) {
            monster_id = PID_ID(pQueue[i].uPackedID);
            if (!(pActors[monster_id].pActorBuffs[ACTOR_BUFF_STONED].Active() ||
                  pActors[monster_id]
                      .pActorBuffs[ACTOR_BUFF_PARALYZED]
                      .Active() ||
                  pActors[monster_id].uAIState == Dead ||
                  pActors[monster_id].uAIState == Removed ||
                  pActors[monster_id].uAIState == 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 == Pursuing ||
                    pActors[monster_id].uAIState == Tethered) {
                    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 == Dying) {
                            pActors[monster_id].uCurrentActionTime = 0;
                            pActors[monster_id].uCurrentActionLength = 0;
                            pActors[monster_id].uAIState = Dead;
                            pActors[monster_id].UpdateAnimation();
                        }
                        if (!ActorMove(i))
                            Actor::AI_Stand(PID_ID(pQueue[i].uPackedID), v13,
                                            32, &v9);
                    }
                }
            }
        }
    }
}

Перекрестные ссылки ACTOR_BUFF_PARALYZED, ACTOR_BUFF_STONED, ActorMove(), ai_near_actors_targets_pid, Actor::AI_Stand(), Dead, Disabled, Dying, Actor::GetDirectionInfo(), OBJECT_Actor, pActors, pEventTimer, pQueue, Pursuing, Removed, Tethered, uActorQueueSize, AIDirection::uDistance и Timer::uTimeElapsed.

Используется в AITurnBasedAction().

Граф вызовов:

Граф вызова функции:

ActorMove()

bool stru262_TurnBased::ActorMove

(

signed int

a2

)

См. определение в файле TurnEngine.cpp строка 919

                                                           {
    AIDirection v9;                // esi@10
    int v11;                       // ecx@10
    unsigned __int8 pHostileType;  // al@12
    AIDirection a3;                // [sp+Ch] [bp-48h]@10
    AIDirection pDir;              // [sp+28h] [bp-2Ch]@10
    unsigned int uActorID;         // [sp+50h] [bp-4h]@2
 
    if (PID_TYPE(pQueue[queue_position].uPackedID) == OBJECT_Player) return 0;
    uActorID = PID_ID(pQueue[queue_position].uPackedID);
    if (pActors[uActorID].uAIState == Dead ||
        pActors[uActorID].uAIState == Dying ||
        pActors[uActorID].uAIState == Removed ||
        pActors[uActorID].uAIState == Disabled ||
        pActors[uActorID].uAIState == Summoned)
        return 1;
    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);
    memcpy(&a3, &v9, sizeof(AIDirection));
    memcpy(&pDir, &a3, sizeof(AIDirection));
    v11 = a3.uDistance - pActors[uActorID].uActorRadius;
    if (v11 < 0) v11 = 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].Active()) {
        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 & ACTOR_FLEEING) ||
            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 (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)v11 < 307.2) return 0;
        if ((signed int)v11 < 5120) {
            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;
}

Перекрестные ссылки Actor::_SelectTarget(), ACTOR_BUFF_AFRAID, TurnBased_QueueElem::AI_action_type, Actor::AI_Flee(), ai_near_actors_targets_pid, Actor::AI_Pursue1(), Actor::AI_Pursue2(), Actor::AI_RandomMove(), Actor::AI_Stand(), Dead, Disabled, Dying, Actor::GetDirectionInfo(), MonsterInfo::Hostility_Friendly, MonsterInfo::Hostility_Long, MONSTER_MOVEMENT_TYPE_FREE, MONSTER_MOVEMENT_TYPE_LONG, MONSTER_MOVEMENT_TYPE_MEDIUM, MONSTER_MOVEMENT_TYPE_SHORT, MONSTER_MOVEMENT_TYPE_STAIONARY, OBJECT_Player, pActors, pQueue, pTurnEngine, Removed, Summoned, TE_AI_FLEE, TE_AI_PURSUE, TurnBased_QueueElem::uActionLength и AIDirection::uDistance.

Используется в ActorAIDoAdditionalMove() и ActorAISetMovementDecision().

Граф вызовов:

Граф вызова функции:

ActorAIChooseNewTargets()

void stru262_TurnBased::ActorAIChooseNewTargets

(

)

См. определение в файле TurnEngine.cpp строка 1084

                                                {
    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) {
            uActorID = PID_ID(pQueue[i].uPackedID);
            curr_acror = &pActors[uActorID];
            if (!(curr_acror->uAIState == Summoned ||
                  curr_acror->uAIState == Dead ||
                  curr_acror->uAIState == Removed ||
                  curr_acror->uAIState == 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 == Dying) {
                        curr_acror->uCurrentActionTime = 0;
                        curr_acror->uCurrentActionLength = 0;
                        curr_acror->uAIState = Dead;
                        curr_acror->UpdateAnimation();
                        break;
                    }
                    if (rand() % 2)
                        Actor::AI_Stand(uActorID, target_pid, 64, &a4);
                    else
                        Actor::AI_Bored(uActorID, target_pid, &a4);
                }
            }
        }
    }
}

Перекрестные ссылки Actor::_SelectTarget(), Actor::AI_Bored(), ai_near_actors_targets_pid, Actor::AI_Stand(), Dead, Disabled, Dying, Actor::GetDirectionInfo(), OBJECT_Actor, pActors, pEventTimer, pQueue, Removed, Summoned, uActorQueueSize, Actor::uAIState, Actor::uCurrentActionLength, Actor::uCurrentActionTime, Actor::UpdateAnimation() и Timer::uTimeElapsed.

Используется в AITurnBasedAction().

Граф вызовов:

Граф вызова функции:

Данные класса

turns_count

int stru262_TurnBased::turns_count

См. определение в файле TurnEngine.h строка 74

Используется в Start(), StartTurn() и stru262_TurnBased().

turn_stage

int stru262_TurnBased::turn_stage

См. определение в файле TurnEngine.h строка 75

Используется в _42777D_CastSpell_UseWand_ShootArrow(), ActorAIStopMovement(), AITurnBasedAction(), ApplyPlayerAction(), BLV_ProcessPartyActions(), OtherOverlayList::DrawTurnBasedIcon(), End(), Application::Game::EventLoop(), GameUI_DrawPortraits(), Party::GetNextActiveCharacter(), NextTurn(), ODM_ProcessPartyActions(), Engine::OnGameViewportClick(), Keyboard::ProcessInputActions(), Start(), stru262_TurnBased(), Mouse::UI_OnMouseLeftClick(), UpdateActors_BLV(), UpdateActors_ODM() и Player::UseItem_DrinkPotion_etc().

ai_turn_timer

int stru262_TurnBased::ai_turn_timer

См. определение в файле TurnEngine.h строка 76

Используется в ActorAISetMovementDecision(), ActorAIStopMovement(), AITurnBasedAction(), Start() и stru262_TurnBased().

uActorQueueSize

int stru262_TurnBased::uActorQueueSize

См. определение в файле TurnEngine.h строка 77

Используется в _406457(), _4065B0(), ActorAIChooseNewTargets(), ActorAIDoAdditionalMove(), ActorAISetMovementDecision(), ActorAIStopMovement(), End(), GameUI_DrawPortraits(), NextTurn(), SetAIRecoveryTimes(), SortTurnQueue(), Start(), StartTurn(), StepTurnQueue() и stru262_TurnBased().

turn_initiative

int stru262_TurnBased::turn_initiative

См. определение в файле TurnEngine.h строка 78

Используется в _406457(), AITurnBasedAction(), Start(), StartTurn(), StepTurnQueue() и stru262_TurnBased().

uActionPointsLeft

int stru262_TurnBased::uActionPointsLeft

См. определение в файле TurnEngine.h строка 79

Используется в AITurnBasedAction(), OtherOverlayList::DrawTurnBasedIcon(), NextTurn(), Keyboard::ProcessInputActions() и stru262_TurnBased().

field_18

int stru262_TurnBased::field_18

См. определение в файле TurnEngine.h строка 80

Используется в AITurnBasedAction(), End(), Application::Game::EventLoop(), NextTurn(), Engine::OnGameViewportClick(), Keyboard::ProcessInputActions(), SortTurnQueue(), Start(), stru262_TurnBased() и Mouse::UI_OnMouseLeftClick().

pending_actions

int stru262_TurnBased::pending_actions

См. определение в файле TurnEngine.h строка 81

Используется в CastSpellInfoHelpers::_427E01_cast_spell(), _46BFFA_update_spell_fx(), NextTurn(), SpriteObject::OnInteraction(), StartTurn(), stru262_TurnBased() и Actor::UpdateActorAI().

pQueue

TurnBased_QueueElem stru262_TurnBased::pQueue[530]

См. определение в файле TurnEngine.h строка 82

Используется в _406457(), _4065B0(), ActorAIChooseNewTargets(), ActorAIDoAdditionalMove(), ActorAISetMovementDecision(), ActorAIStopMovement(), ActorMove(), AI_Action_(), AIAttacks(), AITurnBasedAction(), End(), GameUI_DrawPortraits(), Party::GetNextActiveCharacter(), NextTurn(), Keyboard::ProcessInputActions(), SetAIRecoveryTimes(), SortTurnQueue(), Start(), StartTurn() и StepTurnQueue().

---

Объявления и описания членов структур находятся в файлах:

• C:/git/world-of-might-and-magic/Engine/TurnEngine/TurnEngine.h
• C:/git/world-of-might-and-magic/Engine/TurnEngine/TurnEngine.cpp