Subversion Repositories Games.Descent

/*

 * Portions of this file are copyright Rebirth contributors and licensed as

 * described in COPYING.txt.

 * Portions of this file are copyright Parallax Software and licensed

 * according to the Parallax license below.

 * See COPYING.txt for license details.

THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX

SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO

END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A

ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS

IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS

SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE

FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE

CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS

AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.

COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.

*/

/*

 *

 * Kill matrix displayed at end of level.

 *

 */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#include <stdarg.h>

#include "dxxerror.h"

#include "pstypes.h"

#include "gr.h"

#include "window.h"

#include "key.h"

#include "palette.h"

#include "game.h"

#include "gameseq.h"

#include "window.h"

#include "physfsx.h"

#include "gamefont.h"

#include "u_mem.h"

#include "newmenu.h"

#include "menu.h"

#include "player.h"

#include "screens.h"

#include "cntrlcen.h"

#include "mouse.h"

#include "joy.h"

#include "timer.h"

#include "text.h"

#include "rbaudio.h"

#include "multi.h"

#include "kmatrix.h"

#include "gauges.h"

#include "pcx.h"

#include "object.h"

#include "args.h"

#include "compiler-range_for.h"

#if DXX_USE_OGL

#include "ogl_init.h"

#endif

#define CENTERING_OFFSET(x) ((300 - (70 + (x)*25 ))/2)

#define CENTERSCREEN (SWIDTH/2)

#define KMATRIX_VIEW_SEC 7 // Time after reactor explosion until new level - in seconds

static void kmatrix_redraw_coop(fvcobjptr &vcobjptr);

static void kmatrix_draw_item(fvcobjptr &vcobjptr, grs_canvas &canvas, const grs_font &cv_font, const int i, const playernum_array_t &sorted)

{

        int x, y;

        y = FSPACY(50+i*9);

        const auto &&fspacx = FSPACX();

        auto &p = *vcplayerptr(sorted[i]);

        gr_string(canvas, cv_font, fspacx(CENTERING_OFFSET(N_players)), y, static_cast<const char *>(p.callsign));

        const auto &&rgb10 = BM_XRGB(10, 10, 10);

        const auto &&rgb25 = BM_XRGB(25, 25, 25);

        for (int j=0; j<N_players; j++)

        {

                x = fspacx(70 + CENTERING_OFFSET(N_players) + j * 25);

                const auto kmij = kill_matrix[sorted[i]][sorted[j]];

                if (sorted[i]==sorted[j])

                {

                        if (kmij == 0)

                        {

                                gr_set_fontcolor(canvas, rgb10, -1);

                                gr_string(canvas, cv_font, x, y, "0");

                        }

                        else

                        {

                                gr_set_fontcolor(canvas, rgb25, -1);

                                gr_printf(canvas, cv_font, x, y, "-%hu", kmij);

                        }

                }

                else

                {

                        gr_set_fontcolor(canvas, kmij <= 0 ? rgb10 : rgb25, -1);

                        gr_printf(canvas, cv_font, x, y, "%hu", kmij);

                }

        }

                auto &player_info = vcobjptr(p.objnum)->ctype.player_info;

                const int eff = (player_info.net_killed_total + player_info.net_kills_total <= 0)

                        ? 0

                        : static_cast<int>(

                                static_cast<float>(player_info.net_kills_total) / (

                                        static_cast<float>(player_info.net_killed_total) + static_cast<float>(player_info.net_kills_total)

                                ) * 100.0

                        );

        x = fspacx(60 + CENTERING_OFFSET(N_players) + N_players * 25);

        gr_set_fontcolor(canvas, rgb25, -1);

        gr_printf(canvas, cv_font, x, y, "%4d/%i%%", player_info.net_kills_total, eff <= 0 ? 0 : eff);

}

static void kmatrix_draw_names(grs_canvas &canvas, const grs_font &cv_font, const playernum_array_t &sorted)

{

        int x;

        const auto &&fspacx = FSPACX();

        const auto &&fspacy = FSPACY();

        const auto &&rgb31 = BM_XRGB(31, 31, 31);

        for (int j=0; j<N_players; j++)

        {

                x = fspacx(70 + CENTERING_OFFSET(N_players) + j * 25);

                color_t c;

                auto &p = *vcplayerptr(sorted[j]);

                if (p.connected==CONNECT_DISCONNECTED)

                        c = rgb31;

                else

                {

                        const auto color = get_player_or_team_color(sorted[j]);

                        const auto &rgb = player_rgb[color];

                        c = BM_XRGB(rgb.r, rgb.g, rgb.b);

                }

                gr_set_fontcolor(canvas, c, -1);

                gr_printf(canvas, cv_font, x, fspacy(40), "%c", p.callsign[0u]);

        }

        x = fspacx(72 + CENTERING_OFFSET(N_players) + N_players * 25);

        gr_set_fontcolor(canvas, rgb31, -1);

        gr_string(canvas, cv_font, x, fspacy(40), "K/E");

}

static void kmatrix_draw_coop_names(grs_canvas &canvas, const grs_font &cv_font)

{

        gr_set_fontcolor(canvas, BM_XRGB(63, 31, 31),-1);

        const auto &&fspacy40 = FSPACY(40);

        const auto centerscreen = CENTERSCREEN;

        gr_string(canvas, cv_font, centerscreen, fspacy40, "SCORE");

        gr_string(canvas, cv_font, centerscreen + FSPACX(50), fspacy40, "DEATHS");

}

static void kmatrix_status_msg(grs_canvas &canvas, const fix time, const int reactor)

{

        gr_set_fontcolor(canvas, gr_find_closest_color(255, 255, 255),-1);

        auto &game_font = *GAME_FONT;

        gr_printf(canvas, game_font, 0x8000, SHEIGHT - LINE_SPACING(game_font, game_font), reactor

                ? "Waiting for players to finish level. Reactor time: T-%d"

                : "Level finished. Wait (%d) to proceed or ESC to Quit."

        , time);

}

namespace {

struct kmatrix_screen : ignore_window_pointer_t

{

        grs_main_bitmap background;

        int network;

        fix64 end_time;

        int playing;

        int aborted;

};

}

namespace dsx {

static void kmatrix_redraw(kmatrix_screen *km)

{

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &vcobjptr = Objects.vcptr;

        playernum_array_t sorted;

        gr_set_default_canvas();

        auto &canvas = *grd_curcanv;

        show_fullscr(canvas, km->background);

        if (Game_mode & GM_MULTI_COOP)

        {

                kmatrix_redraw_coop(vcobjptr);

        }

        else

        {

                multi_sort_kill_list();

                const auto title =

#if defined(DXX_BUILD_DESCENT_II)

                        game_mode_capture_flag()

                        ? "CAPTURE THE FLAG SUMMARY"

                        : game_mode_hoard()

                                ? "HOARD SUMMARY"

                                :

#endif

                                TXT_KILL_MATRIX_TITLE;

                auto &medium3_font = *MEDIUM3_FONT;

                gr_string(canvas, medium3_font, 0x8000, FSPACY(10), title);

                auto &game_font = *GAME_FONT;

                multi_get_kill_list(sorted);

                kmatrix_draw_names(canvas, game_font, sorted);

                for (int i=0; i<N_players; i++ )

                {

                        if (vcplayerptr(sorted[i])->connected == CONNECT_DISCONNECTED)

                                gr_set_fontcolor(canvas, gr_find_closest_color(31, 31, 31),-1);

                        else

                        {

                                const auto color = get_player_or_team_color(sorted[i]);

                                gr_set_fontcolor(canvas, BM_XRGB(player_rgb[color].r, player_rgb[color].g, player_rgb[color].b),-1);

                        }

                        kmatrix_draw_item(vcobjptr, canvas, game_font, i, sorted);

                }

        }

        gr_palette_load(gr_palette);

}

}

static void kmatrix_redraw_coop(fvcobjptr &vcobjptr)

{

        playernum_array_t sorted;

        multi_sort_kill_list();

        auto &canvas = *grd_curcanv;

        auto &medium3_font = *MEDIUM3_FONT;

        gr_string(canvas, medium3_font,  0x8000, FSPACY(10), "COOPERATIVE SUMMARY");

        multi_get_kill_list(sorted);

        auto &game_font = *GAME_FONT;

        kmatrix_draw_coop_names(canvas, game_font);

        const auto &&fspacx = FSPACX();

        const auto &&fspacy = FSPACY();

        const auto x_callsign = fspacx(CENTERING_OFFSET(N_players));

        const auto x_centerscreen = CENTERSCREEN;

        const auto &&fspacx50 = fspacx(50);

        const auto rgb60_40_10 = BM_XRGB(60, 40, 10);

        for (playernum_t i = 0; i < N_players; ++i)

        {

                auto &plr = *vcplayerptr(sorted[i]);

                int r, g, b;

                if (plr.connected == CONNECT_DISCONNECTED)

                        r = g = b = 31;

                else

                {

                        auto &color = player_rgb_normal[get_player_color(sorted[i])];

                        r = color.r * 2;

                        g = color.g * 2;

                        b = color.b * 2;

                }

                gr_set_fontcolor(canvas, gr_find_closest_color(r, g, b), -1);

                const auto &&y = fspacy(50 + i * 9);

                gr_string(canvas, game_font, x_callsign, y, static_cast<const char *>(plr.callsign));

                gr_set_fontcolor(canvas, rgb60_40_10, -1);

                auto &player_info = vcobjptr(plr.objnum)->ctype.player_info;

                gr_printf(canvas, game_font, x_centerscreen, y, "%d", player_info.mission.score);

                gr_printf(canvas, game_font, x_centerscreen + fspacx50, y, "%d", player_info.net_killed_total);

        }

        gr_palette_load(gr_palette);

}

namespace dsx {

static window_event_result kmatrix_handler(window *, const d_event &event, kmatrix_screen *km)

{

        auto &LevelUniqueControlCenterState = LevelUniqueObjectState.ControlCenterState;

        int k = 0, choice = 0;

        switch (event.type)

        {

                case EVENT_KEY_COMMAND:

                        k = event_key_get(event);

                        switch( k )

                        {

                                case KEY_ESC:

                                        {

                                                std::array<newmenu_item, 2> nm_message_items{{

                                                        nm_item_menu(TXT_YES),

                                                        nm_item_menu(TXT_NO),

                                                }};

                                                choice = newmenu_do(nullptr, TXT_ABORT_GAME, nm_message_items, km->network ? get_multi_endlevel_poll2() : unused_newmenu_subfunction, unused_newmenu_userdata);

                                        }

                                        if (choice==0)

                                        {

                                                get_local_player().connected=CONNECT_DISCONNECTED;

                                                if (km->network)

                                                        multi_send_endlevel_packet();

                                                multi_leave_game();

                                                km->aborted = 1;

                                                return window_event_result::close;

                                        }

                                        return window_event_result::handled;

                                default:

                                        break;

                        }

                        break;

                case EVENT_WINDOW_DRAW:

                        {

                        timer_delay2(50);

                        if (km->network)

                                multi_do_protocol_frame(0, 1);

                        km->playing = 0;

                        // Check if all connected players are also looking at this screen ...

                        range_for (auto &i, Players)

                                if (i.connected)

                                        if (i.connected != CONNECT_END_MENU && i.connected != CONNECT_DIED_IN_MINE)

                                        {

                                                km->playing = 1;

                                                break;

                                        }

                        // ... and let the reactor blow sky high!

                        if (!km->playing)

                                LevelUniqueControlCenterState.Countdown_seconds_left = -1;

                        // If Reactor is finished and end_time not inited, set the time when we will exit this loop

                        const auto Countdown_seconds_left = LevelUniqueControlCenterState.Countdown_seconds_left;

                        if (km->end_time == -1 && Countdown_seconds_left < 0 && !km->playing)

                                km->end_time = timer_query() + (KMATRIX_VIEW_SEC * F1_0);

                        // Check if end_time has been reached and exit loop

                        if (timer_query() >= km->end_time && km->end_time != -1)

                        {

                                if (km->network)

                                        multi_send_endlevel_packet();  // make sure

#if defined(DXX_BUILD_DESCENT_II)

                                if (is_D2_OEM)

                                {

                                        if (Current_level_num==8)

                                        {

                                                get_local_player().connected=CONNECT_DISCONNECTED;

                                                if (km->network)

                                                        multi_send_endlevel_packet();

                                                multi_leave_game();

                                                km->aborted = 1;

                                        }

                                }

#endif

                                return window_event_result::close;

                        }

                        kmatrix_redraw(km);

                        kmatrix_status_msg(*grd_curcanv, km->playing ? Countdown_seconds_left : f2i(timer_query() - km->end_time), km->playing);

                        break;

                        }

                case EVENT_WINDOW_CLOSE:

                        game_flush_inputs();

                        newmenu_free_background();

                        break;

                default:

                        break;

        }

        return window_event_result::ignored;

}

}

kmatrix_result kmatrix_view(int network)

{

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &vcobjptridx = Objects.vcptridx;

        kmatrix_screen km;

        if (pcx_read_bitmap(STARS_BACKGROUND, km.background, gr_palette) != pcx_result::SUCCESS)

        {

                return kmatrix_result::abort;

        }

        gr_palette_load(gr_palette);

        km.network = network;

        km.end_time = -1;

        km.playing = 0;

        km.aborted = 0;

        set_screen_mode( SCREEN_MENU );

        game_flush_inputs();

        range_for (auto &i, Players)

                if (i.objnum != object_none)

                        digi_kill_sound_linked_to_object(vcobjptridx(i.objnum));

        const auto wind = window_create(grd_curscreen->sc_canvas, 0, 0, SWIDTH, SHEIGHT, kmatrix_handler, &km);

        if (!wind)

        {

                return kmatrix_result::abort;

        }

        event_process_all();

        return (km.aborted ? kmatrix_result::abort : kmatrix_result::proceed);

}