Пример #1
0
        static void rest_heal(bool show_text) /* reset_heal */
        {
            gbl.rest_10_seconds++;

            if (gbl.rest_10_seconds >= (8 * 36))
            {
                bool update_ui = false;

                foreach (Player player in gbl.TeamList)
                {
                    if (ovr024.heal_player(0, 1, player) == true)
                    {
                        update_ui = true;
                    }
                }

                if (show_text == true)
                {
                    display_resting_time(0);
                }

                Seg041.DisplayString("The Whole Party Is Healed", 0, 10, 19, 1);

                if (update_ui)
                {
                    ovr025.PartySummary(gbl.SelectedPlayer);
                }

                Seg041.GameDelay();
                ovr025.ClearPlayerTextArea();
                gbl.rest_10_seconds = 0;
            }
        }
Пример #2
0
        DisplayPlayerStatusString(bool clearDisplay, int lineY, string text, Player player)     /* sub_67788 */
        {
            if (gbl.game_state == GameState.Combat)
            {
                seg037.draw8x8_clear_area(0x15, 0x26, lineY, 0x17);

                displayPlayerName(false, lineY, 0x17, player);
                Seg041.press_any_key(text, true, 10, 0x15, 0x26, lineY + 1, 0x17);
            }
            else
            {
                int line_y = gbl.displayPlayerStatusLine18 ? 18 : 17;

                seg037.draw8x8_clear_area(0x16, 0x26, line_y, 1);

                displayPlayerName(false, line_y + 1, 1, player);
                Seg041.press_any_key(text, true, 10, 0x16, 0x26, line_y + 2, 1);
            }

            if (clearDisplay == true)
            {
                Seg041.GameDelay();
                ovr025.ClearPlayerTextArea();
            }
        }
Пример #3
0
        internal static void string_print01(string text)
        {
            ovr027.ClearPromptAreaNoUpdate();

            Seg041.DisplayString(text, 0, 10, 0x18, 0);

            Seg041.GameDelay();

            ovr027.ClearPromptAreaNoUpdate();
        }
Пример #4
0
        internal static void MagicAttackDisplay(string text, bool showMagicStars, Player player) // sub_6818A
        {
            if (gbl.game_state == GameState.Combat)
            {
                int iconId = showMagicStars ? 0x16 : 0x17;

                load_missile_icons(iconId);

                if (ovr033.PlayerOnScreen(true, player) == false)
                {
                    ovr033.redrawCombatArea(8, 3, ovr033.PlayerMapPos(player));
                }

                if (showMagicStars)
                {
                    seg044.PlaySound(Sound.sound_4);
                }
                else
                {
                    seg044.PlaySound(Sound.sound_3);
                }

                DisplayPlayerStatusString(false, 10, text, player);

                int   idx = ovr033.GetPlayerIndex(player);
                Point pos = gbl.CombatMap[idx].screenPos * 3;

                int loops = showMagicStars ? gbl.game_speed_var : 0;
                for (int loop = 0; loop <= loops; loop++)
                {
                    for (int frame = 0; frame <= 3; frame++)
                    {
                        Display.SaveVidRam();

                        seg040.OverlayBounded(gbl.missile_dax, 5, frame, pos.y, pos.x);
                        seg040.DrawOverlay();

                        seg049.SysDelay(70);

                        Display.RestoreVidRam();
                    }
                }

                seg040.DrawOverlay();

                if (loops == 0)
                {
                    Seg041.GameDelay();
                }
            }
            else
            {
                DisplayPlayerStatusString(true, 10, text, player);
            }
        }
Пример #5
0
        internal static void BattleSetup() // battle_begins
        {
            gbl.DelayBetweenCharacters = false;

            ovr030.DaxArrayFreeDaxBlocks(gbl.byte_1D556);

            gbl.headX_dax       = null;
            gbl.bodyX_dax       = null;
            gbl.bigpic_dax      = null;
            gbl.bigpic_block_id = 0xff;
            gbl.current_head_id = 0xff;
            gbl.current_body_id = 0xff;
            ovr027.ClearPromptArea();
            Seg041.GameDelay();

            Seg041.DisplayString("A battle begins...", 0, 0x0a, 0x18, 0);

            gbl.AutoPCsCastMagic             = false; // TODO review this...
            gbl.combat_round                 = 0;
            gbl.combat_round_no_action_limit = gbl.combat_round_no_action_value;
            gbl.attack_roll = 0;

            gbl.StinkingCloud  = new List <GasCloud>();
            gbl.CloudKillCloud = new List <GasCloud>();
            gbl.item_ptr       = null;

            gbl.downedPlayers = new List <DownedPlayerTile>();

            gbl.area2_ptr.field_666 = 0;

            SetupGroundTiles();

            SetupCombatActions();
            PlaceCombatants();

            seg043.clear_one_keypress();

            gbl.missile_dax = new DaxBlock(4, 3, 0x18);

            Point pos = ovr033.PlayerMapPos(gbl.TeamList[0]);

            gbl.mapToBackGroundTile.mapScreenTopLeft = pos - Point.ScreenCenter;

            ovr025.RedrawCombatScreen();
            foreach (Player player in gbl.TeamList)
            {
                ovr024.CheckAffectsEffect(player, CheckType.Type_8);
                ovr024.CheckAffectsEffect(player, CheckType.Type_22);
            }

            ovr014.calc_enemy_health_percentage();
            gbl.game_state = GameState.Combat;
        }
Пример #6
0
        /// <summary>
        /// returns if the party is interrupted
        /// </summary>
        internal static bool resting(bool interactive_resting) /* reseting */
        {
            bool stop_resting;
            bool resting_intetrupted = false;

            System.Array.Clear(spellLaernTimeout, 0, gbl.TeamList.Count);

            for (int i = 0; i < 0x48; i++)
            {
                gbl.affects_timed_out[i] = true;
            }

            int var_C           = 0;
            int display_counter = 0;

            if (interactive_resting == true)
            {
                seg037.draw8x8_clear_area(TextRegion.NormalBottom);
                display_resting_time(0);
            }

            gbl.displayPlayerStatusLine18 = true;

            if (interactive_resting == true)
            {
                stop_resting = !resting_time_menu();
            }
            else
            {
                stop_resting = false;
            }

            while (stop_resting == false &&
                   (gbl.timeToRest.field_8 > 0 ||
                    gbl.timeToRest.field_6 > 0 ||
                    gbl.timeToRest.field_4 > 0 ||
                    gbl.timeToRest.field_2 > 0))
            {
                if (interactive_resting == true &&
                    seg049.KEYPRESSED() == true)
                {
                    display_resting_time(0);

                    if (ovr027.yes_no(gbl.defaultMenuColors, "Stop Resting? ") == 'Y')
                    {
                        stop_resting = true;
                    }
                    else
                    {
                        ovr027.ClearPromptArea();
                    }
                }

                if (stop_resting == false)
                {
                    rest_time_5849F(1, 5);
                    display_counter++;

                    if (interactive_resting == true &&
                        display_counter >= 5)
                    {
                        display_resting_time(0);
                        display_counter = 0;
                    }

                    step_game_time(1, 5);
                    rest_heal(interactive_resting);
                    CheckForSpellLearning();
                    sub_58C03(ref var_C);

                    if (gbl.area2_ptr.rest_incounter_period > 0)
                    {
                        gbl.rest_incounter_count++;

                        if (gbl.rest_incounter_count >= gbl.area2_ptr.rest_incounter_period)
                        {
                            gbl.rest_incounter_count = 0;

                            if (ovr024.roll_dice(100, 1) <= gbl.area2_ptr.rest_incounter_percentage)
                            {
                                ovr025.ClearPlayerTextArea();
                                display_resting_time(0);
                                Seg041.DisplayString("Your repose is suddenly interrupted!", 0, 15, 0x13, 1);
                                stop_resting        = true;
                                resting_intetrupted = true;
                                Seg041.GameDelay();
                            }
                        }
                    }
                }
            }

            seg037.draw8x8_clear_area(TextRegion.NormalBottom);
            gbl.displayPlayerStatusLine18 = false;

            return(resting_intetrupted);
        }
Пример #7
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;
                }
            }
        }