Классы
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;
 }

◆ 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.

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

◆ 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().

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

◆ 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.

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

◆ 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.

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

◆ 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.

◆ 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.

◆ 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.

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

◆ 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.

◆ 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;
 }

◆ 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.

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

◆ 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().

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

◆ 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.

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

◆ 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.

◆ 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.

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

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

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

◆ 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.

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

◆ 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.

◆ DrawCardsRectangles()

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.

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

◆ DiscardCard() [1/2]

bool DiscardCard	(	int	player_num,
		int	card_slot_index
	)

◆ 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.

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

◆ 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.

◆ 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
 }

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

◆ 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;
 }

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

◆ 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.

◆ 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.

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

◆ 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.

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

◆ 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.

◆ rand_interval()

int rand_interval	(	int	min,
		int	max
	)

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

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

◆ am_IntToString()

void am_IntToString	(	int	val,
		char *	pOut
	)

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

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

◆ R8G8B8_to_TargetFormat()

unsigned int R8G8B8_to_TargetFormat ( int uColor )

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

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

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

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

◆ 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.

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

◆ 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;
     }
 }

Перекрестные ссылки ArcomageGame_InputMSG::am_input_key, pArcomageGame и ArcomageGame::stru1.

Переменные

◆ 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

◆ pArcomageGame

ArcomageGame* pArcomageGame = new ArcomageGame

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

◆ am_Players

ArcomagePlayer am_Players[2]

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

◆ shown_cards

AcromageCardOnTable shown_cards[10]

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

◆ am_effects_array

am_effects_struct am_effects_array[10]

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

◆ playDeck

ArcomageDeck playDeck

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

◆ deckMaster

ArcomageDeck deckMaster

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

◆ Player2Name

char Player2Name[] = "Enemy"

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

◆ Player1Name

char Player1Name[] = "Player"

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

◆ cards_power

am_ai_cardpowerstruct cards_power[10]

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

◆ Player_Gets_First_Turn

bool Player_Gets_First_Turn = 1

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

◆ Player_Cards_Shift

bool Player_Cards_Shift = 1

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

◆ use_start_bonus

char use_start_bonus = 1

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

◆ start_tower_height

int start_tower_height

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

◆ start_wall_height

int start_wall_height

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

◆ start_quarry_level

int start_quarry_level

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

◆ start_magic_level

int start_magic_level

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

◆ start_zoo_level

int start_zoo_level

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

◆ start_bricks_amount

int start_bricks_amount

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

◆ start_gems_amount

int start_gems_amount

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

◆ start_beasts_amount

int start_beasts_amount

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

◆ minimum_cards_at_hand

int minimum_cards_at_hand = 5

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

◆ quarry_bonus

int quarry_bonus = 1

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

◆ magic_bonus

int magic_bonus = 1

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

◆ zoo_bonus

int zoo_bonus = 1

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

◆ max_tower_height

int max_tower_height = 50

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

◆ max_resources_amount

int max_resources_amount = 100

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

◆ opponent_mastery

int opponent_mastery = 1

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

◆ opponents_turn

char opponents_turn

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

◆ See_Opponents_Cards

char See_Opponents_Cards = 0

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

◆ current_player_num

int current_player_num

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

◆ need_to_discard_card

char need_to_discard_card

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

◆ current_card_slot_index

int current_card_slot_index

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

◆ played_card_id

int played_card_id

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

◆ discarded_card_id

int discarded_card_id

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

◆ deck_walk_index

int deck_walk_index

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

◆ Card_Hover_Index

int Card_Hover_Index

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

◆ num_cards_to_discard

int num_cards_to_discard

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

◆ num_actions_left

int num_actions_left

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

◆ anim_card_spd_drawncard

sPoint anim_card_spd_drawncard

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

◆ anim_card_pos_drawncard

Point anim_card_pos_drawncard

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

◆ anim_card_spd_playdiscard

sPoint anim_card_spd_playdiscard

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

◆ anim_card_pos_playdiscard

Point anim_card_pos_playdiscard

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

◆ drawn_card_anim_start

char drawn_card_anim_start

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

◆ drawn_card_anim_cnt

int drawn_card_anim_cnt

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

◆ drawn_card_slot_index

int drawn_card_slot_index

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

◆ playdiscard_anim_start

char playdiscard_anim_start

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

◆ hide_card_anim_start

char hide_card_anim_start

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

◆ hide_card_anim_runnning

char hide_card_anim_runnning

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

◆ hide_card_anim_count

int hide_card_anim_count

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

Классы

Функции

Переменные

Функции

◆ SetStartConditions()

◆ SetStartGameData()

◆ FillPlayerDeck()

◆ InitalHandsFill()

◆ GetNextCardFromDeck()

◆ GetEmptyCardSlotIndex()

◆ IncreaseResourcesInTurn()

◆ TurnChange()

◆ IsGameOver()

◆ CalculateCardPower()

◆ PlayerTurn()

◆ DrawGameUI()

◆ DrawSparks()

◆ DrawRectanglesForText()

◆ DrawPlayersText()

◆ DrawPlayerLevels()

◆ DrawBricksCount()

◆ DrawGemsCount()

◆ DrawBeastsCount()

◆ DrawPlayersTowers()

◆ DrawPlayersWall()

◆ DrawCards()

◆ DrawCardAnimation()

◆ GetPlayerHandCardCount()

◆ DrawCardsRectangles()

◆ DiscardCard() [1/2]

◆ PlayCard()

◆ CanCardBePlayed()

◆ ApplyCardToPlayer()

◆ new_explosion_effect()

◆ ApplyDamageToBuildings()

◆ GameResultsApply()

◆ am_DrawText()

◆ DrawRect()

◆ rand_interval()

◆ am_IntToString()

◆ R8G8B8_to_TargetFormat()

◆ OpponentsAITurn()

◆ DiscardCard() [2/2]

◆ set_stru1_field_8_InArcomage()

Переменные

◆ start_conditions

◆ pArcomageGame

◆ am_Players

◆ shown_cards

◆ am_effects_array

◆ playDeck

◆ deckMaster

◆ Player2Name

◆ Player1Name

◆ cards_power

◆ Player_Gets_First_Turn

◆ Player_Cards_Shift

◆ use_start_bonus

◆ start_tower_height

◆ start_wall_height

◆ start_quarry_level

◆ start_magic_level

◆ start_zoo_level

◆ start_bricks_amount

◆ start_gems_amount

◆ start_beasts_amount

◆ minimum_cards_at_hand

◆ quarry_bonus

◆ magic_bonus

◆ zoo_bonus

◆ max_tower_height

◆ max_resources_amount

◆ opponent_mastery

◆ opponents_turn

◆ See_Opponents_Cards

◆ current_player_num

◆ need_to_discard_card

◆ current_card_slot_index

◆ played_card_id

◆ discarded_card_id