Файл Arcomage.cpp

См. исходные тексты.

Классы
struct	ArcomageStartConditions
struct	am_ai_cardpowerstruct
struct	arcomage_mouse

Функции
void	SetStartConditions ()
void	SetStartGameData ()
void	FillPlayerDeck ()
void	InitalHandsFill ()
void	GetNextCardFromDeck (int player_num)
int	GetEmptyCardSlotIndex (int player_num)
void	IncreaseResourcesInTurn (int player_num)
void	TurnChange ()
bool	IsGameOver ()
int	CalculateCardPower (ArcomagePlayer *player, ArcomagePlayer *enemy, ArcomageCard *pCard, int mastery)
char	PlayerTurn (int player_num)
void	DrawGameUI (int animation_stage)
void	DrawSparks ()
void	DrawRectanglesForText ()
void	DrawPlayersText ()
void	DrawPlayerLevels (const String &str, Point *pXY)
void	DrawBricksCount (const String &str, Point *pXY)
void	DrawGemsCount (const String &str, Point *pXY)
void	DrawBeastsCount (const String &str, Point *pXY)
void	DrawPlayersTowers ()
void	DrawPlayersWall ()
void	DrawCards ()
void	DrawCardAnimation (int a1)
int	GetPlayerHandCardCount (int player_num)
int	DrawCardsRectangles (int player_num)
bool	DiscardCard (int player_num, int card_slot_index)
bool	PlayCard (int player_num, int card_slot_num)
bool	CanCardBePlayed (int player_num, int hand_card_indx)
void	ApplyCardToPlayer (int player_num, unsigned int uCardID)
int	new_explosion_effect (Point *a1, int a2)
int	ApplyDamageToBuildings (int player_num, int damage)
void	GameResultsApply ()
void	am_DrawText (const String &str, Point *pXY)
void	DrawRect (Rect *pXYZW, unsigned __int16 uColor, char bSolidFill)
int	rand_interval (int min, int max)
void	am_IntToString (int val, char *pOut)
unsigned int	R8G8B8_to_TargetFormat (int uColor)
bool	OpponentsAITurn (int player_num)
bool	DiscardCard (int player_num, signed int card_slot_index)
void	set_stru1_field_8_InArcomage (int inValue)

Переменные
const ArcomageStartConditions	start_conditions [13]
ArcomageGame *	pArcomageGame = new ArcomageGame
ArcomagePlayer	am_Players [2]
AcromageCardOnTable	shown_cards [10]
am_effects_struct	am_effects_array [10]
ArcomageDeck	playDeck
ArcomageDeck	deckMaster
char	Player2Name [] = "Enemy"
char	Player1Name [] = "Player"
am_ai_cardpowerstruct	cards_power [10]
bool	Player_Gets_First_Turn = 1
bool	Player_Cards_Shift = 1
char	use_start_bonus = 1
int	start_tower_height
int	start_wall_height
int	start_quarry_level
int	start_magic_level
int	start_zoo_level
int	start_bricks_amount
int	start_gems_amount
int	start_beasts_amount
int	minimum_cards_at_hand = 5
int	quarry_bonus = 1
int	magic_bonus = 1
int	zoo_bonus = 1
int	max_tower_height = 50
int	max_resources_amount = 100
int	opponent_mastery = 1
char	opponents_turn
char	See_Opponents_Cards = 0
int	current_player_num
char	need_to_discard_card
int	current_card_slot_index
int	played_card_id
int	discarded_card_id
int	deck_walk_index
int	Card_Hover_Index
int	num_cards_to_discard
int	num_actions_left
sPoint	anim_card_spd_drawncard
Point	anim_card_pos_drawncard
sPoint	anim_card_spd_playdiscard
Point	anim_card_pos_playdiscard
char	drawn_card_anim_start
int	drawn_card_anim_cnt
int	drawn_card_slot_index
char	playdiscard_anim_start
char	hide_card_anim_start
char	hide_card_anim_runnning
int	hide_card_anim_count

Функции

SetStartConditions()

void SetStartConditions

(

)

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

                          {
    const ArcomageStartConditions *st_cond;
    st_cond = &start_conditions[window_SpeakInHouse->par1C - 108];
 
    // set start conditions
    start_tower_height = st_cond->tower_height;
    start_wall_height = st_cond->wall_height;
    start_quarry_level = st_cond->quarry_level - 1;
    start_magic_level = st_cond->magic_level - 1;
    start_zoo_level = st_cond->zoo_level - 1;
    start_bricks_amount = st_cond->bricks_amount;
    start_gems_amount = st_cond->gems_amount;
    start_beasts_amount = st_cond->beasts_amount;
    // win conditions
    max_tower_height = st_cond->max_tower;
    max_resources_amount = st_cond->max_resources;
    // opponent skill level
    opponent_mastery = st_cond->mastery_lvl;
 
    // bonus acts as min level
    minimum_cards_at_hand = 5;
    quarry_bonus = 1;
    magic_bonus = 1;
    zoo_bonus = 1;
}

Перекрестные ссылки ArcomageStartConditions::beasts_amount, ArcomageStartConditions::bricks_amount, ArcomageStartConditions::gems_amount, magic_bonus, ArcomageStartConditions::magic_level, ArcomageStartConditions::mastery_lvl, ArcomageStartConditions::max_resources, max_resources_amount, ArcomageStartConditions::max_tower, max_tower_height, minimum_cards_at_hand, opponent_mastery, GUIWindow::par1C, quarry_bonus, ArcomageStartConditions::quarry_level, start_beasts_amount, start_bricks_amount, start_conditions, start_gems_amount, start_magic_level, start_quarry_level, start_tower_height, start_wall_height, start_zoo_level, ArcomageStartConditions::tower_height, ArcomageStartConditions::wall_height, window_SpeakInHouse, zoo_bonus и ArcomageStartConditions::zoo_level.

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

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

SetStartGameData()

void SetStartGameData

(

)

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

                        {
    signed int j;                       // edx@7
    int card_id_counter;                // edx@13
    signed int i;                       // ecx@13
    signed int card_dispenser_counter;  // eax@13
 
    SetStartConditions();
 
    current_player_num = !Player_Gets_First_Turn;
    strcpy(am_Players[1].pPlayerName, pArcomageGame->pPlayer2Name);
    am_Players[1].IsHisTurn = 0;  // !Player_Gets_First_Turn;
    strcpy(am_Players[0].pPlayerName, pArcomageGame->pPlayer1Name);
    am_Players[0].IsHisTurn = 1;  // Player_Gets_First_Turn;
 
    for (i = 0; i < 2; ++i) {
        am_Players[i].tower_height = start_tower_height;
        am_Players[i].wall_height = start_wall_height;
        am_Players[i].quarry_level = start_quarry_level;
        am_Players[i].magic_level = start_magic_level;
        am_Players[i].zoo_level = start_zoo_level;
        am_Players[i].resource_bricks = start_bricks_amount;
        am_Players[i].resource_gems = start_gems_amount;
        am_Players[i].resource_beasts = start_beasts_amount;
 
        for (j = 0; j < 10; ++j) {
            am_Players[i].cards_at_hand[j] = -1;
            if (Player_Cards_Shift) {
                am_Players[i].card_shift[j].x = -1;
                am_Players[i].card_shift[j].y = -1;
            } else {
                am_Players[i].card_shift[j].x = 0;
                am_Players[i].card_shift[j].y = 0;
            }
        }
    }
    strcpy(deckMaster.name, "Master Deck");
    for (i = 0, card_dispenser_counter = -2, card_id_counter = 0; i < DECK_SIZE;
         ++i, ++card_dispenser_counter) {
        deckMaster.cardsInUse[i] = 0;
        deckMaster.cards_IDs[i] = card_id_counter;
        switch (card_dispenser_counter) {
            case 0:
            case 2:
            case 6:
            case 9:
            case 13:
            case 18:
            case 23:
            case 33:
            case 36:
            case 38:
            case 44:
            case 46:
            case 52:
            case 57:
            case 69:
            case 71:
            case 75:
            case 79:
            case 81:
            case 84:
            case 89:
                break;
            default:
                ++card_id_counter;
        }
    }
    FillPlayerDeck();
}

Перекрестные ссылки am_Players, ArcomagePlayer::card_shift, ArcomagePlayer::cards_at_hand, ArcomageDeck::cards_IDs, ArcomageDeck::cardsInUse, current_player_num, deckMaster, FillPlayerDeck(), ArcomagePlayer::IsHisTurn, ArcomagePlayer::magic_level, ArcomageDeck::name, pArcomageGame, Player_Cards_Shift, Player_Gets_First_Turn, ArcomageGame::pPlayer1Name, ArcomageGame::pPlayer2Name, ArcomagePlayer::quarry_level, ArcomagePlayer::resource_beasts, ArcomagePlayer::resource_bricks, ArcomagePlayer::resource_gems, SetStartConditions(), start_beasts_amount, start_bricks_amount, start_gems_amount, start_magic_level, start_quarry_level, start_tower_height, start_wall_height, start_zoo_level, ArcomagePlayer::tower_height, ArcomagePlayer::wall_height, sPoint::x, sPoint::y и ArcomagePlayer::zoo_level.

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

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

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

FillPlayerDeck()

void FillPlayerDeck

(

)

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

                      {
    int m;
    int rand_deck_pos;
    char card_taken_flags[DECK_SIZE];
    int i, j;
 
    ArcomageGame::PlaySound(20);
    memset(deckMaster.cardsInUse, 0, DECK_SIZE);
    memset(card_taken_flags, 0, DECK_SIZE);
 
    for (i = 0; i < 2; ++i) {
        for (j = 0; j < 10; ++j) {
            if (am_Players[i].cards_at_hand[j] > -1) {
                for (m = 0; m < DECK_SIZE; ++m) {
                    if (deckMaster.cards_IDs[m] ==
                            am_Players[i].cards_at_hand[j] &&
                        deckMaster.cardsInUse[m] == 0) {
                        // mark which cards are already in players hands
                        deckMaster.cardsInUse[m] = 1;
                        break;
                    }
                }
            }
        }
    }
 
    for (i = 0; i < DECK_SIZE; ++i) {
        do {
            rand_deck_pos = rand() % DECK_SIZE;
        } while (card_taken_flags[rand_deck_pos] == 1);
 
        card_taken_flags[rand_deck_pos] = 1;
        playDeck.cards_IDs[i] = deckMaster.cards_IDs[rand_deck_pos];
        playDeck.cardsInUse[i] = deckMaster.cardsInUse[rand_deck_pos];
    }
 
    deck_walk_index = 0;
    pArcomageGame->force_redraw_1 = 1;
}

Перекрестные ссылки am_Players, ArcomagePlayer::cards_at_hand, ArcomageDeck::cards_IDs, ArcomageDeck::cardsInUse, deck_walk_index, deckMaster, ArcomageGame::force_redraw_1, pArcomageGame, playDeck и ArcomageGame::PlaySound().

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

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

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

InitalHandsFill()

void InitalHandsFill

(

)

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

                       {
    for (int i = 0; i < minimum_cards_at_hand; ++i) {
        // GetNextCardFromDeck(0);
        // GetNextCardFromDeck(1);
        GetNextCardFromDeck(Player_Gets_First_Turn);
    }
    pArcomageGame->force_redraw_1 = 1;
}

Перекрестные ссылки ArcomageGame::force_redraw_1, GetNextCardFromDeck(), minimum_cards_at_hand, pArcomageGame и Player_Gets_First_Turn.

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

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

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

GetNextCardFromDeck()

void GetNextCardFromDeck

(

int

player_num

)

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

                                         {
    signed int deck_index;      // eax@1
    int new_card_id;            // edi@1
    signed int card_slot_indx;  // eax@7
 
    deck_index = deck_walk_index;
    for (;;) {
        if (deck_index >= DECK_SIZE) {
            FillPlayerDeck();
            deck_index = deck_walk_index = 0;
        }
        if (!playDeck.cardsInUse[deck_index]) {
            new_card_id = playDeck.cards_IDs[deck_index];
            ++deck_index;
            deck_walk_index = deck_index;
            break;
        }
        ++deck_index;
        deck_walk_index = deck_index;
    }
 
    ArcomageGame::PlaySound(21);
    card_slot_indx = GetEmptyCardSlotIndex(player_num);
    if (card_slot_indx != -1) {
        drawn_card_slot_index = card_slot_indx;
        am_Players[player_num].cards_at_hand[card_slot_indx] = new_card_id;
        am_Players[player_num].card_shift[card_slot_indx].x = rand_interval(-4, 4);
        am_Players[player_num].card_shift[card_slot_indx].y = rand_interval(-4, 4);
        pArcomageGame->force_redraw_1 = 1;
        drawn_card_anim_start = 1;
    }
}

Перекрестные ссылки am_Players, ArcomagePlayer::card_shift, ArcomagePlayer::cards_at_hand, ArcomageDeck::cards_IDs, ArcomageDeck::cardsInUse, deck_walk_index, drawn_card_anim_start, drawn_card_slot_index, FillPlayerDeck(), ArcomageGame::force_redraw_1, GetEmptyCardSlotIndex(), pArcomageGame, playDeck, ArcomageGame::PlaySound(), rand_interval(), sPoint::x и sPoint::y.

Используется в ApplyCardToPlayer(), InitalHandsFill(), ArcomageGame::Loop() и PlayerTurn().

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

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

GetEmptyCardSlotIndex()

int GetEmptyCardSlotIndex

(

int

player_num

)

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

                                          {
    // find first empty card slot
    for (int i = 0; i < 10; ++i) {
        if (am_Players[player_num].cards_at_hand[i] == -1) return i;
    }
    return -1;
}

Перекрестные ссылки am_Players.

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

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

IncreaseResourcesInTurn()

void IncreaseResourcesInTurn

(

int

player_num

)

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

                                             {
    // increase player resources
    am_Players[player_num].resource_bricks +=
        quarry_bonus + am_Players[player_num].quarry_level;
    am_Players[player_num].resource_gems +=
        magic_bonus + am_Players[player_num].magic_level;
    am_Players[player_num].resource_beasts +=
        zoo_bonus + am_Players[player_num].zoo_level;
}

Перекрестные ссылки am_Players, magic_bonus, ArcomagePlayer::magic_level, quarry_bonus, ArcomagePlayer::quarry_level, ArcomagePlayer::resource_beasts, ArcomagePlayer::resource_bricks, ArcomagePlayer::resource_gems, zoo_bonus и ArcomagePlayer::zoo_level.

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

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

TurnChange()

void TurnChange

(

)

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

                  {
    char player_name[64];    // [sp+4h] [bp-64h]@4
    ArcomageGame_InputMSG v10;  // [sp+54h] [bp-14h]@7
    Point v11;               // [sp+60h] [bp-8h]@4
 
    if (!pArcomageGame->force_am_exit) {
        if (am_Players[0].IsHisTurn != 1 || am_Players[1].IsHisTurn != 1) {
            ++current_player_num;
            hide_card_anim_start = 1;
            if (current_player_num >= 2) current_player_num = 0;
        } else {
            // this is never called - pause when switching turns
 
            // nullsub_1();
            //   v11.x = 0;
            //   v11.y = 0;
            strcpy(player_name, "The Next Player is: ");  //"След"
                                                            // v0 = 0;
            v11.y = 200;
            v11.x = 320;  // - 12 * v0 / 2;
            am_DrawText(player_name, &v11);
            hide_card_anim_start = 1;
            ++current_player_num;
            if (current_player_num >= 2) current_player_num = 0;
            strcpy(player_name, am_Players[current_player_num].pPlayerName);
            // v4 = 0;
            v11.y = 260;
            v11.x = 320;  // - 12 * v4 / 2;
            am_DrawText(player_name, &v11);
            /* v6.left = 0;
            v6.right = 640;
            v6.top = 0;
            v6.bottom = 480;*/
            // nullsub_1();
            render->Present();
            // nullsub_1();
            while (1) {
                while (!ArcomageGame::MsgLoop(20, &v10));
                if (v10.am_input_type == 1) {
                    if (v10.field_4) break;
                    // nullsub_1();
                    continue;
                }
                if ((v10.am_input_type > 4) && (v10.am_input_type <= 8)) break;
                if (v10.am_input_type == 10) {
                    pArcomageGame->force_am_exit = 1;
                    // byte_4FAA74 = 1;
                    break;
                }
            }
            /*  v11.x = 0;
            v11.y = 0;
            v6.left = 0;
            v6.right = 640;
            v6.top = 0;
            v6.bottom = 480;*/
            // nullsub_1();
            render->Present();
        }
    }
}

Перекрестные ссылки am_DrawText(), ArcomageGame_InputMSG::am_input_type, am_Players, current_player_num, ArcomageGame_InputMSG::field_4, ArcomageGame::force_am_exit, hide_card_anim_start, ArcomageGame::MsgLoop(), pArcomageGame, render, Point::x и Point::y.

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

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

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

IsGameOver()

bool IsGameOver

(

)

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

                  {
    // check if victory conditions have been met
    bool result = false;
    for (int i = 0; i < 2; ++i) {
        if (am_Players[i].tower_height <= 0) result = true;
        if (am_Players[i].tower_height >= max_tower_height) result = true;
        if (am_Players[i].resource_bricks >= max_resources_amount ||
            am_Players[i].resource_gems >= max_resources_amount ||
            am_Players[i].resource_beasts >= max_resources_amount)
            result = true;
    }
 
    return result;
}

Перекрестные ссылки am_Players, max_resources_amount и max_tower_height.

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

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

CalculateCardPower()

int CalculateCardPower	(	ArcomagePlayer *	player,
		ArcomagePlayer *	enemy,
		ArcomageCard *	pCard,
		int	mastery
	)

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

                                                         {
    enum V_IND {
        P_TOWER_M10,
        P_WALL_M10,
        E_TOWER,
        E_WALL,
        E_BUILDINGS,
        E_QUARRY,
        E_MAGIC,
        E_ZOO,
        E_RES,
        V_INDEX_MAX
    };
 
    // mastery coeffs
    // base mastery focus on growing walls + tower
    // second level high priority on resource gen
    const int mastery_coeff[V_INDEX_MAX][2] = {
        {10, 5},  // P_TOWER_M10
        {2, 1},   // P_WALL_M10
        {1, 10},  // E_TOWER
        {1, 3},   // E_WALL
        {1, 7},   // E_BUILDINGS
        {1, 5},   // E_QUARRY
        {1, 40},  // E_MAGIC
        {1, 40},  // E_ZOO
        {1, 2}    // E_RES
    };
 
    int card_power = 0;
    int element_power = 0;
 
    if (pCard->to_player_tower == 99 || pCard->to_pl_enm_tower == 99 ||
        pCard->to_player_tower2 == 99 || pCard->to_pl_enm_tower2 == 99) {
        element_power = enemy->tower_height - player->tower_height;
    } else {
        element_power = pCard->to_player_tower + pCard->to_pl_enm_tower +
                        pCard->to_player_tower2 + pCard->to_pl_enm_tower2;
    }
 
    if (player->tower_height >= 10) {
        card_power += mastery_coeff[P_TOWER_M10][mastery] * element_power;
    } else {
        card_power += 20 * element_power;
    }
 
    if (pCard->to_player_wall == 99 || pCard->to_pl_enm_wall == 99 ||
        pCard->to_player_wall2 == 99 || pCard->to_pl_enm_wall2 == 99) {
        element_power = enemy->wall_height - player->wall_height;
    } else {
        element_power = pCard->to_player_wall + pCard->to_pl_enm_wall +
                        pCard->to_player_wall2 + pCard->to_pl_enm_wall2;
    }
 
    if (player->wall_height >= 10) {
        card_power += mastery_coeff[P_WALL_M10][mastery] * element_power;  // 1
    } else {
        card_power += 5 * element_power;
    }
 
    card_power +=
        7 * (pCard->to_player_buildings + pCard->to_pl_enm_buildings +
             pCard->to_player_buildings2 + pCard->to_pl_enm_buildings2);
 
    if (pCard->to_player_quarry_lvl == 99 ||
        pCard->to_pl_enm_quarry_lvl == 99 ||
        pCard->to_player_quarry_lvl2 == 99 ||
        pCard->to_pl_enm_quarry_lvl2 == 99) {
        element_power = enemy->quarry_level - player->quarry_level;
    } else {
        element_power =
            pCard->to_player_quarry_lvl + pCard->to_pl_enm_quarry_lvl +
            pCard->to_player_quarry_lvl2 + pCard->to_pl_enm_quarry_lvl;
    }
 
    card_power += 40 * element_power;
 
    if (pCard->to_player_magic_lvl == 99 || pCard->to_pl_enm_magic_lvl == 99 ||
        pCard->to_player_magic_lvl2 == 99 ||
        pCard->to_pl_enm_magic_lvl2 == 99) {
        element_power = enemy->magic_level - player->magic_level;
    } else {
        element_power =
            pCard->to_player_magic_lvl + pCard->to_pl_enm_magic_lvl +
            pCard->to_player_magic_lvl2 + pCard->to_pl_enm_magic_lvl2;
    }
    card_power += 40 * element_power;
 
    if (pCard->to_player_zoo_lvl == 99 || pCard->to_pl_enm_zoo_lvl == 99 ||
        pCard->to_player_zoo_lvl2 == 99 || pCard->to_pl_enm_zoo_lvl2 == 99) {
        element_power = enemy->zoo_level - player->zoo_level;
    } else {
        element_power = pCard->to_player_zoo_lvl + pCard->to_pl_enm_zoo_lvl +
                        pCard->to_player_zoo_lvl2 + pCard->to_pl_enm_zoo_lvl2;
    }
    card_power += 40 * element_power;
 
    if (pCard->to_player_bricks == 99 || pCard->to_pl_enm_bricks == 99 ||
        pCard->to_player_bricks2 == 99 || pCard->to_pl_enm_bricks2 == 99) {
        element_power = enemy->resource_bricks - player->resource_bricks;
    } else {
        element_power = pCard->to_player_bricks + pCard->to_pl_enm_bricks +
                        pCard->to_player_bricks2 + pCard->to_pl_enm_bricks2;
    }
    card_power += 2 * element_power;
 
    if (pCard->to_player_gems == 99 || pCard->to_pl_enm_gems == 99 ||
        pCard->to_player_gems2 == 99 || pCard->to_pl_enm_gems2 == 99) {
        element_power = enemy->resource_gems - player->resource_gems;
    } else {
        element_power = pCard->to_player_gems + pCard->to_pl_enm_gems +
                        pCard->to_player_gems2 + pCard->to_pl_enm_gems2;
    }
    card_power += 2 * element_power;
 
    if (pCard->to_player_beasts == 99 || pCard->to_pl_enm_beasts == 99 ||
        pCard->to_player_beasts2 == 99 || pCard->to_pl_enm_beasts2 == 99) {
        element_power = enemy->resource_beasts - player->resource_beasts;
    } else {
        element_power = pCard->to_player_beasts + pCard->to_pl_enm_beasts +
                        pCard->to_player_beasts2 + pCard->to_pl_enm_beasts2;
    }
    card_power += 2 * element_power;
 
    if (pCard->to_enemy_tower == 99 || pCard->to_enemy_tower2 == 99) {
        element_power = player->tower_height - enemy->tower_height;
    } else {
        element_power = -(pCard->to_enemy_tower + pCard->to_enemy_tower2);
    }
    card_power += mastery_coeff[E_TOWER][mastery] * element_power;
 
    if (pCard->to_enemy_wall == 99 || pCard->to_enemy_wall2 == 99) {
        element_power = player->wall_height - enemy->wall_height;
    } else {
        element_power = -(pCard->to_enemy_wall + pCard->to_enemy_wall2);
    }
    card_power += mastery_coeff[E_WALL][mastery] * element_power;
 
    card_power -= mastery_coeff[E_BUILDINGS][mastery] *
                  (pCard->to_enemy_buildings + pCard->to_enemy_buildings2);
 
    if (pCard->to_enemy_quarry_lvl == 99 || pCard->to_enemy_quarry_lvl2 == 99) {
        element_power = player->quarry_level - enemy->quarry_level;  // 5
    } else {
        element_power =
            -(pCard->to_enemy_quarry_lvl + pCard->to_enemy_quarry_lvl2);  // 5
    }
    card_power += mastery_coeff[E_QUARRY][mastery] * element_power;
 
    if (pCard->to_enemy_magic_lvl == 99 || pCard->to_enemy_magic_lvl2 == 99) {
        element_power = player->magic_level - enemy->magic_level;  // 40
    } else {
        element_power =
            -(pCard->to_enemy_magic_lvl + pCard->to_enemy_magic_lvl2);
    }
    card_power += mastery_coeff[E_MAGIC][mastery] * element_power;
 
    if (pCard->to_enemy_zoo_lvl == 99 || pCard->to_enemy_zoo_lvl2 == 99) {
        element_power = player->zoo_level - enemy->zoo_level;  // 40
    } else {
        element_power = -(pCard->to_enemy_zoo_lvl + pCard->to_enemy_zoo_lvl2);
    }
    card_power += mastery_coeff[E_ZOO][mastery] * element_power;
 
    if (pCard->to_enemy_bricks == 99 || pCard->to_enemy_bricks2 == 99) {
        element_power = player->resource_bricks - enemy->resource_bricks;  // 2
    } else {
        element_power = -(pCard->to_enemy_bricks + pCard->to_enemy_bricks2);
    }
    card_power += mastery_coeff[E_RES][mastery] * element_power;
 
    if (pCard->to_enemy_gems == 99 || pCard->to_enemy_gems2 == 99) {
        element_power = player->resource_gems - enemy->resource_gems;  // 2
    } else {
        element_power = -(pCard->to_enemy_gems + pCard->to_enemy_gems2);
    }
    card_power += mastery_coeff[E_RES][mastery] * element_power;
 
    if (pCard->to_enemy_beasts == 99 || pCard->to_enemy_beasts2 == 99) {
        element_power = player->resource_beasts - enemy->resource_beasts;  // 2
    } else {
        element_power = -(pCard->to_enemy_beasts + pCard->to_enemy_beasts2);
    }
    card_power += mastery_coeff[E_RES][mastery] * element_power;
 
    if (pCard->field_30 || pCard->field_4D) {
        card_power *= 10;
    }
 
    if (pCard->card_resource_type == 1) {
        element_power = player->resource_bricks - pCard->needed_bricks;
    } else if (pCard->card_resource_type == 2) {
        element_power = player->resource_gems - pCard->needed_gems;
    } else if (pCard->card_resource_type == 3) {
        element_power = player->resource_beasts - pCard->needed_beasts;
    }
    if (element_power > 3) {
        element_power = 3;
    }
    card_power += 5 * element_power;
 
    if (enemy->tower_height <= pCard->to_enemy_tower2 + pCard->to_enemy_tower) {
        card_power += 9999;
    }
 
    if (pCard->to_enemy_tower2 + pCard->to_enemy_tower + pCard->to_enemy_wall +
            pCard->to_enemy_wall2 + pCard->to_enemy_buildings +
            pCard->to_enemy_buildings2 >=
        enemy->wall_height + enemy->tower_height) {
        card_power += 9999;
    }
 
    if ((pCard->to_player_tower2 + pCard->to_pl_enm_tower2 +
         pCard->to_player_tower + pCard->to_pl_enm_tower +
         player->tower_height) >= max_tower_height) {
        card_power += 9999;
    }
 
    return card_power;
}

Перекрестные ссылки ArcomageCard::card_resource_type, ArcomageCard::field_30, ArcomageCard::field_4D, ArcomagePlayer::magic_level, max_tower_height, ArcomageCard::needed_beasts, ArcomageCard::needed_bricks, ArcomageCard::needed_gems, ArcomagePlayer::quarry_level, ArcomagePlayer::resource_beasts, ArcomagePlayer::resource_bricks, ArcomagePlayer::resource_gems, ArcomageCard::to_enemy_beasts, ArcomageCard::to_enemy_beasts2, ArcomageCard::to_enemy_bricks, ArcomageCard::to_enemy_bricks2, ArcomageCard::to_enemy_buildings, ArcomageCard::to_enemy_buildings2, ArcomageCard::to_enemy_gems, ArcomageCard::to_enemy_gems2, ArcomageCard::to_enemy_magic_lvl, ArcomageCard::to_enemy_magic_lvl2, ArcomageCard::to_enemy_quarry_lvl, ArcomageCard::to_enemy_quarry_lvl2, ArcomageCard::to_enemy_tower, ArcomageCard::to_enemy_tower2, ArcomageCard::to_enemy_wall, ArcomageCard::to_enemy_wall2, ArcomageCard::to_enemy_zoo_lvl, ArcomageCard::to_enemy_zoo_lvl2, ArcomageCard::to_pl_enm_beasts, ArcomageCard::to_pl_enm_beasts2, ArcomageCard::to_pl_enm_bricks, ArcomageCard::to_pl_enm_bricks2, ArcomageCard::to_pl_enm_buildings, ArcomageCard::to_pl_enm_buildings2, ArcomageCard::to_pl_enm_gems, ArcomageCard::to_pl_enm_gems2, ArcomageCard::to_pl_enm_magic_lvl, ArcomageCard::to_pl_enm_magic_lvl2, ArcomageCard::to_pl_enm_quarry_lvl, ArcomageCard::to_pl_enm_quarry_lvl2, ArcomageCard::to_pl_enm_tower, ArcomageCard::to_pl_enm_tower2, ArcomageCard::to_pl_enm_wall, ArcomageCard::to_pl_enm_wall2, ArcomageCard::to_pl_enm_zoo_lvl, ArcomageCard::to_pl_enm_zoo_lvl2, ArcomageCard::to_player_beasts, ArcomageCard::to_player_beasts2, ArcomageCard::to_player_bricks, ArcomageCard::to_player_bricks2, ArcomageCard::to_player_buildings, ArcomageCard::to_player_buildings2, ArcomageCard::to_player_gems, ArcomageCard::to_player_gems2, ArcomageCard::to_player_magic_lvl, ArcomageCard::to_player_magic_lvl2, ArcomageCard::to_player_quarry_lvl, ArcomageCard::to_player_quarry_lvl2, ArcomageCard::to_player_tower, ArcomageCard::to_player_tower2, ArcomageCard::to_player_wall, ArcomageCard::to_player_wall2, ArcomageCard::to_player_zoo_lvl, ArcomageCard::to_player_zoo_lvl2, ArcomagePlayer::tower_height, ArcomagePlayer::wall_height и ArcomagePlayer::zoo_level.

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

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

PlayerTurn()

char PlayerTurn

(

int

player_num

)

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

                                {
    Rect pSrcXYZW;
    Point pTargetXY;
    ArcomageGame_InputMSG get_message;
 
    // reset player turn
    opponents_turn = 0;
    num_actions_left = 0;
 
    // reset animations
    int animation_stage = 20;
    drawn_card_anim_cnt = 10;
    hide_card_anim_count = 5;
    discarded_card_id = -1;
    if (drawn_card_slot_index != -1) drawn_card_anim_start = 1;
 
    // timing and loop
    int frame_quant_time;
    bool break_loop = false;
    do {
        // frame limiter apprx 32fps 128 / 32 = 4
        do {
            frame_quant_time = (int)pEventTimer->Time() - (int)pArcomageGame->event_timer_time;
        } while (frame_quant_time < 4);
        pArcomageGame->event_timer_time = (int)pEventTimer->Time();
 
        // get input message
        if (pArcomageGame->force_am_exit) break_loop = true;
        ArcomageGame::MsgLoop(0, &get_message);
        switch (get_message.am_input_type) {
            case 2:  // unkown ??
                if (get_message.field_4 == 129 && get_message.am_input_key == 1) {
                    pAudioPlayer->StopChannels(-1, -1);
                    num_actions_left = 0;
                    break_loop = true;
                    pArcomageGame->force_am_exit = 1;
                }
                break;
            case 9:  // toggle fullscreen
                pArcomageGame->force_redraw_1 = 1;
                break;
            case 10:  // hit escape key
                if (pArcomageGame->check_exit == 1) {
                    pAudioPlayer->StopChannels(-1, -1);
                    pArcomageGame->GameOver = 1;
                    pArcomageGame->uGameWinner = 2;
                    pArcomageGame->Victory_type = -2;
                    break_loop = true;
                    pArcomageGame->force_am_exit = 1;
                } else {
                    pArcomageGame->check_exit = 1;
                    pArcomageGame->force_redraw_1 = 1;
                }
                break;
        }
 
        // time to start the AIs turn
        if (am_Players[current_player_num].IsHisTurn != 1 && !opponents_turn &&
            !playdiscard_anim_start && !drawn_card_anim_start) {
            if (hide_card_anim_start) hide_card_anim_runnning = 1;
            OpponentsAITurn(current_player_num);
            playdiscard_anim_start = 1;
        }
 
        if (drawn_card_slot_index != -1 && drawn_card_anim_cnt > 10) drawn_card_anim_cnt = 10;
 
        if (playdiscard_anim_start || drawn_card_anim_start || am_Players[current_player_num].IsHisTurn != 1) {
            // player cant act
            pArcomageGame->force_redraw_1 = 1;
 
            // card drawing animation
            if (drawn_card_anim_start) {
                --drawn_card_anim_cnt;
                if (drawn_card_anim_cnt < 0) {
                    drawn_card_anim_start = 0;
                    drawn_card_anim_cnt = 10;
                    break_loop = false;
                    if (GetPlayerHandCardCount(current_player_num) <= minimum_cards_at_hand) {
                        GetNextCardFromDeck(current_player_num);
                    }
                }
            }
 
            // card played/ discarded animation
            if (playdiscard_anim_start) {
                --animation_stage;
                if (animation_stage < 0) {
                    if (num_actions_left > 1) {
                        --num_actions_left;
                        opponents_turn = 0;
                    } else {
                        break_loop = true;
                    }
                    playdiscard_anim_start = 0;
                    animation_stage = 20;
                }
            }
        } else {
            // can play cards
            if (need_to_discard_card) {
                // any mouse - try and discard
                if ((get_message.am_input_type == 7 || get_message.am_input_type == 8) && DiscardCard(player_num, current_card_slot_index)) {
                    if (hide_card_anim_start) hide_card_anim_runnning = 1;
                    if (num_cards_to_discard > 0) {
                        --num_cards_to_discard;
                        need_to_discard_card = (GetPlayerHandCardCount(player_num) > minimum_cards_at_hand);
                    }
                    playdiscard_anim_start = 1;
                }
            } else {
                if (get_message.am_input_type == 7) {
                    // left mouse - try and play card
                    if (PlayCard(player_num, current_card_slot_index)) {
                        playdiscard_anim_start = 1;
                        if (hide_card_anim_start) hide_card_anim_runnning = 1;
                    }
                }
                if (get_message.am_input_type == 8) {
                    // right mouse - try and discard card
                    if (DiscardCard(player_num, current_card_slot_index)) {
                        playdiscard_anim_start = 1;
                        if (hide_card_anim_start) hide_card_anim_runnning = 1;
                    }
                }
            }
        }
 
        // if the hover rectangle has moved redraw
        if (Card_Hover_Index != DrawCardsRectangles(player_num)) {
            Card_Hover_Index = DrawCardsRectangles(player_num);
            pArcomageGame->force_redraw_1 = 1;
        }
 
        // do we need to draw
        if (pArcomageGame->force_redraw_1) {
            DrawGameUI(animation_stage);
            pArcomageGame->force_redraw_1 = 0;
        }
    } while (!break_loop);
 
    return num_actions_left > 0;
}

Перекрестные ссылки ArcomageGame_InputMSG::am_input_key, ArcomageGame_InputMSG::am_input_type, am_Players, Card_Hover_Index, ArcomageGame::check_exit, current_card_slot_index, current_player_num, DiscardCard(), discarded_card_id, DrawCardsRectangles(), DrawGameUI(), drawn_card_anim_cnt, drawn_card_anim_start, drawn_card_slot_index, ArcomageGame::event_timer_time, ArcomageGame_InputMSG::field_4, ArcomageGame::force_am_exit, ArcomageGame::force_redraw_1, ArcomageGame::GameOver, GetNextCardFromDeck(), GetPlayerHandCardCount(), hide_card_anim_count, hide_card_anim_runnning, hide_card_anim_start, minimum_cards_at_hand, ArcomageGame::MsgLoop(), need_to_discard_card, num_actions_left, num_cards_to_discard, opponents_turn, OpponentsAITurn(), pArcomageGame, pAudioPlayer, pEventTimer, PlayCard(), playdiscard_anim_start, AudioPlayer::StopChannels(), Timer::Time(), ArcomageGame::uGameWinner и ArcomageGame::Victory_type.

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

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

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

DrawGameUI()

void DrawGameUI

(

int

animation_stage

)

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

                                     {
    // set copy image location
    pArcomageGame->pBlit_Copy_pixels = pArcomageGame->pSpritesPixels;
    // draw background
    render->DrawTextureNew(0, 0, pArcomageGame->pGameBackground);
 
    // draw gui items
    DrawRectanglesForText();
    DrawCards();          //рисуем карты
    DrawPlayersTowers();  //рисуем башню
    DrawPlayersWall();    //рисуем стену
    DrawPlayersText();    //рисуем текст
 
    DrawCardAnimation(animation_stage);
    current_card_slot_index = DrawCardsRectangles(current_player_num);
 
    // update explosion effects
    for (int i = 0; i < 10; ++i) {
        if (am_effects_array[i].have_effect) am_effects_array[i].explosion_eff->UpdateEffect();
    }
    DrawSparks();
 
    // draw texts
    if (pArcomageGame->check_exit) {
        String t = "Are you sure you want to resign?\n    Press ESC again to confirm";
        Point p(200, 200);
        am_DrawText(t, &p);
    }
    if (pArcomageGame->GameOver) {
        String t = "Game Over!";
        Point p(270, 200);
        am_DrawText(t, &p);
    }
 
    render->Present();
}

Перекрестные ссылки am_DrawText(), am_effects_array, ArcomageGame::check_exit, current_card_slot_index, current_player_num, DrawCardAnimation(), DrawCards(), DrawCardsRectangles(), DrawPlayersText(), DrawPlayersTowers(), DrawPlayersWall(), DrawRectanglesForText(), DrawSparks(), am_effects_struct::explosion_eff, ArcomageGame::GameOver, pArcomageGame, ArcomageGame::pBlit_Copy_pixels, ArcomageGame::pGameBackground, ArcomageGame::pSpritesPixels, render и explosion_effect_struct::UpdateEffect().

Используется в ArcomageGame::Loop() и PlayerTurn().

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

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

DrawSparks()

void DrawSparks

(

)

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

                  {
    int rgb_pixel_color;
 
    for (int i = 0; i < 10; ++i) {
        if (am_effects_array[i].have_effect &&
            (am_effects_array[i].explosion_eff->IsEffectActive() == 2)) {
            // scan and find extents of spark array
            bool first = 0;
            int xmin = -1;
            int xmax = -1;
            int ymin = -1;
            int ymax = -1;
            for (int j = 0; j < 150; ++j) {
                if (am_effects_array[i].effect_sparks[j].spark_remaining_life > 0) {
                    if (first == 0) {
                        if (am_effects_array[i].effect_sparks[j].spark_position.x >= 0 && am_effects_array[i].effect_sparks[j].spark_position.y >= 0) {
                            if (am_effects_array[i].effect_sparks[j].spark_position.x <= 639 && am_effects_array[i].effect_sparks[j].spark_position.y <= 479) {
                                xmin = xmax = am_effects_array[i].effect_sparks[j].spark_position.x;
                                ymin = ymax = am_effects_array[i].effect_sparks[j].spark_position.y;
                                first = 1;
                            }
                        }
                    } else {
                        if (am_effects_array[i].effect_sparks[j].spark_position.x >= 0 && am_effects_array[i].effect_sparks[j].spark_position.y >= 0) {
                            if (am_effects_array[i].effect_sparks[j].spark_position.x <= 639 && am_effects_array[i].effect_sparks[j].spark_position.y <= 479) {
                                if (am_effects_array[i].effect_sparks[j].spark_position.x < xmin)
                                    xmin = am_effects_array[i].effect_sparks[j].spark_position.x;
                                if (am_effects_array[i].effect_sparks[j].spark_position.x > xmax)
                                    xmax = am_effects_array[i].effect_sparks[j].spark_position.x;
                                if (am_effects_array[i].effect_sparks[j].spark_position.y < ymin)
                                    ymin = am_effects_array[i].effect_sparks[j].spark_position.y;
                                if (am_effects_array[i].effect_sparks[j].spark_position.y > ymax)
                                    ymax = am_effects_array[i].effect_sparks[j].spark_position.y;
                            }
                        }
                    }
                }
            }
 
            // increase extents to cover larger square particle drawing
            xmax +=2;
            ymax +=2;
            uint width = xmax - xmin;
            uint height = ymax - ymin;
 
            if (width && height) {
                // create temp image
                Image* temp = Image::Create(width, height, IMAGE_FORMAT_A8R8G8B8);
                uint32_t* temppix = (uint32_t*)temp->GetPixels(IMAGE_FORMAT_A8R8G8B8);
 
                // set the pixel color
                rgb_pixel_color = 0xFF00FF00;  // green
                if (!am_effects_array[i].effect_sign) rgb_pixel_color = 0xFFFF0000;  // red
 
                // draw pixels to image
                for (int j = 0; j < 150; ++j) {
                    if (am_effects_array[i].effect_sparks[j].spark_remaining_life > 0) {
                        // check limits
                        if (am_effects_array[i].effect_sparks[j].spark_position.x >= 0 && am_effects_array[i].effect_sparks[j].spark_position.y >= 0) {
                            if (am_effects_array[i].effect_sparks[j].spark_position.x <= 639 && am_effects_array[i].effect_sparks[j].spark_position.y <= 479) {
                                uint x = am_effects_array[i].effect_sparks[j].spark_position.x - xmin;
                                uint y = am_effects_array[i].effect_sparks[j].spark_position.y - ymin;
 
                                if (j % 2) {
                                    // draw single pixel
                                    temppix[x + y * width] = rgb_pixel_color;
                                } else {
                                    // draw square
                                    temppix[x + y * width] = rgb_pixel_color;
                                    temppix[((x + 1) + y * width)] = rgb_pixel_color;
                                    temppix[(x + (y+1) * width)] = rgb_pixel_color;
                                    temppix[((x + 1) + (y+1) * width)] = rgb_pixel_color;
                                }
                            }
                        }
                    }
                }
 
                // draw created image to xmin,ymin
                render->DrawTextureAlphaNew(xmin / 640., ymin / 480., temp);
                temp->Release();
            }
        }
    }
}

Перекрестные ссылки am_effects_array, Image::Create(), am_effects_struct::effect_sparks, Image::GetPixels(), IMAGE_FORMAT_A8R8G8B8, Image::Release(), render, spark_point_struct::spark_position, Point::x и Point::y.

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

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

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

DrawRectanglesForText()

void DrawRectanglesForText

(

)

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

                             {
    Rect pSrcRect;
    Point pTargetXY;
 
    // resources rectangles
    pSrcRect.x = 765;
    pSrcRect.y = 0;
    pSrcRect.z = 843;
    pSrcRect.w = 216;
 
    pTargetXY.x = 8;
    pTargetXY.y = 56;
    render->am_Blt_Chroma(&pSrcRect, &pTargetXY, 0, 2);
 
    pTargetXY.x = 555;
    pTargetXY.y = 56;
    render->am_Blt_Chroma(&pSrcRect, &pTargetXY, 0, 2);
 
    // players name rectangle
    pSrcRect.x = 283;
    pSrcRect.y = 166;
    pSrcRect.z = 361;
    pSrcRect.w = 190;
    pTargetXY.x = 8;
    pTargetXY.y = 13;
    render->am_Blt_Chroma(&pSrcRect, &pTargetXY, pArcomageGame->field_54, 2);
 
    pTargetXY.x = 555;
    pTargetXY.y = 13;
    render->am_Blt_Chroma(&pSrcRect, &pTargetXY, pArcomageGame->field_54, 2);
 
    // tower height rectangle
    pSrcRect.x = 234;
    pSrcRect.y = 166;
    pSrcRect.z = 283;
    pSrcRect.w = 190;
    pTargetXY.x = 100;
    pTargetXY.y = 296;
    render->am_Blt_Chroma(&pSrcRect, &pTargetXY, pArcomageGame->field_54, 2);
 
    pTargetXY.x = 492;
    pTargetXY.y = 296;
    render->am_Blt_Chroma(&pSrcRect, &pTargetXY, pArcomageGame->field_54, 2);
 
    // wall height rectangle
    pSrcRect.x = 192;
    pSrcRect.y = 166;
    pSrcRect.z = 234;
    pSrcRect.w = 190;
    pTargetXY.x = 168;
    pTargetXY.y = 296;
    render->am_Blt_Chroma(&pSrcRect, &pTargetXY, pArcomageGame->field_54, 2);
 
    pTargetXY.x = 430;
    pTargetXY.y = 296;
    render->am_Blt_Chroma(&pSrcRect, &pTargetXY, pArcomageGame->field_54, 2);
}

Перекрестные ссылки ArcomageGame::field_54, pArcomageGame, render, Rect::w, Rect::x, Point::x, Rect::y, Point::y и Rect::z.

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

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

DrawPlayersText()

void DrawPlayersText

(

)

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

                       {
    int res_value;
    char text_buff[32];
    Point text_position;
 
    if (need_to_discard_card) {
        // DISCARD A CARD
        strcpy(text_buff, localization->GetString(266));
        text_position.x = 320 - pArcomageGame->pfntArrus->GetLineWidth(text_buff) / 2;
        text_position.y = 306;
        am_DrawText(text_buff, &text_position);
    }
 
    // player names
    strcpy(text_buff, am_Players[0].pPlayerName);
    if (!current_player_num) strcat(text_buff, "***");
    text_position.x = 47 - pArcomageGame->pfntComic->GetLineWidth(text_buff) / 2;
    text_position.y = 21;
    am_DrawText(text_buff, &text_position);
 
    strcpy(text_buff, am_Players[1].pPlayerName);
    if (current_player_num == 1) strcat(text_buff, "***");
    text_position.x = 595 - pArcomageGame->pfntComic->GetLineWidth(text_buff) / 2;
    text_position.y = 21;
    am_DrawText(text_buff, &text_position);
 
    // tower heights
    am_IntToString(am_Players[0].tower_height, text_buff);
    text_position.x = 123 - pArcomageGame->pfntComic->GetLineWidth(text_buff) / 2;
    text_position.y = 305;
    am_DrawText(text_buff, &text_position);
 
    am_IntToString(am_Players[1].tower_height, text_buff);
    text_position.x = 515 - pArcomageGame->pfntComic->GetLineWidth(text_buff) / 2;
    text_position.y = 305;
    am_DrawText(text_buff, &text_position);
 
    // wall heights
    am_IntToString(am_Players[0].wall_height, text_buff);
    text_position.x = 188 - pArcomageGame->pfntComic->GetLineWidth(text_buff) / 2;
    text_position.y = 305;
    am_DrawText(text_buff, &text_position);
 
    am_IntToString(am_Players[1].wall_height, text_buff);
    text_position.x = 451 - pArcomageGame->pfntComic->GetLineWidth(text_buff) / 2;
    text_position.y = 305;
    am_DrawText(text_buff, &text_position);
 
    // quarry levels
    res_value = am_Players[0].quarry_level;
    if (use_start_bonus) res_value = am_Players[0].quarry_level + quarry_bonus;
    text_position.x = 14;
    text_position.y = 92;
    DrawPlayerLevels(StringFromInt(res_value), &text_position);
 
    res_value = am_Players[1].quarry_level;
    if (use_start_bonus) res_value = am_Players[1].quarry_level + quarry_bonus;
    text_position.y = 92;
    text_position.x = 561;
    DrawPlayerLevels(StringFromInt(res_value), &text_position);
 
    // magic levels
    res_value = am_Players[0].magic_level;
    if (use_start_bonus) res_value = am_Players[0].magic_level + magic_bonus;
    text_position.y = 164;
    text_position.x = 14;
    DrawPlayerLevels(StringFromInt(res_value), &text_position);
 
    res_value = am_Players[1].magic_level;
    if (use_start_bonus) res_value = am_Players[1].magic_level + magic_bonus;
    text_position.y = 164;
    text_position.x = 561;
    DrawPlayerLevels(StringFromInt(res_value), &text_position);
 
    // zoo levels
    res_value = am_Players[0].zoo_level;
    if (use_start_bonus) res_value = am_Players[0].zoo_level + zoo_bonus;
    text_position.y = 236;
    text_position.x = 14;
    DrawPlayerLevels(StringFromInt(res_value), &text_position);
 
    res_value = am_Players[1].zoo_level;
    if (use_start_bonus) res_value = am_Players[1].zoo_level + zoo_bonus;
    text_position.y = 236;
    text_position.x = 561;
    DrawPlayerLevels(StringFromInt(res_value), &text_position);
 
    // bricks
    text_position.y = 114;
    text_position.x = 10;
    DrawBricksCount(StringFromInt(am_Players[0].resource_bricks), &text_position);
 
    text_position.x = 557;
    text_position.y = 114;
    DrawBricksCount(StringFromInt(am_Players[1].resource_bricks), &text_position);
 
    // gems
    text_position.x = 10;
    text_position.y = 186;
    DrawGemsCount(StringFromInt(am_Players[0].resource_gems), &text_position);
 
    text_position.x = 557;
    text_position.y = 186;
    DrawGemsCount(StringFromInt(am_Players[1].resource_gems), &text_position);
 
    // beasts
    text_position.x = 10;
    text_position.y = 258;
    DrawBeastsCount(StringFromInt(am_Players[0].resource_beasts), &text_position);
 
    text_position.x = 557;
    text_position.y = 258;
    DrawBeastsCount(StringFromInt(am_Players[1].resource_beasts), &text_position);
}

Перекрестные ссылки am_DrawText(), am_IntToString(), am_Players, current_player_num, DrawBeastsCount(), DrawBricksCount(), DrawGemsCount(), DrawPlayerLevels(), GUIFont::GetLineWidth(), Localization::GetString(), localization, magic_bonus, ArcomagePlayer::magic_level, need_to_discard_card, pArcomageGame, ArcomageGame::pfntArrus, ArcomageGame::pfntComic, quarry_bonus, ArcomagePlayer::quarry_level, StringFromInt(), use_start_bonus, Point::x, Point::y, zoo_bonus и ArcomagePlayer::zoo_level.

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

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

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

DrawPlayerLevels()

void DrawPlayerLevels	(	const String &	str,
		Point *	pXY
	)

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

                                                     {
    Rect pSrcRect;
    Point pTargetPoint;
 
    pTargetPoint.x = pXY->x;
    pTargetPoint.y = pXY->y;
    for (auto i = str.begin(); i != str.end(); ++i) {
        // get each digit
        if (*i) {
            // calc position in sprite layout
            int v7 = 22 * *i;
            pSrcRect.z = v7 - 842;
            pSrcRect.x = v7 - 864;
            pSrcRect.y = 190;
            pSrcRect.w = 207;
            // draw digit
            render->am_Blt_Chroma(&pSrcRect, &pTargetPoint, pArcomageGame->field_54, 1);
            pTargetPoint.x += 22;
        }
    }
}

Перекрестные ссылки ArcomageGame::field_54, pArcomageGame, render, Rect::w, Rect::x, Point::x, Rect::y, Point::y и Rect::z.

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

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

DrawBricksCount()

void DrawBricksCount	(	const String &	str,
		Point *	pXY
	)

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

                                                    {
    Rect pSrcRect;
    Point pTargetPoint;
 
    pTargetPoint.x = pXY->x;
    pTargetPoint.y = pXY->y;
    for (auto i = str.begin(); i != str.end(); ++i) {
        // get each digit
        if (*i) {
            // calc position in sprite layout
            int v7 = 13 * *i;
            pSrcRect.x = v7 - 370;
            pSrcRect.z = v7 - 357;
            pSrcRect.y = 128;
            pSrcRect.w = 138;
            // draw digit
            render->am_Blt_Chroma(&pSrcRect, &pTargetPoint, 0, 2);
            pTargetPoint.x += 13;
        }
    }
}

Перекрестные ссылки render, Rect::w, Rect::x, Point::x, Rect::y, Point::y и Rect::z.

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

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

DrawGemsCount()

void DrawGemsCount	(	const String &	str,
		Point *	pXY
	)

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

                                                  {
    Rect pSrcRect;
    Point pTargetPoint;
 
    pTargetPoint.x = pXY->x;
    pTargetPoint.y = pXY->y;
    for (auto i = str.begin(); i != str.end(); ++i) {
        // get each digit
        if (*i) {
            // calc position in sprite layout
            int  v7 = 13 * *i;
            pSrcRect.x = v7 - 370;
            pSrcRect.z = v7 - 357;
            pSrcRect.y = 138;
            pSrcRect.w = 148;
            // draw digit
            render->am_Blt_Chroma(&pSrcRect, &pTargetPoint, 0, 2);
            pTargetPoint.x += 13;
        }
    }
}

Перекрестные ссылки render, Rect::w, Rect::x, Point::x, Rect::y, Point::y и Rect::z.

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

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

DrawBeastsCount()

void DrawBeastsCount	(	const String &	str,
		Point *	pXY
	)

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

                                                    {
    Rect pSrcRect;
    Point pTargetPoint;
 
    pTargetPoint.x = pXY->x;
    pTargetPoint.y = pXY->y;
    for (auto i = str.begin(); i != str.end(); ++i) {
        // get each digit
        if (*i) {
            // calc position in sprite layout
            int x_offset = 13 * *i;
            pSrcRect.x = x_offset - 370;
            pSrcRect.z = x_offset - 357;
            pSrcRect.y = 148;
            pSrcRect.w = 158;
            // draw digit
            render->am_Blt_Chroma(&pSrcRect, &pTargetPoint, 0, 2);
            pTargetPoint.x += 13;
        }
    }
}

Перекрестные ссылки render, Rect::w, Rect::x, Point::x, Rect::y, Point::y и Rect::z.

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

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

DrawPlayersTowers()

void DrawPlayersTowers

(

)

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

                         {
    Rect pSrcXYZW;
    Point pTargetXY;
 
    // draw player 0 tower
    int tower_height = am_Players[0].tower_height;
    // check limits
    if (tower_height > max_tower_height) tower_height = max_tower_height;
    pSrcXYZW.y = 0;
    pSrcXYZW.x = 892;
    pSrcXYZW.z = 937;
    // calc height ratio
    int tower_top = 200 * tower_height / max_tower_height;
    pSrcXYZW.w = tower_top;
    pTargetXY.x = 102;
    pTargetXY.y = 297 - tower_top;
    if (tower_height > 0) render->am_Blt_Chroma(&pSrcXYZW, &pTargetXY, 0, 2);  //стена башни
 
    // draw player 0 top
    pSrcXYZW.y = 0;
    pSrcXYZW.x = 384;
    pSrcXYZW.z = 452;
    pSrcXYZW.w = 94;
    pTargetXY.y = 203 - tower_top;
    pTargetXY.x = 91;
    render->am_Blt_Chroma(&pSrcXYZW, &pTargetXY, pArcomageGame->field_54, 2);  //верхушка башни
 
    // draw player 1 tower
    tower_height = am_Players[1].tower_height;
    // set limits
    if (tower_height > max_tower_height) tower_height = max_tower_height;
    // calc tower height ratio
    tower_top = 200 * tower_height / max_tower_height;
    pSrcXYZW.y = 0;
    pSrcXYZW.x = 892;
    pSrcXYZW.z = 937;
    pSrcXYZW.w = tower_top;
    pTargetXY.x = 494;
    pTargetXY.y = 297 - tower_top;
    if (tower_height > 0) render->am_Blt_Chroma(&pSrcXYZW, &pTargetXY, 0, 2);
 
    // draw tower 1 top
    pSrcXYZW.x = 384;
    pSrcXYZW.z = 452;
    pSrcXYZW.y = 94;
    pSrcXYZW.w = 188;
    pTargetXY.x = 483;
    pTargetXY.y = 203 - tower_top;
    render->am_Blt_Chroma(&pSrcXYZW, &pTargetXY, pArcomageGame->field_54, 2);
}

Перекрестные ссылки am_Players, ArcomageGame::field_54, max_tower_height, pArcomageGame, render, ArcomagePlayer::tower_height, Rect::w, Rect::x, Point::x, Rect::y, Point::y и Rect::z.

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

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

DrawPlayersWall()

void DrawPlayersWall

(

)

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

                       {
    Rect pSrcXYZW;
    Point pTargetXY;
 
    // draw player 0 wall
    int player_0_h = am_Players[0].wall_height;
    // fix limit
    if (player_0_h > 100) player_0_h = 100;
 
    // is there any wall the draw
    if (player_0_h > 0) {
        pSrcXYZW.y = 0;
        pSrcXYZW.x = 843;
        // calc ratio of wall to draw
        int player_0_pixh = 200 * player_0_h / 100;
        pSrcXYZW.z = 867;
        pSrcXYZW.w = player_0_pixh;
        pTargetXY.x = 177;
        pTargetXY.y = 297 - player_0_pixh;
        render->am_Blt_Chroma(&pSrcXYZW, &pTargetXY, pArcomageGame->field_54, 2);
    }
 
    // draw player 1 wall
    int player_1_h = am_Players[1].wall_height;
    if (player_1_h > 100) player_1_h = 100;
    if (player_1_h > 0) {
        pSrcXYZW.y = 0;
        pSrcXYZW.x = 843;
        int player_1_pixh = 200 * player_1_h / 100;
        pSrcXYZW.z = 867;
        pSrcXYZW.w = player_1_pixh;
        pTargetXY.x = 439;
        pTargetXY.y = 297 - player_1_pixh;
        render->am_Blt_Chroma(&pSrcXYZW, &pTargetXY, pArcomageGame->field_54, 2);
    }
}

Перекрестные ссылки am_Players, ArcomageGame::field_54, pArcomageGame, render, Rect::w, ArcomagePlayer::wall_height, Rect::x, Point::x, Rect::y, Point::y и Rect::z.

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

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

DrawCards()

void DrawCards

(

)

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

                 {
    // draw hand of current player and any cards on the table
    Rect pSrcXYZW;
    Point pTargetXY;
 
    // draw player hand
    int card_count = GetPlayerHandCardCount(current_player_num);
    pTargetXY.y = 327;
    int card_spacing = (window->GetWidth() - 96 * card_count) / (card_count + 1);
    pTargetXY.x = card_spacing;
 
    for (int card_slot = 0; card_slot < card_count; ++card_slot) {
        // shift card pos
        if (Player_Cards_Shift) {
            pTargetXY.x += am_Players[current_player_num].card_shift[card_slot].x;
            pTargetXY.y += am_Players[current_player_num].card_shift[card_slot].y;
        }
 
        if (am_Players[current_player_num].cards_at_hand[card_slot] == -1) {
            // need to acess another slot if card sent for animatoin
            ++card_count;
        } else if (card_slot != drawn_card_slot_index) {
            // draw back of card for opponents turn
            if (am_Players[current_player_num].IsHisTurn == 0 && See_Opponents_Cards == 0) {
                pSrcXYZW.x = 192;
                pSrcXYZW.z = 288;
                pSrcXYZW.y = 0;
                pSrcXYZW.w = 128;
                render->am_Blt_Chroma(&pSrcXYZW, &pTargetXY, 0, 2);  //рисуется оборотные стороны карт противника
            } else {
                pArcomageGame->GetCardRect(am_Players[current_player_num].cards_at_hand[card_slot], &pSrcXYZW);
                if (!CanCardBePlayed(current_player_num, card_slot)) {
                    // рисуются неактивные карты - greyed out
                    render->am_Blt_Chroma(&pSrcXYZW, &pTargetXY, 0, 0);
                } else {
                    render->am_Blt_Chroma(&pSrcXYZW, &pTargetXY, 0, 2);  //рисуются активные карты
                }
            }
        }
 
        // unshift by card pos
        if (Player_Cards_Shift) {
            pTargetXY.x -= am_Players[current_player_num].card_shift[card_slot].x;
            pTargetXY.y -= am_Players[current_player_num].card_shift[card_slot].y;
        }
 
        // shift draw postion along
        pTargetXY.x += card_spacing + 96;
    }
 
    //  draw shown cards on table
    for (int table_cards = 0; table_cards < 10; ++table_cards) {
        if (hide_card_anim_runnning == 0) {
            // cards stationary
            if (shown_cards[table_cards].uCardId != -1) {
                // draw card - greyed out
                pArcomageGame->GetCardRect(shown_cards[table_cards].uCardId, &pSrcXYZW);
                render->am_Blt_Chroma(&pSrcXYZW, &shown_cards[table_cards].hide_anim_pos, 0, 0);
            }
            if (shown_cards[table_cards].discarded != 0) {
                // draw discarded text
                pTargetXY.x = shown_cards[table_cards].hide_anim_pos.x + 12;
                pTargetXY.y = shown_cards[table_cards].hide_anim_pos.y + 40;
                pSrcXYZW.x = 843;
                pSrcXYZW.z = 916;
                pSrcXYZW.y = 200;
                pSrcXYZW.w = 216;
                render->am_Blt_Chroma(&pSrcXYZW, &pTargetXY, pArcomageGame->field_54, 2);
            }
        } else if (hide_card_anim_count <= 0) {
            // animation finished
            if (table_cards == 9) {
                // reset anim at last card
                hide_card_anim_runnning = 0;
                hide_card_anim_start = 0;
                hide_card_anim_count = 5;
            }
 
            // reset table slot
            shown_cards[table_cards].uCardId = -1;
            shown_cards[table_cards].hide_anim_pos.x = shown_cards[table_cards].table_pos.x;
            shown_cards[table_cards].hide_anim_pos.y = shown_cards[table_cards].table_pos.y;
            shown_cards[table_cards].discarded = 0;
        } else {
            // animation
            if (shown_cards[table_cards].uCardId != -1) {
                // update position and draw
                shown_cards[table_cards].hide_anim_pos.x += shown_cards[table_cards].hide_anim_spd.x;
                shown_cards[table_cards].hide_anim_pos.y += shown_cards[table_cards].hide_anim_spd.y;
                pArcomageGame->GetCardRect(shown_cards[table_cards].uCardId, &pSrcXYZW);
                render->am_Blt_Chroma(&pSrcXYZW, &shown_cards[table_cards].hide_anim_pos, 0, 0);
            }
        }
    }
 
    // update hide card anim
    if (hide_card_anim_runnning != 0) --hide_card_anim_count;
 
    // blank deck card
    pSrcXYZW.x = 192;
    pSrcXYZW.z = 288;
    pSrcXYZW.y = 0;
    pSrcXYZW.w = 128;
    pTargetXY.x = 120;
    pTargetXY.y = 18;
    render->am_Blt_Chroma(&pSrcXYZW, &pTargetXY, 0, 0);
}

Перекрестные ссылки am_Players, CanCardBePlayed(), ArcomagePlayer::card_shift, current_player_num, AcromageCardOnTable::discarded, drawn_card_slot_index, ArcomageGame::field_54, ArcomageGame::GetCardRect(), GetPlayerHandCardCount(), AcromageCardOnTable::hide_anim_pos, AcromageCardOnTable::hide_anim_spd, hide_card_anim_count, hide_card_anim_runnning, hide_card_anim_start, pArcomageGame, Player_Cards_Shift, render, See_Opponents_Cards, shown_cards, AcromageCardOnTable::table_pos, AcromageCardOnTable::uCardId, Rect::w, Rect::x, Point::x, sPoint::x, Rect::y, Point::y, sPoint::y и Rect::z.

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

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

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

DrawCardAnimation()

void DrawCardAnimation

(

int

a1

)

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

                                            {
    // draws any card currently in animation stage
    // draw - discard - play
 
    Rect pSrcXYZW;
    Point pTargetXY;
 
    // drawing card anim
    if (drawn_card_slot_index != -1) {
        if (drawn_card_anim_cnt >= 9) {
            // animation start so calcualte posiotn and speeds
            anim_card_pos_drawncard.y = 18;
            anim_card_pos_drawncard.x = 120;
            int card_count = GetPlayerHandCardCount(current_player_num);
            int card_spacing = (window->GetWidth() - (96 * card_count)) / (card_count + 1);
 
            int targetx = drawn_card_slot_index * (card_spacing + 96) + card_spacing;
            int targety = 327;
 
            if (Player_Cards_Shift) {
                targetx += am_Players[current_player_num].card_shift[drawn_card_slot_index].x;
                targety += am_Players[current_player_num].card_shift[drawn_card_slot_index].y;
            }
 
            anim_card_spd_drawncard.x = (targetx - (signed)anim_card_pos_drawncard.x) / 10;
            anim_card_spd_drawncard.y = (targety - (signed)anim_card_pos_drawncard.y) / 10;
 
            // move the card
            anim_card_pos_drawncard.y += anim_card_spd_drawncard.y;
            anim_card_pos_drawncard.x += anim_card_spd_drawncard.x;
 
            // draw the blank card at animation position
            pSrcXYZW.x = 192;
            pSrcXYZW.y = 0;
            pSrcXYZW.z = 288;
            pSrcXYZW.w = 128;
            render->am_Blt_Chroma(&pSrcXYZW, &anim_card_pos_drawncard, 0, 2);
        } else {
            // animation is running - update position and draw
            pSrcXYZW.x = 192;
            pSrcXYZW.y = 0;
            pSrcXYZW.z = 288;
            pSrcXYZW.w = 128;
            anim_card_pos_drawncard.x += anim_card_spd_drawncard.x;
            anim_card_pos_drawncard.y += anim_card_spd_drawncard.y;
            render->am_Blt_Chroma(&pSrcXYZW, &anim_card_pos_drawncard, 0, 2);
 
            // reset if animation is finished
            if (!drawn_card_anim_cnt) drawn_card_slot_index = -1;
        }
    }
    // end drawing card from deck anim
 
    // discard card anim
    if (discarded_card_id != -1) {
        // anim runs 20 -> 10
        if (animation_stage <= 10) {
            if (animation_stage == 10) {
                // card has reached its destination - find first table slot
                int card_slot = 0;
                for (card_slot = 0; card_slot < 10; ++card_slot) {
                    if (shown_cards[card_slot].uCardId == -1) {
                        // set card to slot
                        shown_cards[card_slot].uCardId = discarded_card_id;
                        shown_cards[card_slot].discarded = 1;
                        break;
                    }
                }
 
                // update positiona and draw
                pArcomageGame->GetCardRect(discarded_card_id, &pSrcXYZW);
                pTargetXY.x = shown_cards[card_slot].table_pos.x;
                pTargetXY.y = shown_cards[card_slot].table_pos.y;
                render->am_Blt_Chroma(&pSrcXYZW, &pTargetXY, 0, 0);
 
                // reset discard anim
                discarded_card_id = -1;
            }
        } else {
            // update pos and draw
            pArcomageGame->GetCardRect(discarded_card_id, &pSrcXYZW);
            anim_card_pos_playdiscard.x += anim_card_spd_playdiscard.x;
            anim_card_pos_playdiscard.y += anim_card_spd_playdiscard.y;
            render->am_Blt_Chroma(&pSrcXYZW, &anim_card_pos_playdiscard, 0, 0);
        }
    }
    // end discard card anim
 
    // play card anim
    if (played_card_id != -1) {
        // 20 -> 16 move to play position
        if (animation_stage > 15.0) {
            // update positiona and draw
            pArcomageGame->GetCardRect(played_card_id, &pSrcXYZW);
            anim_card_pos_playdiscard.x += anim_card_spd_playdiscard.x;
            anim_card_pos_playdiscard.y += anim_card_spd_playdiscard.y;
            render->am_Blt_Chroma(&pSrcXYZW, &anim_card_pos_playdiscard, 0, 2);
            return;
        }
 
        // 15 -> 6 hold and play card
        if (animation_stage > 5) {
            if (animation_stage == 15) {
                // card arrived at centre - execute effects
                ApplyCardToPlayer(current_player_num, played_card_id);
            }
 
            // draw in centre
            pArcomageGame->GetCardRect(played_card_id, &pSrcXYZW);
            pTargetXY.x = 272;
            pTargetXY.y = 173;
            render->am_Blt_Chroma(&pSrcXYZW, &pTargetXY, 0, 2);
            return;
        }
 
        // 5 set up move to table positon
        if (animation_stage == 5.0) {
            // find slots and update speeds
            anim_card_pos_playdiscard.x = 272;
            anim_card_pos_playdiscard.y = 173;
            int v17;
            for (v17 = 0; v17 < 10; ++v17) {
                if (shown_cards[v17].uCardId == -1) break;
            }
            anim_card_spd_playdiscard.x = ((int)shown_cards[v17].table_pos.x - 272) / 5;
            anim_card_spd_playdiscard.y = ((int)shown_cards[v17].table_pos.y - 173) / 5;
 
            // draw card in position
            pArcomageGame->GetCardRect(played_card_id, &pSrcXYZW);
            pTargetXY.x = 272;
            pTargetXY.y = 173;
            render->am_Blt_Chroma(&pSrcXYZW, &pTargetXY, 0, 2);
            return;
        }
 
        // 4-> 1  move to table slot
        if (animation_stage > 0) {
            // update position and draw
            pArcomageGame->GetCardRect(played_card_id, &pSrcXYZW);
            anim_card_pos_playdiscard.x += anim_card_spd_playdiscard.x;
            anim_card_pos_playdiscard.y += anim_card_spd_playdiscard.y;
            render->am_Blt_Chroma(&pSrcXYZW, &anim_card_pos_playdiscard, 0, 0);
            return;
        }
 
        // 0 draw in table pos and reset
        if (animation_stage == 0) {
            // find free table slot
            int v19;
            for (v19 = 0; v19 < 10; ++v19) {
                if (shown_cards[v19].uCardId == -1) {
                    shown_cards[v19].uCardId = played_card_id;
                    break;
                }
            }
 
            // update position and draw
            pArcomageGame->GetCardRect(played_card_id, &pSrcXYZW);
            pTargetXY.x = shown_cards[v19].table_pos.x;
            pTargetXY.y = shown_cards[v19].table_pos.y;
            render->am_Blt_Chroma(&pSrcXYZW, &pTargetXY, 0, 0);
 
            // reset anim
            played_card_id = -1;
        }
    }
    // end play card anim
}

Перекрестные ссылки am_Players, anim_card_pos_drawncard, anim_card_pos_playdiscard, anim_card_spd_drawncard, anim_card_spd_playdiscard, ApplyCardToPlayer(), ArcomagePlayer::card_shift, current_player_num, AcromageCardOnTable::discarded, discarded_card_id, drawn_card_anim_cnt, drawn_card_slot_index, ArcomageGame::GetCardRect(), GetPlayerHandCardCount(), pArcomageGame, played_card_id, Player_Cards_Shift, render, shown_cards, AcromageCardOnTable::table_pos, AcromageCardOnTable::uCardId, Rect::w, Rect::x, Point::x, sPoint::x, Rect::y, Point::y, sPoint::y и Rect::z.

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

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

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

GetPlayerHandCardCount()

int GetPlayerHandCardCount

(

int

player_num

)

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

                                           {
    int card_count = 0;
    for (int i = 0; i < 10; ++i) {
        if (am_Players[player_num].cards_at_hand[i] != -1) ++card_count;
    }
 
    return card_count;
}

Перекрестные ссылки am_Players.

Используется в ApplyCardToPlayer(), DiscardCard(), DrawCardAnimation(), DrawCards(), DrawCardsRectangles(), ArcomageGame::Loop(), OpponentsAITurn(), PlayCard() и PlayerTurn().

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

DrawCardsRectangles()

signed int DrawCardsRectangles

(

int

player_num

)

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

                                               {
    // draws the framing rectangle around cards on hover
    arcomage_mouse get_mouse;
    Rect pXYZW;
    int color;
 
    // only do for the human player
    if (am_Players[player_num].IsHisTurn) {
        // get the mouse position
        if (get_mouse.Update()) {
            // calc spacings and first card position
            int card_count = GetPlayerHandCardCount(player_num);
            int card_spacing = (window->GetWidth() - 96 * card_count) / (card_count + 1);
            pXYZW.y = 327;
            pXYZW.w = 455;
            pXYZW.x = card_spacing;
            int card_offset = pXYZW.x + 96;
            pXYZW.z = card_offset;
 
            // loop through hand of cards
            for (int hand_index = 0; hand_index < card_count; hand_index++) {
                // if there is a card
                if (am_Players[player_num].cards_at_hand[hand_index] != -1) {
                    // shift rectangle co ords
                    if (Player_Cards_Shift) {
                        pXYZW.x += am_Players[player_num].card_shift[hand_index].x;
                        pXYZW.z += am_Players[player_num].card_shift[hand_index].x;
                        pXYZW.y += am_Players[player_num].card_shift[hand_index].y;
                        pXYZW.w += am_Players[player_num].card_shift[hand_index].y;
                    }
 
                    // see if mouse is hovering
                    if (get_mouse.Inside(&pXYZW)) {
                        if (CanCardBePlayed(player_num, hand_index))
                            color = 0x00FFFFFF;  //белый цвет - white frame
                        else
                            color = 0x000000FF;  //красный цвет - red frame
 
                        // draw outline and return
                        DrawRect(&pXYZW, R8G8B8_to_TargetFormat(color), 0);
                        return hand_index;
                    }
 
                    //рамка чёрного цвета - black frame
                    DrawRect(&pXYZW, R8G8B8_to_TargetFormat(0), 0);
 
                    // unshift rectangle co ords
                    if (Player_Cards_Shift) {
                        pXYZW.x -= am_Players[player_num].card_shift[hand_index].x;
                        pXYZW.z -= am_Players[player_num].card_shift[hand_index].x;
                        pXYZW.y -= am_Players[player_num].card_shift[hand_index].y;
                        pXYZW.w -= am_Players[player_num].card_shift[hand_index].y;
                    }
 
                    // shift offsets along a card width
                    pXYZW.x += card_offset;
                    pXYZW.z += card_offset;
                }
            }
        }
    }
    // no card hovered
    return -1;
}

Перекрестные ссылки am_Players, CanCardBePlayed(), ArcomagePlayer::card_shift, DrawRect(), GetPlayerHandCardCount(), arcomage_mouse::Inside(), Player_Cards_Shift, R8G8B8_to_TargetFormat(), arcomage_mouse::Update(), Rect::w, Rect::x, sPoint::x, Rect::y, sPoint::y и Rect::z.

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

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

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

DiscardCard() [1/2]

bool DiscardCard	(	int	player_num,
		int	card_slot_index
	)

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

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

PlayCard()

bool PlayCard	(	int	player_num,
		int	card_slot_num
	)

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

                                                 {
    // check for valid card slot
    if (card_slot_num <= -1) return false;
 
    // can the card be played
    if (CanCardBePlayed(player_num, card_slot_num)) {
        // calc animation position and move speed
        int cards_at_hand = GetPlayerHandCardCount(current_player_num);
        int card_spacing = (window->GetWidth() - (96 * cards_at_hand)) / (cards_at_hand + 1);
 
        anim_card_pos_playdiscard.x = am_Players[player_num].card_shift[card_slot_num].x + (card_slot_num * (card_spacing + 96) + card_spacing);
        anim_card_pos_playdiscard.y = am_Players[player_num].card_shift[card_slot_num].y + 327;
 
        anim_card_spd_playdiscard.x = (272 - (int)anim_card_pos_playdiscard.x) / 5;
        anim_card_spd_playdiscard.y = -30;  // (-150 / 5)
 
        // play sound and take resource cost
        ArcomageCard* pCard = &pCards[am_Players[player_num].cards_at_hand[card_slot_num]];
        ArcomageGame::PlaySound(23);
        am_Players[player_num].resource_bricks -= pCard->needed_bricks;
        am_Players[player_num].resource_beasts -= pCard->needed_beasts;
        am_Players[player_num].resource_gems -= pCard->needed_gems;
 
        // set anim card and remove from player
        played_card_id = am_Players[player_num].cards_at_hand[card_slot_num];
        am_Players[player_num].cards_at_hand[card_slot_num] = -1;
        pArcomageGame->force_redraw_1 = 1;
 
        return true;
    } else {
        // cannot make this move
        return false;
    }
}

Перекрестные ссылки am_Players, anim_card_pos_playdiscard, anim_card_spd_playdiscard, CanCardBePlayed(), ArcomagePlayer::card_shift, ArcomagePlayer::cards_at_hand, current_player_num, ArcomageGame::force_redraw_1, GetPlayerHandCardCount(), ArcomageCard::needed_beasts, ArcomageCard::needed_bricks, ArcomageCard::needed_gems, pArcomageGame, pCards, played_card_id, ArcomageGame::PlaySound(), ArcomagePlayer::resource_beasts, ArcomagePlayer::resource_bricks, ArcomagePlayer::resource_gems, Point::x, sPoint::x, Point::y и sPoint::y.

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

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

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

CanCardBePlayed()

bool CanCardBePlayed	(	int	player_num,
		int	hand_card_indx
	)

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

                                                         {
    bool result = true;
    ArcomagePlayer* pPlayer = &am_Players[player_num];
    ArcomageCard *test_card = &pCards[pPlayer->cards_at_hand[hand_card_indx]];
 
    // test card conditions
    if (test_card->needed_quarry_level > pPlayer->quarry_level) result = false;
    if (test_card->needed_magic_level > pPlayer->magic_level) result = false;
    if (test_card->needed_zoo_level > pPlayer->zoo_level) result = false;
    if (test_card->needed_bricks > pPlayer->resource_bricks) result = false;
    if (test_card->needed_gems > pPlayer->resource_gems) result = false;
    if (test_card->needed_beasts > pPlayer->resource_beasts) result = false;
 
    return result;
}

Перекрестные ссылки am_Players, ArcomagePlayer::cards_at_hand, ArcomagePlayer::magic_level, ArcomageCard::needed_beasts, ArcomageCard::needed_bricks, ArcomageCard::needed_gems, ArcomageCard::needed_magic_level, ArcomageCard::needed_quarry_level, ArcomageCard::needed_zoo_level, pCards, ArcomagePlayer::quarry_level, ArcomagePlayer::resource_beasts, ArcomagePlayer::resource_bricks, ArcomagePlayer::resource_gems и ArcomagePlayer::zoo_level.

Используется в DrawCards(), DrawCardsRectangles(), OpponentsAITurn() и PlayCard().

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

ApplyCardToPlayer()

void ApplyCardToPlayer	(	int	player_num,
		unsigned int	uCardID
	)

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

                                                             {
#define APPLY_TO_PLAYER(PLAYER, ENEMY, FIELD, VAL, RES)   \
    if (VAL != 0) {                                       \
        if (VAL == 99) {                                  \
            if (PLAYER->FIELD < ENEMY->FIELD) {           \
                PLAYER->FIELD = ENEMY->FIELD;             \
                RES = ENEMY->FIELD - PLAYER->FIELD;       \
            }                                             \
        } else {                                          \
            PLAYER->FIELD += (signed int)(VAL);           \
            if (PLAYER->FIELD < 0) PLAYER->FIELD = 0;     \
            RES = (signed int)(VAL);                      \
        }                                                 \
    }
 
#define APPLY_TO_ENEMY(PLAYER, ENEMY, FIELD, VAL, RES) \
    APPLY_TO_PLAYER(ENEMY, PLAYER, FIELD, VAL, RES)
 
#define APPLY_TO_BOTH(PLAYER, ENEMY, FIELD, VAL, RES_P, RES_E) \
    if (VAL != 0) {                                            \
        if (VAL == 99) {                                       \
            if (PLAYER->FIELD != ENEMY->FIELD) {               \
                if (PLAYER->FIELD <= ENEMY->FIELD) {           \
                    PLAYER->FIELD = ENEMY->FIELD;              \
                    RES_P = ENEMY->FIELD - PLAYER->FIELD;      \
                } else {                                       \
                    ENEMY->FIELD = PLAYER->FIELD;              \
                    RES_E = PLAYER->FIELD - ENEMY->FIELD;      \
                }                                              \
            }                                                  \
        } else {                                               \
            PLAYER->FIELD += (signed int)(VAL);                \
            ENEMY->FIELD += (signed int)(VAL);                 \
            if (PLAYER->FIELD < 0) {                           \
                PLAYER->FIELD = 0;                             \
            }                                                  \
            if (ENEMY->FIELD < 0) {                            \
                ENEMY->FIELD = 0;                              \
            }                                                  \
            RES_P = (signed int)(VAL);                         \
            RES_E = (signed int)(VAL);                         \
        }                                                      \
    }
 
    ArcomagePlayer *player = &am_Players[player_num];
    int enemy_num = ((player_num + 1) % 2);
    ArcomagePlayer *enemy = &am_Players[enemy_num];
    ArcomageCard* pCard = &pCards[uCardID];
 
    int buildings_e = 0;
    int buildings_p = 0;
    int dmg_e = 0;
    int dmg_p = 0;
    int tower_e = 0;
    int tower_p = 0;
    int wall_e = 0;
    int wall_p = 0;
 
    int beasts_e = 0;
    int beasts_p = 0;
    int gems_e = 0;
    int gems_p = 0;
    int bricks_e = 0;
    int bricks_p = 0;
    int zoo_e = 0;
    int zoo_p = 0;
    int magic_e = 0;
    int magic_p = 0;
    int quarry_e = 0;
    int quarry_p = 0;
 
    switch (pCard->compare_param) {
        case 2:
            if (player->quarry_level <
                enemy->quarry_level)  //если рудники < рудника врага
                goto LABEL_26;
            goto LABEL_231;
        case 3:
            if (player->magic_level < enemy->magic_level) goto LABEL_26;
            goto LABEL_231;
        case 4:
            if (player->zoo_level <
                enemy->zoo_level)  //если зверинец < зверинца врага
                goto LABEL_26;
            goto LABEL_231;
        case 5:
            if (player->quarry_level == enemy->quarry_level) goto LABEL_26;
            goto LABEL_231;
        case 6:
            if (player->magic_level == enemy->magic_level) goto LABEL_26;
            goto LABEL_231;
        case 7:
            if (player->zoo_level == enemy->zoo_level) goto LABEL_26;
            goto LABEL_231;
        case 8:
            if (player->quarry_level < enemy->quarry_level) goto LABEL_26;
            goto LABEL_231;
        case 9:
            if (player->magic_level < enemy->magic_level) goto LABEL_26;
            goto LABEL_231;
        case 10:
            if (player->zoo_level < enemy->zoo_level) goto LABEL_26;
            goto LABEL_231;
        case 11:
            if (!player->wall_height) goto LABEL_26;
            goto LABEL_231;
        case 12:
            if (player->wall_height) goto LABEL_26;
            goto LABEL_231;
        case 13:
            if (!enemy->wall_height) goto LABEL_26;
            goto LABEL_231;
        case 14:
            if (enemy->wall_height) goto LABEL_26;
            goto LABEL_231;
        case 15:
            if (player->wall_height < enemy->wall_height) goto LABEL_26;
            goto LABEL_231;
        case 16:
            if (player->tower_height < enemy->tower_height) goto LABEL_26;
            goto LABEL_231;
        case 17:
            if (player->wall_height == enemy->wall_height) goto LABEL_26;
            goto LABEL_231;
        case 18:
            if (player->tower_height == enemy->tower_height) goto LABEL_26;
            goto LABEL_231;
        case 19:
            if (player->wall_height < enemy->wall_height) goto LABEL_26;
            goto LABEL_231;
        case 20:
            if (player->tower_height < enemy->tower_height) goto LABEL_26;
            goto LABEL_231;
        default:
        LABEL_26:
            num_actions_left =
                pCard->draw_extra_card_count + (pCard->field_30 == 1);
            num_cards_to_discard = pCard->draw_extra_card_count;
            for (char i = 0; i < pCard->draw_extra_card_count; i++)
                GetNextCardFromDeck(player_num);
 
            need_to_discard_card =
                GetPlayerHandCardCount(player_num) > minimum_cards_at_hand;
 
            APPLY_TO_PLAYER(player, enemy, quarry_level,
                            pCard->to_player_quarry_lvl, quarry_p);
            APPLY_TO_PLAYER(player, enemy, magic_level,
                            pCard->to_player_magic_lvl, magic_p);
            APPLY_TO_PLAYER(player, enemy, zoo_level, pCard->to_player_zoo_lvl,
                            zoo_p);
            APPLY_TO_PLAYER(player, enemy, resource_bricks,
                            pCard->to_player_bricks, bricks_p);
            APPLY_TO_PLAYER(player, enemy, resource_gems, pCard->to_player_gems,
                            gems_p);
            APPLY_TO_PLAYER(player, enemy, resource_beasts,
                            pCard->to_player_beasts, beasts_p);
            if (pCard->to_player_buildings) {
                dmg_p = ApplyDamageToBuildings(
                    player_num, (signed int)pCard->to_player_buildings);
                buildings_p = (signed int)pCard->to_player_buildings - dmg_p;
            }
            APPLY_TO_PLAYER(player, enemy, wall_height, pCard->to_player_wall,
                            wall_p);
            APPLY_TO_PLAYER(player, enemy, tower_height, pCard->to_player_tower,
                            tower_p);
 
            APPLY_TO_ENEMY(player, enemy, quarry_level,
                           pCard->to_enemy_quarry_lvl, quarry_e);
            APPLY_TO_ENEMY(player, enemy, magic_level,
                           pCard->to_enemy_magic_lvl, magic_e);
            APPLY_TO_ENEMY(player, enemy, zoo_level, pCard->to_enemy_zoo_lvl,
                           zoo_e);
            APPLY_TO_ENEMY(player, enemy, resource_bricks,
                           pCard->to_enemy_bricks, bricks_e);
            APPLY_TO_ENEMY(player, enemy, resource_gems, pCard->to_enemy_gems,
                           gems_e);
            APPLY_TO_ENEMY(player, enemy, resource_beasts,
                           pCard->to_enemy_beasts, beasts_e);
            if (pCard->to_enemy_buildings) {
                dmg_e = ApplyDamageToBuildings(
                    enemy_num, (signed int)pCard->to_enemy_buildings);
                buildings_e = (signed int)pCard->to_enemy_buildings - dmg_e;
            }
            APPLY_TO_ENEMY(player, enemy, wall_height, pCard->to_enemy_wall,
                           wall_e);
            APPLY_TO_ENEMY(player, enemy, tower_height, pCard->to_enemy_tower,
                           tower_e);
 
            APPLY_TO_BOTH(player, enemy, quarry_level,
                          pCard->to_pl_enm_quarry_lvl, quarry_p, quarry_e);
            APPLY_TO_BOTH(player, enemy, magic_level,
                          pCard->to_pl_enm_magic_lvl, magic_p, magic_e);
            APPLY_TO_BOTH(player, enemy, zoo_level, pCard->to_pl_enm_zoo_lvl,
                          zoo_p, zoo_e);
            APPLY_TO_BOTH(player, enemy, resource_bricks,
                          pCard->to_pl_enm_bricks, bricks_p, bricks_e);
            APPLY_TO_BOTH(player, enemy, resource_gems, pCard->to_pl_enm_gems,
                          gems_p, gems_e);
            APPLY_TO_BOTH(player, enemy, resource_beasts,
                          pCard->to_pl_enm_beasts, beasts_p, beasts_e);
            if (pCard->to_pl_enm_buildings) {
                dmg_p = ApplyDamageToBuildings(
                    player_num, (signed int)pCard->to_pl_enm_buildings);
                dmg_e = ApplyDamageToBuildings(
                    enemy_num, (signed int)pCard->to_pl_enm_buildings);
                buildings_p = (signed int)pCard->to_pl_enm_buildings - dmg_p;
                buildings_e = (signed int)pCard->to_pl_enm_buildings - dmg_e;
            }
            APPLY_TO_BOTH(player, enemy, wall_height, pCard->to_pl_enm_wall,
                          wall_p, wall_e);
            APPLY_TO_BOTH(player, enemy, tower_height, pCard->to_pl_enm_tower,
                          tower_p, tower_e);
            break;
        case 0:
        LABEL_231:
            num_actions_left = pCard->can_draw_extra_card2 + (pCard->field_4D == 1);
            num_cards_to_discard = pCard->can_draw_extra_card2;
            for (char i = 0; i < pCard->can_draw_extra_card2; i++)
                GetNextCardFromDeck(player_num);
 
            need_to_discard_card =
                GetPlayerHandCardCount(player_num) > minimum_cards_at_hand;
 
            APPLY_TO_PLAYER(player, enemy, quarry_level,
                            pCard->to_player_quarry_lvl2, quarry_p);
            APPLY_TO_PLAYER(player, enemy, magic_level,
                            pCard->to_player_magic_lvl2, magic_p);
            APPLY_TO_PLAYER(player, enemy, zoo_level, pCard->to_player_zoo_lvl2,
                            zoo_p);
            APPLY_TO_PLAYER(player, enemy, resource_bricks,
                            pCard->to_player_bricks2, bricks_p);
            APPLY_TO_PLAYER(player, enemy, resource_gems,
                            pCard->to_player_gems2, gems_p);
            APPLY_TO_PLAYER(player, enemy, resource_beasts,
                            pCard->to_player_beasts2, beasts_p);
            if (pCard->to_player_buildings2) {
                dmg_p = ApplyDamageToBuildings(
                    player_num, (signed int)pCard->to_player_buildings2);
                buildings_p = (signed int)pCard->to_player_buildings2 - dmg_p;
            }
            APPLY_TO_PLAYER(player, enemy, wall_height, pCard->to_player_wall2,
                            wall_p);
            APPLY_TO_PLAYER(player, enemy, tower_height,
                            pCard->to_player_tower2, tower_p);
 
            APPLY_TO_ENEMY(player, enemy, quarry_level,
                           pCard->to_enemy_quarry_lvl2, quarry_e);
            APPLY_TO_ENEMY(player, enemy, magic_level,
                           pCard->to_enemy_magic_lvl2, magic_e);
            APPLY_TO_ENEMY(player, enemy, zoo_level, pCard->to_enemy_zoo_lvl2,
                           zoo_e);
            APPLY_TO_ENEMY(player, enemy, resource_bricks,
                           pCard->to_enemy_bricks2, bricks_e);
            APPLY_TO_ENEMY(player, enemy, resource_gems, pCard->to_enemy_gems2,
                           gems_e);
            APPLY_TO_ENEMY(player, enemy, resource_beasts,
                           pCard->to_enemy_beasts2, beasts_e);
            if (pCard->to_enemy_buildings2) {
                dmg_e = ApplyDamageToBuildings(
                    enemy_num, (signed int)pCard->to_enemy_buildings2);
                buildings_e = (signed int)pCard->to_enemy_buildings2 - dmg_e;
            }
            APPLY_TO_ENEMY(player, enemy, wall_height, pCard->to_enemy_wall2,
                           wall_e);
            APPLY_TO_ENEMY(player, enemy, tower_height, pCard->to_enemy_tower2,
                           tower_e);
 
            APPLY_TO_BOTH(player, enemy, quarry_level,
                          pCard->to_pl_enm_quarry_lvl2, quarry_p, quarry_e);
            APPLY_TO_BOTH(player, enemy, magic_level,
                          pCard->to_pl_enm_magic_lvl2, magic_p, magic_e);
            APPLY_TO_BOTH(player, enemy, zoo_level, pCard->to_pl_enm_zoo_lvl2,
                          zoo_p, zoo_e);
            APPLY_TO_BOTH(player, enemy, resource_bricks,
                          pCard->to_pl_enm_bricks2, bricks_p, bricks_e);
            APPLY_TO_BOTH(player, enemy, resource_gems, pCard->to_pl_enm_gems2,
                          gems_p, gems_e);
            APPLY_TO_BOTH(player, enemy, resource_beasts,
                          pCard->to_pl_enm_beasts2, beasts_p, beasts_e);
 
            if (pCard->to_pl_enm_buildings2) {
                dmg_p = ApplyDamageToBuildings(
                    player_num, (signed int)pCard->to_pl_enm_buildings2);
                dmg_e = ApplyDamageToBuildings(
                    enemy_num, (signed int)pCard->to_pl_enm_buildings2);
                buildings_p = (signed int)pCard->to_pl_enm_buildings2 - dmg_p;
                buildings_e = (signed int)pCard->to_pl_enm_buildings2 - dmg_e;
            }
            APPLY_TO_BOTH(player, enemy, wall_height, pCard->to_pl_enm_wall2,
                          wall_p, wall_e);
            APPLY_TO_BOTH(player, enemy, tower_height, pCard->to_pl_enm_tower2,
                          tower_p, tower_e);
            break;
    }
    //  }
 
 
    // call sound if required
    if (quarry_p > 0 || quarry_e > 0) pArcomageGame->PlaySound(30);
    if (quarry_p < 0 || quarry_e < 0) pArcomageGame->PlaySound(31);
    if (magic_p > 0 || magic_e > 0) pArcomageGame->PlaySound(33);
    if (magic_p < 0 || magic_e < 0) pArcomageGame->PlaySound(34);
    if (zoo_p > 0 || zoo_e > 0) pArcomageGame->PlaySound(36);
    if (zoo_p < 0 || zoo_e < 0) pArcomageGame->PlaySound(37);
    if (bricks_p > 0 || bricks_e > 0) pArcomageGame->PlaySound(39);
    if (bricks_p < 0 || bricks_e < 0) pArcomageGame->PlaySound(40);
    if (gems_p > 0 || gems_e > 0) pArcomageGame->PlaySound(42);
    if (gems_p < 0 || gems_e < 0) pArcomageGame->PlaySound(43);
    if (beasts_p > 0 || beasts_e > 0) pArcomageGame->PlaySound(45u);
    if (beasts_p < 0 || beasts_e < 0) pArcomageGame->PlaySound(46);
    if (buildings_p || buildings_e || dmg_p || dmg_e) pArcomageGame->PlaySound(48);
    if (wall_p > 0 || wall_e > 0) pArcomageGame->PlaySound(49);
    if (wall_p < 0 || wall_e < 0) pArcomageGame->PlaySound(50);
    if (tower_p > 0 || tower_e > 0) pArcomageGame->PlaySound(52);
    if (tower_p < 0 || tower_e < 0) pArcomageGame->PlaySound(53);
 
 
    // call spark effect if required
    Point explos_coords;
    if (player_num) {
        if (quarry_p) {
            explos_coords.x = 573;
            explos_coords.y = 92;
            new_explosion_effect(&explos_coords, quarry_p);
        }
        if (quarry_e) {
            explos_coords.x = 26;
            explos_coords.y = 92;
            new_explosion_effect(&explos_coords, quarry_e);
        }
        if (magic_p) {
            explos_coords.x = 573;
            explos_coords.y = 164;
            new_explosion_effect(&explos_coords, magic_p);
        }
        if (magic_e) {
            explos_coords.x = 26;
            explos_coords.y = 164;
            new_explosion_effect(&explos_coords, magic_e);
        }
        if (zoo_p) {
            explos_coords.x = 573;
            explos_coords.y = 236;
            new_explosion_effect(&explos_coords, zoo_p);
        }
        if (zoo_e) {
            explos_coords.x = 26;
            explos_coords.y = 236;
            new_explosion_effect(&explos_coords, zoo_e);
        }
        if (bricks_p) {
            explos_coords.x = 563;
            explos_coords.y = 114;
            new_explosion_effect(&explos_coords, bricks_p);
        }
        if (bricks_e) {
            explos_coords.x = 16;
            explos_coords.y = 114;
            new_explosion_effect(&explos_coords, bricks_e);
        }
        if (gems_p) {
            explos_coords.x = 563;
            explos_coords.y = 186;
            new_explosion_effect(&explos_coords, gems_p);
        }
        if (gems_e) {
            explos_coords.x = 16;
            explos_coords.y = 186;
            new_explosion_effect(&explos_coords, gems_e);
        }
        if (beasts_p) {
            explos_coords.x = 563;
            explos_coords.y = 258;
            new_explosion_effect(&explos_coords, beasts_p);
        }
        if (beasts_e) {
            explos_coords.x = 16;
            explos_coords.y = 258;
            new_explosion_effect(&explos_coords, beasts_e);
        }
        if (wall_p) {
            explos_coords.x = 442;
            explos_coords.y = 296;
            new_explosion_effect(&explos_coords, wall_p);
        }
        if (wall_e) {
            explos_coords.x = 180;
            explos_coords.y = 296;
            new_explosion_effect(&explos_coords, wall_e);
        }
        if (tower_p) {
            explos_coords.x = 514;
            explos_coords.y = 296;
            new_explosion_effect(&explos_coords, tower_p);
        }
        if (tower_e) {
            explos_coords.x = 122;
            explos_coords.y = 296;
            new_explosion_effect(&explos_coords, tower_e);
        }
        if (dmg_p) {
            explos_coords.x = 442;
            explos_coords.y = 296;
            new_explosion_effect(&explos_coords, dmg_p);
        }
        if (buildings_p) {
            explos_coords.x = 514;
            explos_coords.y = 296;
            new_explosion_effect(&explos_coords, buildings_p);
        }
        if (dmg_e) {
            explos_coords.x = 180;
            explos_coords.y = 296;
            new_explosion_effect(&explos_coords, dmg_e);
        }
        if (buildings_e) {
            explos_coords.x = 122;
            explos_coords.y = 296;
            new_explosion_effect(&explos_coords, buildings_e);
        }
    } else {
        if (quarry_p) {
            explos_coords.x = 26;
            explos_coords.y = 92;
            new_explosion_effect(&explos_coords, quarry_p);
        }
        if (quarry_e) {
            explos_coords.x = 573;
            explos_coords.y = 92;
            new_explosion_effect(&explos_coords, quarry_e);
        }
        if (magic_p) {
            explos_coords.x = 26;
            explos_coords.y = 164;
            new_explosion_effect(&explos_coords, magic_p);
        }
        if (magic_e) {
            explos_coords.x = 573;
            explos_coords.y = 164;
            new_explosion_effect(&explos_coords, magic_e);
        }
        if (zoo_p) {
            explos_coords.x = 26;
            explos_coords.y = 236;
            new_explosion_effect(&explos_coords, zoo_p);
        }
        if (zoo_e) {
            explos_coords.x = 573;
            explos_coords.y = 236;
            new_explosion_effect(&explos_coords, zoo_e);
        }
        if (bricks_p) {
            explos_coords.x = 16;
            explos_coords.y = 114;
            new_explosion_effect(&explos_coords, bricks_p);
        }
        if (bricks_e) {
            explos_coords.x = 563;
            explos_coords.y = 114;
            new_explosion_effect(&explos_coords, bricks_e);
        }
        if (gems_p) {
            explos_coords.x = 16;
            explos_coords.y = 186;
            new_explosion_effect(&explos_coords, gems_p);
        }
        if (gems_e) {
            explos_coords.x = 563;
            explos_coords.y = 186;
            new_explosion_effect(&explos_coords, gems_e);
        }
        if (beasts_p) {
            explos_coords.x = 16;
            explos_coords.y = 258;
            new_explosion_effect(&explos_coords, beasts_p);
        }
        if (beasts_e) {
            explos_coords.x = 563;
            explos_coords.y = 258;
            new_explosion_effect(&explos_coords, beasts_e);
        }
        if (wall_p) {
            explos_coords.x = 180;
            explos_coords.y = 296;
            new_explosion_effect(&explos_coords, wall_p);
        }
        if (wall_e) {
            explos_coords.x = 442;
            explos_coords.y = 296;
            new_explosion_effect(&explos_coords, wall_e);
        }
        if (tower_p) {
            explos_coords.x = 122;
            explos_coords.y = 296;
            new_explosion_effect(&explos_coords, tower_p);
        }
        if (tower_e) {
            explos_coords.x = 514;
            explos_coords.y = 296;
            new_explosion_effect(&explos_coords, tower_e);
        }
        if (dmg_p) {
            explos_coords.x = 180;
            explos_coords.y = 296;
            new_explosion_effect(&explos_coords, dmg_p);
        }
        if (buildings_p) {
            explos_coords.x = 122;
            explos_coords.y = 296;
            new_explosion_effect(&explos_coords, buildings_p);
        }
        if (dmg_e) {
            explos_coords.x = 442;
            explos_coords.y = 296;
            new_explosion_effect(&explos_coords, dmg_e);
        }
        if (buildings_e) {
            explos_coords.x = 514;
            explos_coords.y = 296;
            new_explosion_effect(&explos_coords, buildings_e);
        }
    }
 
#undef APPLY_TO_BOTH
#undef APPLY_TO_ENEMY
#undef APPLY_TO_PLAYER
}

Перекрестные ссылки am_Players, ApplyDamageToBuildings(), ArcomageCard::can_draw_extra_card2, ArcomageCard::compare_param, ArcomageCard::draw_extra_card_count, ArcomageCard::field_30, ArcomageCard::field_4D, GetNextCardFromDeck(), GetPlayerHandCardCount(), ArcomagePlayer::magic_level, minimum_cards_at_hand, need_to_discard_card, new_explosion_effect(), num_actions_left, num_cards_to_discard, pArcomageGame, pCards, ArcomageGame::PlaySound(), ArcomagePlayer::quarry_level, ArcomageCard::to_enemy_beasts, ArcomageCard::to_enemy_beasts2, ArcomageCard::to_enemy_bricks, ArcomageCard::to_enemy_bricks2, ArcomageCard::to_enemy_buildings, ArcomageCard::to_enemy_buildings2, ArcomageCard::to_enemy_gems, ArcomageCard::to_enemy_gems2, ArcomageCard::to_enemy_magic_lvl, ArcomageCard::to_enemy_magic_lvl2, ArcomageCard::to_enemy_quarry_lvl, ArcomageCard::to_enemy_quarry_lvl2, ArcomageCard::to_enemy_tower, ArcomageCard::to_enemy_tower2, ArcomageCard::to_enemy_wall, ArcomageCard::to_enemy_wall2, ArcomageCard::to_enemy_zoo_lvl, ArcomageCard::to_enemy_zoo_lvl2, ArcomageCard::to_pl_enm_beasts, ArcomageCard::to_pl_enm_beasts2, ArcomageCard::to_pl_enm_bricks, ArcomageCard::to_pl_enm_bricks2, ArcomageCard::to_pl_enm_buildings, ArcomageCard::to_pl_enm_buildings2, ArcomageCard::to_pl_enm_gems, ArcomageCard::to_pl_enm_gems2, ArcomageCard::to_pl_enm_magic_lvl, ArcomageCard::to_pl_enm_magic_lvl2, ArcomageCard::to_pl_enm_quarry_lvl, ArcomageCard::to_pl_enm_quarry_lvl2, ArcomageCard::to_pl_enm_tower, ArcomageCard::to_pl_enm_tower2, ArcomageCard::to_pl_enm_wall, ArcomageCard::to_pl_enm_wall2, ArcomageCard::to_pl_enm_zoo_lvl, ArcomageCard::to_pl_enm_zoo_lvl2, ArcomageCard::to_player_beasts, ArcomageCard::to_player_beasts2, ArcomageCard::to_player_bricks, ArcomageCard::to_player_bricks2, ArcomageCard::to_player_buildings, ArcomageCard::to_player_buildings2, ArcomageCard::to_player_gems, ArcomageCard::to_player_gems2, ArcomageCard::to_player_magic_lvl, ArcomageCard::to_player_magic_lvl2, ArcomageCard::to_player_quarry_lvl, ArcomageCard::to_player_quarry_lvl2, ArcomageCard::to_player_tower, ArcomageCard::to_player_tower2, ArcomageCard::to_player_wall, ArcomageCard::to_player_wall2, ArcomageCard::to_player_zoo_lvl, ArcomageCard::to_player_zoo_lvl2, ArcomagePlayer::tower_height, ArcomagePlayer::wall_height, Point::x, Point::y и ArcomagePlayer::zoo_level.

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

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

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

new_explosion_effect()

int new_explosion_effect	(	Point *	a1,
		int	a2
	)

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

                                                           {
    // find first empty effect slot
    signed int arr_slot = 0;
    for (arr_slot = 0; arr_slot < 10; arr_slot++) {
        if (am_effects_array[arr_slot].have_effect) {
            if (am_effects_array[arr_slot].explosion_eff->IsEffectActive() == 0) {
                am_effects_array[arr_slot].have_effect = 0;
                break;
            }
        } else {
            break;
        }
        if (arr_slot == 9) return 2;
    }
 
    // set slot active and effect colour
    am_effects_array[arr_slot].have_effect = 1;
    if (effect_value <= 0) {
        am_effects_array[arr_slot].effect_sign = 0;
        effect_value = -effect_value;
    } else {
        am_effects_array[arr_slot].effect_sign = 1;
    }
 
    // fill effect params
    am_effects_array[arr_slot].eff_params.effect_area.x = startXY->x - 20;
    am_effects_array[arr_slot].eff_params.effect_area.z = startXY->x + 20;
    am_effects_array[arr_slot].eff_params.effect_area.y = startXY->y - 20;
    am_effects_array[arr_slot].eff_params.effect_area.w = startXY->y + 20;
    am_effects_array[arr_slot].eff_params.unused_param_1 = -60;
    am_effects_array[arr_slot].eff_params.unused_param_2 = 60;
    am_effects_array[arr_slot].eff_params.unused_param_3 = 180;
    am_effects_array[arr_slot].eff_params.gravity_acc = 0.5;
    am_effects_array[arr_slot].eff_params.spark_array_size = 150;
    am_effects_array[arr_slot].eff_params.create_per_frame = 50.0;
    am_effects_array[arr_slot].eff_params.unused_acc_1 = 3.0;
    am_effects_array[arr_slot].eff_params.unused_acc_1 = 8.0;
    am_effects_array[arr_slot].eff_params.min_lifespan = 5;
    am_effects_array[arr_slot].eff_params.max_lifespan = 15;
    am_effects_array[arr_slot].eff_params.sparks_array = &am_effects_array[arr_slot].effect_sparks[0];
 
    // fill explosion struct
    explosion_effect_struct* explos = am_effects_array[arr_slot].explosion_eff;
    if ((explos->StartFill(&am_effects_array[arr_slot].eff_params)) == 2) return 2;
    if (!explos->params_filled) return 3;
    if (10 * effect_value > 150) effect_value = 15;
    explos->remaining_sparks_to_init = 10 * effect_value;
    explos->prev_init_overflow = 0.0;
    explos->effect_active = 0;
 
    // unused parameters
    explos->unused_param_4 = 0;
    explos->unused_param_6 = 0;
    explos->unused_param_5 = 0;
    explos->unused_param_7 = 0;
 
    // wipe spark array
    for (int i = 0; i < explos->spark_array_size; ++i) explos->spark_array_ptr[i].spark_remaining_life = 0;
 
    return 0;
}

Перекрестные ссылки am_effects_array, effect_params_struct::create_per_frame, am_effects_struct::eff_params, explosion_effect_struct::effect_active, effect_params_struct::effect_area, am_effects_struct::effect_sign, am_effects_struct::effect_sparks, am_effects_struct::explosion_eff, effect_params_struct::gravity_acc, am_effects_struct::have_effect, effect_params_struct::max_lifespan, effect_params_struct::min_lifespan, explosion_effect_struct::params_filled, explosion_effect_struct::prev_init_overflow, explosion_effect_struct::remaining_sparks_to_init, explosion_effect_struct::spark_array_ptr, effect_params_struct::spark_array_size, explosion_effect_struct::spark_array_size, spark_point_struct::spark_remaining_life, effect_params_struct::sparks_array, explosion_effect_struct::StartFill(), effect_params_struct::unused_acc_1, effect_params_struct::unused_param_1, effect_params_struct::unused_param_2, effect_params_struct::unused_param_3, explosion_effect_struct::unused_param_4, explosion_effect_struct::unused_param_5, explosion_effect_struct::unused_param_6, explosion_effect_struct::unused_param_7, Rect::w, Rect::x, Point::x, Rect::y, Point::y и Rect::z.

Используется в ApplyCardToPlayer() и ArcomageGame::Loop().

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

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

ApplyDamageToBuildings()

int ApplyDamageToBuildings	(	int	player_num,
		int	damage
	)

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

                                                       {
    int wall = am_Players[player_num].wall_height;
    int result = 0;
 
    if (wall >= -damage) {  // wall absorbs all damage
        result = damage;
        am_Players[player_num].wall_height += damage;
    } else {
        damage += wall;  // reduce damage by size of wall
        am_Players[player_num].wall_height = 0;
        result = -wall;
        am_Players[player_num].tower_height += damage;  // apply remaining to tower
    }
 
    if (am_Players[player_num].tower_height < 0)
        am_Players[player_num].tower_height = 0;
 
    return result;
}

Перекрестные ссылки am_Players, ArcomagePlayer::tower_height и ArcomagePlayer::wall_height.

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

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

GameResultsApply()

void GameResultsApply

(

)

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

                        {
    int winner;               // esi@1
    int victory_type;         // edi@1
    int pl_resource;          // edx@25
    int en_resource;          // eax@28
    unsigned int tavern_num;  // eax@54
 
    winner = -1;
    victory_type = -1;
    // nullsub_1();
    /*strcpy(pText, "The Winner is: ");//"Победил: " Ritor1: архаизм
    xy.y = 160;
    xy.x = 320; //- 12 * v2 / 2;
    am_DrawText(-1, pText, &xy);*/
 
    //проверка построена ли башня
    if (am_Players[0].tower_height < max_tower_height &&
        am_Players[1].tower_height >=
            max_tower_height) {  //наша башня не построена, а у врага построена
        winner = 2;  //победил игрок 2(враг)
        victory_type = 0;
    } else if (am_Players[0].tower_height >= max_tower_height &&
               am_Players[1].tower_height <
                   max_tower_height) {  //наша башня построена, а у врага нет
        winner = 1;  //победил игрок 1(мы)
        victory_type = 0;
    } else if (am_Players[0].tower_height >= max_tower_height &&
               am_Players[1].tower_height >=
                   max_tower_height) {  //и у нас, и у врага построена
        if (am_Players[0].tower_height ==
            am_Players[1].tower_height) {  //наши башни равны
            winner = 0;        //никто не победил
            victory_type = 4;  //ничья
        } else {               //наши башни не равны
            winner =
                (am_Players[0].tower_height <= am_Players[1].tower_height) +
                1;  //победил тот, у кого выше
            victory_type = 0;
        }
    }
 
    //проверка разрушена ли башня
    if (am_Players[0].tower_height <= 0 &&
        am_Players[1].tower_height > 0) {  //наша башня разрушена, а у врага нет
        winner = 2;        // победил игрок 2(враг)
        victory_type = 2;  //победил разрушив башню врага
    } else if (am_Players[0].tower_height > 0 &&
               am_Players[1].tower_height <=
                   0) {  //у врага башня разрушена, а у нас нет
        winner = 1;        //победил игрок 1(мы)
        victory_type = 2;  //победил разрушив башню врага
    } else if (am_Players[0].tower_height <= 0 &&
               am_Players[1].tower_height <=
                   0) {  //наша башня разрушена, и у врага разрушена
        if (am_Players[0].tower_height ==
            am_Players[1].tower_height) {  //если башни равны
            if (am_Players[0].wall_height ==
                am_Players[1].wall_height) {  //если стены равны
                winner = 0;
                victory_type = 4;
            } else {  //если стены не равны
                winner =
                    (am_Players[0].wall_height <= am_Players[1].wall_height) +
                    1;  //победил тот, у кого стена выше
                victory_type = 1;  //победа когда больше стена при ничье
            }
        } else {  //башни не равны
            winner =
                (am_Players[0].tower_height <= am_Players[1].tower_height) +
                1;  // побеждает тот у кого башня больше
            victory_type = 2;  //победил разрушив башню врага
        }
    }
 
    //проверка набраны ли ресурсы
    //проверка какого ресурса больше всего у игрока 1(нас)
    pl_resource =
        am_Players[0].resource_bricks;  //кирпичей больше чем др. ресурсов
    if (am_Players[0].resource_gems > am_Players[0].resource_bricks &&
        am_Players[0].resource_gems >
            am_Players[0].resource_beasts)  //драг.камней больше всего
        pl_resource = am_Players[0].resource_gems;
    else if (am_Players[0].resource_beasts > am_Players[0].resource_gems &&
             am_Players[0].resource_beasts >
                 am_Players[0].resource_bricks)  //зверей больше всего
        pl_resource = am_Players[0].resource_beasts;
 
    //проверка какого ресурса больше у игрока 2(врага)
    en_resource =
        am_Players[1].resource_bricks;  //кирпичей больше чем др. ресурсов
    if (am_Players[1].resource_gems > am_Players[1].resource_bricks &&
        am_Players[1].resource_gems >
            am_Players[1].resource_beasts)  //драг.камней больше всего
        en_resource = am_Players[1].resource_gems;
    else if (am_Players[1].resource_beasts > am_Players[1].resource_gems &&
             am_Players[1].resource_beasts >
                 am_Players[1].resource_bricks)  //зверей больше всего
        en_resource = am_Players[1].resource_beasts;
 
    //сравнение ресурсов игроков
    if (winner == -1 && victory_type == -1) {  //нет победителя по башням
        if (pl_resource < max_resources_amount &&
            en_resource >=
                max_resources_amount) {  //враг набрал нужное количество
            winner = 2;  // враг победил
            victory_type = 3;  //победа собрав нужное количество ресурсов
        } else if (pl_resource >= max_resources_amount &&
                   en_resource <
                       max_resources_amount) {  //мы набрали нужное количество
            winner = 1;  // мы победили
            victory_type = 3;  //победа собрав нужное количество ресурсов
        } else if (pl_resource >= max_resources_amount &&
                   en_resource >=
                       max_resources_amount) {  //и у нас и у врага нужное
                                                //количество ресурсов
            if (pl_resource == en_resource) {  // ресурсы равны
                winner = 0;        //ресурсы равны
                victory_type = 4;  //ничья
            } else {
                winner = (pl_resource <= en_resource) +
                         1;  //ресурсы не равны, побеждает тот у кого больше
                victory_type = 3;  //победа собрав нужное количество ресурсов
            }
        }
    } else if (winner == 0 && victory_type == 4) {  // при ничье по башням и стене
        if (pl_resource != en_resource) {  //ресурсы не равны
            winner =
                (pl_resource <= en_resource) + 1;  //победил тот у кого больше
            victory_type =
                5;  //победа когда при ничье большее количество ресурсов
        } else {    //ресурсы равны
            winner = 0;        //нет победителя
            victory_type = 4;  //ничья
        }
    }
 
    //подведение итогов
    pArcomageGame->Victory_type = victory_type;
    pArcomageGame->uGameWinner = winner;
    if (winner == 1) {  //победитель игрок 1(мы)
        if ((window_SpeakInHouse->par1C >= 108) &&
            (window_SpeakInHouse->par1C <= 120)) {  //таверны
            if (!pParty->pArcomageWins[window_SpeakInHouse->par1C - 108]) {
                pParty->pArcomageWins[window_SpeakInHouse->par1C - 108] = 1;
                pParty->PartyFindsGold(
                    p2DEvents[window_SpeakInHouse->par1C - 1].fPriceMultiplier *
                        100.0,
                    0);  //вознаграждение
            }
        }
        //проверка выполнен ли квест по аркомагу
        tavern_num = 0;
        for (uint i = 108; i <= 120; ++i) {
            if (!pParty->pArcomageWins[i - 108]) break;
            tavern_num++;
        }
        if (tavern_num == 13)
            _449B7E_toggle_bit(pParty->_quest_bits, 238,
                               1);  // 238 - Won all Arcomage games
 
        for (int i = 0; i < 4; ++i) {  //внесение записи в Заслуги
            if (!_449B57_test_bit(pParty->pPlayers[i]._achieved_awards_bits, PLAYER_GUILD_BITS__FINED))
                _449B7E_toggle_bit(pParty->pPlayers[i]._achieved_awards_bits,
                                   PLAYER_GUILD_BITS__ARCOMAGE_WIN, 1);
        }
        ++pParty->uNumArcomageWins;
        if (pParty->uNumArcomageWins > 1000000)  //ограничение количества побед
            pParty->uNumArcomageWins = 1000000;
    } else {  //проигрыш
        for (int i = 0; i < 4; ++i) {  //внесение записи в Заслуги
            if (!_449B57_test_bit(pParty->pPlayers[i]._achieved_awards_bits, PLAYER_GUILD_BITS__FINED))
                _449B7E_toggle_bit(pParty->pPlayers[i]._achieved_awards_bits,
                                   PLAYER_GUILD_BITS__ARCOMAGE_LOSE, 1);
        }
        ++pParty->uNumArcomageLoses;
        if (pParty->uNumArcomageLoses >
            1000000)  //ограничение количества проигрышей
            pParty->uNumArcomageLoses = 1000000;
    }
}

Перекрестные ссылки _449B57_test_bit(), _449B7E_toggle_bit(), Party::_quest_bits, am_Players, _2devent::fPriceMultiplier, max_resources_amount, max_tower_height, p2DEvents, GUIWindow::par1C, pArcomageGame, Party::pArcomageWins, Party::PartyFindsGold(), pParty, Party::pPlayers, ArcomagePlayer::resource_beasts, ArcomagePlayer::resource_bricks, ArcomagePlayer::resource_gems, ArcomagePlayer::tower_height, ArcomageGame::uGameWinner, Party::uNumArcomageLoses, Party::uNumArcomageWins, ArcomageGame::Victory_type, ArcomagePlayer::wall_height и window_SpeakInHouse.

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

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

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

am_DrawText()

void am_DrawText	(	const String &	str,
		Point *	pXY
	)

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

                                                {
    pPrimaryWindow->DrawText(pFontComic, pXY->x,
                             pXY->y - ((pFontComic->GetHeight() - 3) / 2) + 3,
                             0, str, 0, 0, 0);
}

Перекрестные ссылки GUIWindow::DrawText(), GUIFont::GetHeight(), pFontComic, pPrimaryWindow, Point::x и Point::y.

Используется в DrawGameUI(), DrawPlayersText() и TurnChange().

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

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

DrawRect()

void DrawRect	(	Rect *	pXYZW,
		unsigned __int16	uColor,
		char	bSolidFill
	)

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

                                                                     {
    if (bSolidFill) {
        for (int i = pXYZW->y; i <= pXYZW->w; ++i)
            render->RasterLine2D(pXYZW->x, i, pXYZW->z, i, uColor);
    } else {
        render->RasterLine2D(pXYZW->x, pXYZW->y, pXYZW->z, pXYZW->y, uColor);
        render->RasterLine2D(pXYZW->z, pXYZW->y, pXYZW->z, pXYZW->w, uColor);
        render->RasterLine2D(pXYZW->z, pXYZW->w, pXYZW->x, pXYZW->w, uColor);
        render->RasterLine2D(pXYZW->x, pXYZW->w, pXYZW->x, pXYZW->y, uColor);
    }
}

Перекрестные ссылки render, Rect::w, Rect::x, Rect::y и Rect::z.

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

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

rand_interval()

int rand_interval	(	int	min,
		int	max
	)

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

{ return min + rand() % (max - min + 1); }

Используется в GetNextCardFromDeck(), ArcomageGame::Loop(), OpponentsAITurn() и explosion_effect_struct::UpdateEffect().

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

am_IntToString()

void am_IntToString	(	int	val,
		char *	pOut
	)

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

{ sprintf(pOut, "%d", val); }

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

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

R8G8B8_to_TargetFormat()

unsigned int R8G8B8_to_TargetFormat

(

int

uColor

)

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

                                                {
    return Color16(uColor & 0xFF, (uColor >> 8) & 0xFF, (uColor >> 16) & 0xFF);
}

Перекрестные ссылки Color16().

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

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

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

OpponentsAITurn()

bool OpponentsAITurn

(

int

player_num

)

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

                                     {
    if (player_num == 0) __debugbreak();
 
    int ai_player_cards_count = GetPlayerHandCardCount(player_num);
    if (ai_player_cards_count == 0) return true;
 
    // opponent_mastery = 2; // testing
 
    opponents_turn = 1;
    if (opponent_mastery == 0) {
        // select card at random to play
        int random_card_slot;
        if (need_to_discard_card == 0) {
            for (int i = 0; i < 10; ++i) {
                random_card_slot = rand_interval(0, ai_player_cards_count - 1);
                if (CanCardBePlayed(player_num, random_card_slot))
                    return PlayCard(player_num, random_card_slot);
            }
        }
 
        // if that fails discard card at random
        random_card_slot = rand_interval(0, ai_player_cards_count - 1);
        return DiscardCard(player_num, random_card_slot);
 
    } else if ((opponent_mastery == 1) || (opponent_mastery == 2)) {
        // apply some cunning
        ArcomagePlayer* player = &am_Players[player_num];
        ArcomagePlayer* enemy = &am_Players[(player_num + 1) % 2];
 
        // wipe cards power array - set negative for unfilled card slots
        for (int i = 0; i < 10; ++i) {
            if (i >= ai_player_cards_count) {
                cards_power[i].slot_index = -1;
                cards_power[i].card_power = -9999;
            } else {
                cards_power[i].slot_index = i;
                cards_power[i].card_power = 0;
            }
        }
 
        // calculate how effective each card would be
        for (int i = 0; i < ai_player_cards_count; ++i) {
            ArcomageCard* calc_card = &pCards[am_Players[player_num].cards_at_hand[cards_power[i].slot_index]];
            cards_power[i].card_power =
                CalculateCardPower(player, enemy, calc_card, opponent_mastery - 1);
        }
 
        // bubble sort the card powers in order
        for (int j = ai_player_cards_count - 1; j >= 0; --j) {
            for (int m = 0; m < j; ++m) {
                if (cards_power[m].card_power < cards_power[m + 1].card_power) {
                    int tempslot = cards_power[m].slot_index;
                    int temppow = cards_power[m].card_power;
                    cards_power[m].slot_index = cards_power[m + 1].slot_index;
                    cards_power[m].card_power = cards_power[m + 1].card_power;
                    cards_power[m + 1].slot_index = tempslot;
                    cards_power[m + 1].card_power = temppow;
                }
            }
        }
 
        // if we have to discard pick the least powerful to chuck
        int discard_slot = 0;
        for (int i = ai_player_cards_count - 1; i; --i) {
            if (i >= 0) {
                if (pCards[am_Players[player_num].cards_at_hand[cards_power[i].slot_index]].can_be_discarded) {
                    discard_slot = cards_power[i].slot_index;
                }
            }
        }
 
        if (!need_to_discard_card) {
            // try and play most powerful card
            for (int i = 0; i < ai_player_cards_count - 1; ++i) {
                if (CanCardBePlayed(player_num, cards_power[i].slot_index) && cards_power[i].card_power) {
                    return PlayCard(player_num, cards_power[i].slot_index);
                }
            }
        }
 
        // fall back - have to discard
        return DiscardCard(player_num, discard_slot);
    }
    return true;  // result != 0;
}

Перекрестные ссылки __debugbreak(), am_Players, CalculateCardPower(), CanCardBePlayed(), am_ai_cardpowerstruct::card_power, ArcomagePlayer::cards_at_hand, cards_power, DiscardCard(), GetPlayerHandCardCount(), need_to_discard_card, opponent_mastery, opponents_turn, pCards, PlayCard(), rand_interval() и am_ai_cardpowerstruct::slot_index.

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

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

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

DiscardCard() [2/2]

bool DiscardCard	(	int	player_num,
		signed int	card_slot_index
	)

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

                                                             {
    // check for valid card slot
    if (card_slot_index <= -1) return false;
 
    // can the card be discarded
    if (pCards[am_Players[player_num].cards_at_hand[card_slot_index]].can_be_discarded) {
        // calc animation position and move speed
        int card_count = GetPlayerHandCardCount(current_player_num);
        int card_spacing = (window->GetWidth() - (96 * card_count)) / (card_count + 1);
 
        anim_card_pos_playdiscard.x = am_Players[player_num].card_shift[card_slot_index].x + (card_slot_index * (card_spacing + 96) + card_spacing);
        anim_card_pos_playdiscard.y = am_Players[player_num].card_shift[card_slot_index].y + 327;
 
        // find first free table slot
        int table_slot = 0;
        if (!hide_card_anim_start) {
            for (table_slot = 0; table_slot < 10; ++table_slot) {
                if (shown_cards[table_slot].uCardId == -1) break;
            }
        }
 
        anim_card_spd_playdiscard.x = ((int)shown_cards[table_slot].table_pos.x - (int)anim_card_pos_playdiscard.x) / 10;
        anim_card_spd_playdiscard.y = ((int)shown_cards[table_slot].table_pos.y - (int)anim_card_pos_playdiscard.y) / 10;
 
        // play sound - set anim card and remove from player
        ArcomageGame::PlaySound(22);
        discarded_card_id = am_Players[player_num].cards_at_hand[card_slot_index];
        am_Players[player_num].cards_at_hand[card_slot_index] = -1;
        need_to_discard_card = 0;
        pArcomageGame->force_redraw_1 = 1;
 
        return true;
    } else {
        // cannot make this move
        return false;
    }
}

Перекрестные ссылки am_Players, anim_card_pos_playdiscard, anim_card_spd_playdiscard, ArcomagePlayer::card_shift, ArcomagePlayer::cards_at_hand, current_player_num, discarded_card_id, ArcomageGame::force_redraw_1, GetPlayerHandCardCount(), hide_card_anim_start, need_to_discard_card, pArcomageGame, pCards, ArcomageGame::PlaySound(), shown_cards, Point::x, sPoint::x, Point::y и sPoint::y.

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

set_stru1_field_8_InArcomage()

void set_stru1_field_8_InArcomage

(

int

inValue

)

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

                                               {  // what is this meant to be doing??
    switch (inValue) {
        case 91:
            HEXRAYS_LOBYTE(pArcomageGame->stru1.am_input_key) = 123;
            break;
        case 92:
            HEXRAYS_LOBYTE(pArcomageGame->stru1.am_input_key) = 124;
            break;
        case 93:
            HEXRAYS_LOBYTE(pArcomageGame->stru1.am_input_key) = 125;
            break;
        case 96:
            HEXRAYS_LOBYTE(pArcomageGame->stru1.am_input_key) = 126;
            break;
        case 61:
            HEXRAYS_LOBYTE(pArcomageGame->stru1.am_input_key) = 43;
            break;
        case 55:
            HEXRAYS_LOBYTE(pArcomageGame->stru1.am_input_key) = 38;
            break;
        case 56:
            HEXRAYS_LOBYTE(pArcomageGame->stru1.am_input_key) = 42;
            break;
        case 57:
            HEXRAYS_LOBYTE(pArcomageGame->stru1.am_input_key) = 40;
            break;
        case 59:
            HEXRAYS_LOBYTE(pArcomageGame->stru1.am_input_key) = 58;
            break;
        case 54:
            HEXRAYS_LOBYTE(pArcomageGame->stru1.am_input_key) = 94;
            break;
        case 50:
            HEXRAYS_LOBYTE(pArcomageGame->stru1.am_input_key) = 64;
            break;
        case 51:
            HEXRAYS_LOBYTE(pArcomageGame->stru1.am_input_key) = 35;
            break;
        case 52:
            HEXRAYS_LOBYTE(pArcomageGame->stru1.am_input_key) = 36;
            break;
        case 53:
            HEXRAYS_LOBYTE(pArcomageGame->stru1.am_input_key) = 37;
            break;
        case 49:
            HEXRAYS_LOBYTE(pArcomageGame->stru1.am_input_key) = 33;
            break;
        case 39:
            HEXRAYS_LOBYTE(pArcomageGame->stru1.am_input_key) = 34;
            break;
        case 44:
            HEXRAYS_LOBYTE(pArcomageGame->stru1.am_input_key) = 60;
            break;
        case 46:
            HEXRAYS_LOBYTE(pArcomageGame->stru1.am_input_key) = 62;
            break;
        case 47:
            HEXRAYS_LOBYTE(pArcomageGame->stru1.am_input_key) = 63;
            break;
        case 48:
            HEXRAYS_LOBYTE(pArcomageGame->stru1.am_input_key) = 41;
            break;
        default:
            HEXRAYS_LOBYTE(pArcomageGame->stru1.am_input_key) = inValue;
            break;
    }
}

Используется в Application::GameWindowHandler::OnVkDown().

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

Переменные

start_conditions

const ArcomageStartConditions start_conditions[13]

Инициализатор

= {
    {30, 100, 15, 5, 2, 2, 2, 10, 10, 10, 0},
    {50, 150, 20, 5, 2, 2, 2, 5, 5, 5, 1},
    {50, 150, 20, 5, 2, 2, 2, 5, 5, 5, 2},
    {75, 200, 25, 10, 3, 3, 3, 5, 5, 5, 2},
    {75, 200, 20, 10, 3, 3, 3, 5, 5, 5, 1},
    {100, 300, 30, 15, 4, 4, 4, 10, 10, 10, 1},
    {100, 300, 30, 15, 4, 4, 4, 10, 10, 10, 2},
    {150, 400, 20, 10, 5, 5, 5, 25, 25, 25, 0},
    {200, 500, 20, 10, 1, 1, 1, 15, 15, 15, 2},
    {100, 300, 20, 50, 1, 1, 5, 5, 5, 25, 0},
    {125, 350, 10, 20, 3, 1, 2, 15, 5, 10, 2},
    {125, 350, 10, 20, 3, 1, 2, 15, 5, 10, 1},
    {100, 300, 50, 50, 5, 3, 5, 20, 10, 20, 0}}

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

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

pArcomageGame

ArcomageGame* pArcomageGame = new ArcomageGame

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

Используется в Render::am_Blt_Chroma(), ApplyCardToPlayer(), DiscardCard(), DrawCardAnimation(), DrawCards(), DrawGameUI(), DrawPlayerLevels(), DrawPlayersText(), DrawPlayersTowers(), DrawPlayersWall(), DrawRectanglesForText(), Application::Game::EventLoop(), FillPlayerDeck(), Application::Game::GameLoop(), GameResultsApply(), GetNextCardFromDeck(), InitalHandsFill(), ArcomageGame::LoadSprites(), ArcomageGame::Loop(), ArcomageGame::MsgLoop(), Application::GameWindowHandler::OnActivated(), ArcomageGame::OnMouseClick(), Application::GameWindowHandler::OnMouseLeftClick(), Application::GameWindowHandler::OnMouseLeftDoubleClick(), Application::GameWindowHandler::OnMouseLeftUp(), Application::GameWindowHandler::OnMouseMove(), ArcomageGame::OnMouseMove(), Application::GameWindowHandler::OnMouseRightClick(), Application::GameWindowHandler::OnMouseRightDoubleClick(), Application::GameWindowHandler::OnMouseRightUp(), Application::GameWindowHandler::OnPaint(), Application::GameWindowHandler::OnVkDown(), PlayCard(), PlayerTurn(), ArcomageGame::PrepareArcomage(), set_stru1_field_8_InArcomage(), SetStartGameData(), TavernDialog(), TurnChange() и arcomage_mouse::Update().

am_Players

ArcomagePlayer am_Players[2]

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

Используется в ApplyCardToPlayer(), ApplyDamageToBuildings(), CanCardBePlayed(), DiscardCard(), DrawCardAnimation(), DrawCards(), DrawCardsRectangles(), DrawPlayersText(), DrawPlayersTowers(), DrawPlayersWall(), FillPlayerDeck(), GameResultsApply(), GetEmptyCardSlotIndex(), GetNextCardFromDeck(), GetPlayerHandCardCount(), IncreaseResourcesInTurn(), IsGameOver(), ArcomageGame::Loop(), OpponentsAITurn(), PlayCard(), PlayerTurn(), SetStartGameData() и TurnChange().

shown_cards

AcromageCardOnTable shown_cards[10]

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

Используется в DiscardCard(), DrawCardAnimation(), DrawCards() и ArcomageGame::PrepareArcomage().

am_effects_array

am_effects_struct am_effects_array[10]

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

Используется в DrawGameUI(), DrawSparks(), ArcomageGame::Loop(), new_explosion_effect() и ArcomageGame::PrepareArcomage().

playDeck

ArcomageDeck playDeck

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

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

deckMaster

ArcomageDeck deckMaster

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

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

Player2Name

char Player2Name[] = "Enemy"

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

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

Player1Name

char Player1Name[] = "Player"

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

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

cards_power

am_ai_cardpowerstruct cards_power[10]

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

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

Player_Gets_First_Turn

bool Player_Gets_First_Turn = 1

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

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

Player_Cards_Shift

bool Player_Cards_Shift = 1

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

Используется в DrawCardAnimation(), DrawCards(), DrawCardsRectangles() и SetStartGameData().

use_start_bonus

char use_start_bonus = 1

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

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

start_tower_height

int start_tower_height

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

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

start_wall_height

int start_wall_height

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

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

start_quarry_level

int start_quarry_level

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

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

start_magic_level

int start_magic_level

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

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

start_zoo_level

int start_zoo_level

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

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

start_bricks_amount

int start_bricks_amount

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

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

start_gems_amount

int start_gems_amount

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

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

start_beasts_amount

int start_beasts_amount

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

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

minimum_cards_at_hand

int minimum_cards_at_hand = 5

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

Используется в ApplyCardToPlayer(), InitalHandsFill(), ArcomageGame::Loop(), PlayerTurn() и SetStartConditions().

quarry_bonus

int quarry_bonus = 1

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

Используется в DrawPlayersText(), IncreaseResourcesInTurn() и SetStartConditions().

magic_bonus

int magic_bonus = 1

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

Используется в DrawPlayersText(), IncreaseResourcesInTurn() и SetStartConditions().

zoo_bonus

int zoo_bonus = 1

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

Используется в DrawPlayersText(), IncreaseResourcesInTurn() и SetStartConditions().

max_tower_height

int max_tower_height = 50

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

Используется в CalculateCardPower(), DrawPlayersTowers(), GameResultsApply(), IsGameOver() и SetStartConditions().

max_resources_amount

int max_resources_amount = 100

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

Используется в GameResultsApply(), IsGameOver() и SetStartConditions().

opponent_mastery

int opponent_mastery = 1

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

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

opponents_turn

char opponents_turn

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

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

See_Opponents_Cards

char See_Opponents_Cards = 0

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

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

current_player_num

int current_player_num

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

Используется в DiscardCard(), DrawCardAnimation(), DrawCards(), DrawGameUI(), DrawPlayersText(), ArcomageGame::Loop(), PlayCard(), PlayerTurn(), SetStartGameData() и TurnChange().

need_to_discard_card

char need_to_discard_card

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

Используется в ApplyCardToPlayer(), DiscardCard(), DrawPlayersText(), ArcomageGame::Loop(), OpponentsAITurn(), PlayerTurn() и ArcomageGame::PrepareArcomage().

current_card_slot_index

int current_card_slot_index

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

Используется в DrawGameUI(), PlayerTurn() и ArcomageGame::PrepareArcomage().

played_card_id

int played_card_id

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

Используется в DrawCardAnimation(), ArcomageGame::Loop() и PlayCard().

discarded_card_id

int discarded_card_id

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

Используется в DiscardCard(), DrawCardAnimation() и PlayerTurn().

deck_walk_index

int deck_walk_index

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

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

Card_Hover_Index

int Card_Hover_Index

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

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

num_cards_to_discard

int num_cards_to_discard

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

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

num_actions_left

int num_actions_left

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

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

anim_card_spd_drawncard

sPoint anim_card_spd_drawncard

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

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

anim_card_pos_drawncard

Point anim_card_pos_drawncard

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

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

anim_card_spd_playdiscard

sPoint anim_card_spd_playdiscard

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

Используется в DiscardCard(), DrawCardAnimation() и PlayCard().

anim_card_pos_playdiscard

Point anim_card_pos_playdiscard

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

Используется в DiscardCard(), DrawCardAnimation() и PlayCard().

drawn_card_anim_start

char drawn_card_anim_start

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

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

drawn_card_anim_cnt

int drawn_card_anim_cnt

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

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

drawn_card_slot_index

int drawn_card_slot_index

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

Используется в DrawCardAnimation(), DrawCards(), GetNextCardFromDeck(), PlayerTurn() и ArcomageGame::PrepareArcomage().

playdiscard_anim_start

char playdiscard_anim_start

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

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

hide_card_anim_start

char hide_card_anim_start

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

Используется в DiscardCard(), DrawCards(), PlayerTurn(), ArcomageGame::PrepareArcomage() и TurnChange().

hide_card_anim_runnning

char hide_card_anim_runnning

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

Используется в DrawCards(), PlayerTurn() и ArcomageGame::PrepareArcomage().

hide_card_anim_count

int hide_card_anim_count

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

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