Exemple #1
0
        internal static void combat_menu(Player player) /* camp_menu */
        {
            int spell_id;
            DownedPlayerTile var_D = new DownedPlayerTile();
            char             var_1;

            if (player.in_combat == true)
            {
                if (player.actions.spell_id > 0)
                {
                    spell_id = player.actions.spell_id;
                    player.actions.spell_id = 0;

                    ovr023.sub_5D2E1(true, QuickFight.False, spell_id);
                    ovr025.clear_actions(player);
                }
                else
                {
                    bool var_2 = false;

                    while (var_2 == false)
                    {
                        combat_menu(out var_1, player);

                        if (gbl.displayInput_specialKeyPressed == false)
                        {
                            switch (var_1)
                            {
                            case 'Q':
                                SetPlayerQuickFight(player);
                                ovr027.ClearPromptArea();
                                seg043.clear_keyboard();
                                seg049.SysDelay(0x0C8);
                                var_2 = true;
                                ovr010.PlayerQuickFight(player);
                                break;

                            case 'M':
                                sub_33B26(ref var_2, ' ', player);
                                break;

                            case 'V':
                                var_2 = ovr020.viewPlayer();
                                ovr014.reclac_attacks(player);
                                if (var_2 == false)
                                {
                                    ovr025.RedrawCombatScreen();
                                }
                                break;

                            case 'A':
                                var_2 = ovr014.aim_menu(var_D, true, false, true, -1, player);
                                break;

                            case 'U':
                                gbl.menuSelectedWord = 2;
                                ovr020.PlayerItemsMenu(ref var_2);
                                ovr014.reclac_attacks(player);
                                if (var_2 == false)
                                {
                                    ovr025.RedrawCombatScreen();
                                }
                                break;

                            case 'C':
                                ovr014.spell_menu3(out var_2, 0, 0);
                                break;

                            case 'T':
                                ovr014.turns_undead(player);
                                var_2 = true;
                                ovr025.clear_actions(player);
                                break;

                            case 'D':
                                delay_menu(ref var_2, player);
                                break;

                            case ' ':
                                /* Turn off auto-fight. */
                                foreach (Player p in gbl.TeamList)
                                {
                                    if (p.control_morale < Control.NPC_Base)
                                    {
                                        p.quick_fight = QuickFight.False;
                                    }
                                }
                                break;
                            }
                        }
                        else
                        {
                            switch (var_1)
                            {
                            case 'G':
                            case 'H':
                            case 'K':
                            case 'M':
                            case 'O':
                            case 'P':
                            case 'Q':
                            case 'I':
                                sub_33B26(ref var_2, var_1, player);
                                break;

                            case '2':
                                gbl.AutoPCsCastMagic = !gbl.AutoPCsCastMagic;

                                if (gbl.AutoPCsCastMagic == true)
                                {
                                    ovr025.string_print01("Magic On");
                                }
                                else
                                {
                                    ovr025.string_print01("Magic Off");
                                }
                                break;

                            case (char)0x10:
                                player.actions.delay = 20;
                                foreach (Player p in gbl.TeamList)
                                {
                                    SetPlayerQuickFight(p);
                                }
                                ovr027.ClearPromptArea();
                                seg049.SysDelay(0x0C8);

                                var_2 = true;
                                break;

                            case '-':
                                if (ovr014.god_intervene() == true)
                                {
                                    ovr033.RedrawCombatIfFocusOn(false, 3, player);
                                    var_2 = true;
                                }
                                else
                                {
                                    ovr025.string_print01("That doesn't work");
                                }
                                break;
                            }
                        }

                        if (var_2 == false)
                        {
                            ovr033.RedrawCombatIfFocusOn(true, 2, player);
                            gbl.display_hitpoints_ac = true;
                            ovr025.CombatDisplayPlayerSummary(player);
                        }
                    }
                }
            }
            else
            {
                ovr025.clear_actions(player);
            }
        }
Exemple #2
0
        static void PlaceCombatants() /* sub_387FE */
        {
            ovr025.CountCombatTeamMembers();

            for (int i = 1; i <= gbl.MaxCombatantCount; i++)
            {
                gbl.CombatMap[i].size = 0;
            }
            ovr033.setup_mapToPlayerIndex_and_playerScreen();

            gbl.team_start_x[0]   = 0;
            gbl.team_start_y[0]   = 0;
            gbl.team_direction[0] = gbl.mapDirection / 2;

            gbl.team_start_x[1]   = (gbl.area2_ptr.encounter_distance * gbl.MapDirectionXDelta[gbl.mapDirection]) + gbl.team_start_x[0];
            gbl.team_start_y[1]   = (gbl.area2_ptr.encounter_distance * gbl.MapDirectionYDelta[gbl.mapDirection]) + gbl.team_start_y[0];
            gbl.team_direction[1] = ((gbl.mapDirection + 4) % 8) / 2;

            gbl.half_team_count[0] = (gbl.friends_count + 1) / 2;
            gbl.half_team_count[1] = (gbl.foe_count + 1) / 2;

            for (gbl.currentTeam = 0; gbl.currentTeam < 2; gbl.currentTeam++)
            {
                for (int var_C = 0; var_C < 4; var_C++)
                {
                    int direction;
                    if (var_C == 1)
                    {
                        direction = 4;
                    }
                    else
                    {
                        direction = gbl.team_direction[gbl.currentTeam];
                    }

                    for (int var_2 = 0; var_2 < 6; var_2++)
                    {
                        for (int var_1 = 0; var_1 < 11; var_1++)
                        {
                            if (unk_16620[direction, var_2, 0] > var_1 ||
                                unk_16620[direction, var_2, 1] < var_1)
                            {
                                unk_1AB1C[gbl.currentTeam, var_C, var_2, var_1] = 0;
                            }
                            else
                            {
                                unk_1AB1C[gbl.currentTeam, var_C, var_2, var_1] = 1;
                            }
                        }
                    }
                }
            }

            int loop_var = 1;

            gbl.CombatantCount = 0;

            List <Player> to_remove = new List <Player>();

            foreach (Player player in gbl.TeamList)
            {
                seg043.clear_one_keypress();

                gbl.player_array[loop_var] = player;

                gbl.currentTeam = (sbyte)player.combat_team;

                gbl.CombatMap[loop_var].size = player.field_DE & 7;

                if (place_combatant(loop_var) == true)
                {
                    if (player.in_combat == false)
                    {
                        gbl.CombatMap[loop_var].size = 0;

                        if (gbl.combat_type == CombatType.normal &&
                            player.actions.nonTeamMember == false)
                        {
                            var pos = gbl.CombatMap[loop_var].pos;

                            var b = new DownedPlayerTile();
                            gbl.downedPlayers.Add(b);

                            b.originalBackgroundTile = gbl.mapToBackGroundTile[pos];
                            b.target = player;
                            b.map    = pos;

                            gbl.mapToBackGroundTile[pos] = 0x1F;
                        }
                    }

                    gbl.CombatantCount++;
                    ovr033.setup_mapToPlayerIndex_and_playerScreen();
                    loop_var++;
                }
                else
                {
                    gbl.CombatMap[loop_var].size = 0;

                    if (player.actions.nonTeamMember == true)
                    {
                        gbl.player_array[loop_var] = null;
                        to_remove.Add(player);
                    }
                    else
                    {
                        gbl.CombatantCount++;
                    }
                }
            }

            foreach (Player player in to_remove)
            {
                gbl.SelectedPlayer = ovr018.FreeCurrentPlayer(player, false, true);
            }
        }
Exemple #3
0
        internal static void CombatantKilled(Player player) // sub_74E6F
        {
            if (gbl.game_state != GameState.Combat)
            {
                seg044.PlaySound(Sound.sound_5);
                Seg041.GameDelay();
            }
            else
            {
                bool downedPlayer = gbl.downedPlayers.Exists(cell => cell.target == player);

                if (!downedPlayer)
                {
                    int player_index = GetPlayerIndex(player);
                    var map          = ovr033.PlayerMapPos(player);

                    if (PlayerOnScreen(true, player) == false)
                    {
                        redrawCombatArea(8, 3, map);
                    }

                    RedrawPlayerBackground(player_index);
                    seg044.PlaySound(Sound.sound_5);

                    // Draw skull overlay
                    DaxBlock attackIcon = gbl.combat_icons[24].GetIcon(Icon.Attack, 0);
                    DaxBlock normalIcon = gbl.combat_icons[25].GetIcon(Icon.Normal, 0);
                    var      points     = BuildSizeMap(gbl.CombatMap[player_index].size, gbl.CombatMap[player_index].screenPos);
                    for (int var_3 = 0; var_3 <= 8; var_3++)
                    {
                        foreach (var pos in points)
                        {
                            if (CoordOnScreen(pos) == true)
                            {
                                DaxBlock tmp = ((var_3 & 1) == 0) ? attackIcon : normalIcon;

                                seg040.OverlayBounded(tmp, 5, 0, (pos.y) * 3, (pos.x) * 3);
                            }
                        }

                        seg040.DrawOverlay();
                        seg049.SysDelay(10);
                    }

                    // Add downed corpse for team players.
                    if (player.actions.nonTeamMember == false)
                    {
                        var b = new DownedPlayerTile();

                        gbl.downedPlayers.Add(b);
                        b.originalBackgroundTile = gbl.mapToBackGroundTile[map];
                        b.target = player;
                        b.map    = map;

                        if (gbl.mapToBackGroundTile[map] != gbl.Tile_StinkingCloud)
                        {
                            gbl.mapToBackGroundTile[map] = gbl.Tile_DownPlayer;
                        }
                    }


                    // clean-up combat stuff
                    Seg041.GameDelay();
                    RedrawPlayerBackground(player_index);

                    gbl.CombatMap[GetPlayerIndex(player)].size = 0;

                    setup_mapToPlayerIndex_and_playerScreen();

                    redrawCombatArea(8, 3, gbl.mapToBackGroundTile.mapScreenTopLeft + Point.ScreenCenter);

                    player.actions.delay    = 0;
                    player.actions.move     = 0;
                    player.actions.spell_id = 0;
                    player.actions.guarding = false;
                }
            }
        }