src/network/multi_dogfight.cpp

   1 /*
   2  * Copyright (C) Volition, Inc. 1999.  All rights reserved.
   3  *
   4  * All source code herein is the property of Volition, Inc. You may not sell
   5  * or otherwise commercially exploit the source or things you created based on
   6  * the source.
   7  */
   8
   9 /*
  10  * $Logfile: /Freespace2/code/Network/multi_dogfight.cpp $
  11  * $Revision$
  12  * $Date$
  13  * $Author$
  14  *
  15  * $Log$
  16  * Revision 1.4  2004/09/20 01:31:44  theoddone33
  17  * GCC 3.4 fixes.
  18  *
  19  * Revision 1.3  2002/06/09 04:41:23  relnev
  20  * added copyright header
  21  *
  22  * Revision 1.2  2002/05/07 03:16:47  theoddone33
  23  * The Great Newline Fix
  24  *
  25  * Revision 1.1.1.1  2002/05/03 03:28:10  root
  26  * Initial import.
  27  *
  28  *
  29  * 11    8/18/99 11:31a Jefff
  30  * mission title on kill matrix
  31  *
  32  * 10    8/17/99 9:55a Dave
  33  * Fixed dogfight scoring problem.
  34  *
  35  * 9     8/06/99 12:29a Dave
  36  * Multiple bug fixes.
  37  *
  38  * 8     5/03/99 8:32p Dave
  39  * New version of multi host options screen.
  40  *
  41  * 7     4/12/99 10:07p Dave
  42  * Made network startup more forgiving. Added checkmarks to dogfight
  43  * screen for players who hit commit.
  44  *
  45  * 6     4/12/99 2:22p Dave
  46  * More checks for dogfight stats.
  47  *
  48  * 5     2/24/99 3:40p Dave
  49  * Fixed problem where ships were becoming traitor all the time.
  50  *
  51  * 4     2/24/99 2:25p Dave
  52  * Fixed up chatbox bugs. Made squad war reporting better. Fixed a respawn
  53  * bug for dogfight more.
  54  *
  55  * 3     2/23/99 8:11p Dave
  56  * Tidied up dogfight mode. Fixed TvT ship type problems for alpha wing.
  57  * Small pass over todolist items.
  58  *
  59  * 2     2/23/99 2:29p Dave
  60  * First run of oldschool dogfight mode.
  61  *
  62  * $NoKeywords: $
  63  */
  64
  65 #include "multi.h"
  66 #include "multiutil.h"
  67 #include "multi_log.h"
  68 #include "bmpman.h"
  69 #include "object.h"
  70 #include "systemvars.h"
  71 #include "freespace.h"
  72 #include "key.h"
  73 #include "missionscreencommon.h"
  74 #include "eventmusic.h"
  75 #include "gamesnd.h"
  76 #include "multiui.h"
  77 #include "chatbox.h"
  78 #include "ui.h"
  79 #include "font.h"
  80 #include "multi_dogfight.h"
  81 #include "alphacolors.h"
  82
  83 // ----------------------------------------------------------------------------------------------------
  84 // MULTI DOGFIGHT DEFINES/VARS
  85 //
  86
  87 // interface stuff
  88 UI_WINDOW Multi_df_window;
  89
  90 #define NUM_MULTI_DF_BUTTONS                    1
  91 #define ACCEPT_BUTTON                                   0
  92
  93 ui_button_info Multi_df_buttons[GR_NUM_RESOLUTIONS][NUM_MULTI_DF_BUTTONS] = {
  94         { // GR_640
  95                 // accept
  96                 ui_button_info("CB_05a",        571,    425,    578,    413,    5),
  97         },
  98         { // GR_1024
  99                 // accept
 100                 ui_button_info("2_CB_05a",      914,    681,    914,    660,    5),
 101         }
 102 };
 103
 104 int Multi_df_background_bitmap = -1;
 105 const char *Multi_df_background_fname[GR_NUM_RESOLUTIONS] = {
 106         "KillMatrix",
 107         "2_KillMatrix"
 108 };
 109 const char *Multi_df_mask_fname[GR_NUM_RESOLUTIONS] = {
 110         "KillMatrix-m",
 111         "2_KillMatrix-m"
 112 };
 113
 114 // coord 3 is max width
 115 static int Kill_matrix_title_coords[GR_NUM_RESOLUTIONS][3] = {
 116         {       // GR_640
 117                 19, 118, 172
 118         },
 119         {       // GR_1024
 120                 33, 194, 272
 121         }
 122 };
 123
 124 // display area coords
 125 int Multi_df_display_coords[GR_NUM_RESOLUTIONS][4] = {
 126         { // GR_640
 127                 43, 133, 569, 269
 128         },
 129         { // GR_1024
 130                 60, 213, 919, 429
 131         }
 132 };
 133
 134 #define MULTI_DF_TOTAL_ADJUST                           5
 135
 136 // "check" icon coords
 137 int Multi_df_check_coords[GR_NUM_RESOLUTIONS] = {
 138         // GR_640
 139         28,
 140
 141         // GR_1024
 142         45
 143 };
 144
 145 // players when the screen started - we need to store this explicity so that even after players leave, we can display the full kill matrix
 146 typedef struct multi_df_score {
 147         char callsign[CALLSIGN_LEN+1];          // callsign for this guy
 148         scoring_struct stats;                                   // stats for the guy
 149         int np_index;                                                           // absolute index into the netplayers array
 150 } multi_df_score;
 151 multi_df_score Multi_df_score[MAX_PLAYERS];
 152 int Multi_df_score_count = 0;
 153
 154
 155 // ----------------------------------------------------------------------------------------------------
 156 // MULTI DOGFIGHT FORWARD DECLARATIONS
 157 //
 158
 159 // process button presses
 160 void multi_df_process_buttons();
 161
 162 // button was pressed
 163 void multi_df_button_pressed(int button);
 164
 165 // setup kill matrix data
 166 void multi_df_setup_kill_matrix();
 167
 168 // blit the kill matrix
 169 void multi_df_blit_kill_matrix();
 170
 171 // stuff a string representing the # of kills, player X had on player Y (where X and Y are indices into Multi_df_score)
 172 // returns the # of kills
 173 int multi_df_stuff_kills(char *kills, const int max_klen, int player_x, int player_y);
 174
 175
 176 // ----------------------------------------------------------------------------------------------------
 177 // MULTI DOGFIGHT FUNCTIONS
 178 //
 179
 180 // call once per level just before entering the mission
 181 void multi_df_level_pre_enter()
 182 {
 183         int idx;
 184
 185         // if we're not in dogfight mode, do nothing
 186         if(!(Netgame.type_flags & NG_TYPE_DOGFIGHT)){
 187                 return;
 188         }
 189
 190         // go through all player ships and make them hostile
 191         for(idx=0; idx<MAX_PLAYERS; idx++){
 192                 if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx]) && !MULTI_OBSERVER(Net_players[idx]) && (Net_players[idx].player != NULL) && (Net_players[idx].player->objnum >= 0) && (Objects[Net_players[idx].player->objnum].type == OBJ_SHIP)){
 193                         Ships[Objects[Net_players[idx].player->objnum].instance].team = TEAM_TRAITOR;
 194                 }
 195         }
 196
 197         //
 198 }
 199
 200 // evaluate a kill in dogfight by a netplayer
 201 void multi_df_eval_kill(net_player *killer, object *dead_obj)
 202 {
 203         int dead_index = -1;
 204
 205         // if we're not in dogfight mode, do nothing
 206         if(!(Netgame.type_flags & NG_TYPE_DOGFIGHT)){
 207                 return;
 208         }
 209
 210         // sanity checks
 211         if((killer == NULL) || (dead_obj == NULL) || (killer->player == NULL)){
 212                 return;
 213         }
 214
 215         // try and find the dead player
 216         dead_index = multi_find_player_by_object(dead_obj);
 217         if(dead_index < 0){
 218                 return;
 219         }
 220         SDL_assert(dead_index < MAX_PLAYERS);
 221         if(dead_index == NET_PLAYER_INDEX(killer)){
 222                 return;
 223         }
 224 #ifndef MAKE_FS1
 225         // update his kills
 226         killer->player->stats.m_dogfight_kills[dead_index]++;
 227 #endif
 228 }
 229
 230 // debrief
 231 void multi_df_debrief_init()
 232 {
 233         // no longer is mission
 234         Game_mode &= ~(GM_IN_MISSION);
 235         game_flush();
 236
 237         // call scoring level close for my stats.  Needed for award_init.  The stats will
 238         // be backed out if used chooses to replace them.
 239         scoring_level_close();
 240
 241         // multiplayer debriefing stuff
 242         multi_debrief_init();
 243
 244         // close down any old instances of the chatbox
 245         chatbox_close();
 246
 247         // create the new one
 248         chatbox_create();
 249
 250         // always play success music
 251         common_music_init(SCORE_DEBRIEF_SUCCESS);
 252
 253         // setup kill matrix
 254         multi_df_setup_kill_matrix();
 255
 256         UI_WINDOW *w;
 257         ui_button_info *b;
 258         int idx;
 259
 260         // load background bitmap
 261         Multi_df_background_bitmap = bm_load(Multi_df_background_fname[gr_screen.res]);
 262         SDL_assert(Multi_df_background_bitmap);
 263
 264         // create the UI window
 265         Multi_df_window.create(0, 0, gr_screen.max_w, gr_screen.max_h, 0);
 266         Multi_df_window.set_mask_bmap(Multi_df_mask_fname[gr_screen.res]);
 267
 268         // initialize the control buttons
 269         for (idx=0; idx<NUM_MULTI_DF_BUTTONS; idx++) {
 270                 b = &Multi_df_buttons[gr_screen.res][idx];
 271
 272                 // create the button
 273                 b->button.create(&Multi_df_window, NULL, b->x, b->y, 60, 30, 1, 1);
 274
 275                 // set its highlight action
 276                 b->button.set_highlight_action(common_play_highlight_sound);
 277
 278                 // set its animation bitmaps
 279                 b->button.set_bmaps(b->filename);
 280
 281                 // link the mask hotspot
 282                 b->button.link_hotspot(b->hotspot);
 283         }
 284
 285         // add some text
 286         w = &Multi_df_window;
 287         w->add_XSTR("Accept", 1035, Multi_df_buttons[gr_screen.res][ACCEPT_BUTTON].xt, Multi_df_buttons[gr_screen.res][ACCEPT_BUTTON].yt, &Multi_df_buttons[gr_screen.res][ACCEPT_BUTTON].button, UI_XSTR_COLOR_PINK);
 288 }
 289
 290 // do frame
 291 void multi_df_debrief_do()
 292 {
 293         int k, new_k;
 294         char buf[256];
 295
 296         k = chatbox_process();
 297         new_k = Multi_df_window.process(k, 0);
 298
 299         // process keypresses
 300         switch(new_k){
 301         case SDLK_ESCAPE:
 302                 multi_debrief_esc_hit();
 303                 break;
 304         }
 305
 306         // process buttons
 307         multi_df_process_buttons();
 308
 309         // music stuff
 310         common_music_do();
 311
 312         // process debriefing details
 313         multi_debrief_do_frame();
 314
 315         // draw the background
 316         GR_MAYBE_CLEAR_RES(Multi_df_background_bitmap);
 317         if (Multi_df_background_bitmap >= 0) {
 318                 gr_set_bitmap(Multi_df_background_bitmap, GR_ALPHABLEND_NONE, GR_BITBLT_MODE_NORMAL, 1.0f, -1, -1);
 319                 gr_bitmap(0, 0);
 320         }
 321
 322         // draw the window
 323         Multi_df_window.draw();
 324
 325         // kill matrix
 326         multi_df_blit_kill_matrix();
 327
 328         // render the chatbox
 329         chatbox_render();
 330
 331         // draw the mission title
 332         SDL_strlcpy(buf, The_mission.name, SDL_arraysize(buf));
 333         gr_force_fit_string(buf, 255, Kill_matrix_title_coords[gr_screen.res][2]);
 334         gr_set_color_fast(&Color_bright_white);
 335         gr_string(Kill_matrix_title_coords[gr_screen.res][0], Kill_matrix_title_coords[gr_screen.res][1], buf);
 336
 337         // flip
 338         gr_flip();
 339 }
 340
 341 // close
 342 void multi_df_debrief_close()
 343 {
 344         int idx;
 345
 346         // shutdown the chatbox
 347         chatbox_close();
 348
 349         // if stats weren't accepted, backout my own stats
 350         if (multi_debrief_stats_accept_code() != 1) {
 351                 if(MULTIPLAYER_MASTER){
 352                         for(idx=0; idx<MAX_PLAYERS; idx++){
 353                                 if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx]) && !MULTI_PERM_OBSERVER(Net_players[idx]) && (Net_players[idx].player != NULL)){
 354                                         scoring_backout_accept(&Net_players[idx].player->stats);
 355                                 }
 356                         }
 357                 } else {
 358                         scoring_backout_accept( &Player->stats );
 359                 }
 360         }
 361
 362         // music stuff
 363         common_music_close();
 364 }
 365
 366
 367 // ----------------------------------------------------------------------------------------------------
 368 // MULTI DOGFIGHT FORWARD DEFINITIONS
 369 //
 370
 371 // process button presses
 372 void multi_df_process_buttons()
 373 {
 374         int idx;
 375
 376         for(idx=0; idx<NUM_MULTI_DF_BUTTONS; idx++){
 377                 if(Multi_df_buttons[gr_screen.res][idx].button.pressed()){
 378                         multi_df_button_pressed(idx);
 379                         break;
 380                 }
 381         }
 382 }
 383
 384 // button was pressed
 385 void multi_df_button_pressed(int button)
 386 {
 387         switch(button){
 388         case ACCEPT_BUTTON:
 389                 multi_debrief_accept_hit();
 390                 break;
 391         }
 392 }
 393
 394 // setup kill matrix data
 395 void multi_df_setup_kill_matrix()
 396 {
 397         int idx;
 398         multi_df_score *s;
 399
 400         Multi_df_score_count = 0;
 401
 402         // add players as necessary
 403         for(idx=0; idx<MAX_PLAYERS; idx++){
 404                 if(MULTI_CONNECTED(Net_players[idx]) && !MULTI_STANDALONE(Net_players[idx]) && !MULTI_PERM_OBSERVER(Net_players[idx]) && (Net_players[idx].player != NULL)){
 405                         // stuff data for this guy
 406                         s = &Multi_df_score[Multi_df_score_count++];
 407 #ifndef MAKE_FS1
 408                         ml_printf("Dogfight debrief stats for %s", Net_players[idx].player->callsign);
 409                         for(int s_idx=0; s_idx<MAX_PLAYERS; s_idx++){
 410                                 ml_printf("%d", Net_players[idx].player->stats.m_dogfight_kills[s_idx]);
 411                         }
 412 #endif
 413                         s->stats = Net_players[idx].player->stats;
 414                         SDL_strlcpy(s->callsign, Net_players[idx].player->callsign, SDL_arraysize(s->callsign));
 415                         s->np_index = idx;
 416                 }
 417         }
 418 }
 419
 420 // blit the kill matrix
 421 void multi_df_blit_kill_matrix()
 422 {
 423         int idx, s_idx, str_len;
 424         int cx, cy;
 425         char squashed_string[CALLSIGN_LEN+1] = "";
 426
 427         // max width of an individual item, and the text that can be in that item
 428         float max_item_width = ((float)Multi_df_display_coords[gr_screen.res][2] - 40.0f) / (float)(Multi_df_score_count + 1);
 429         float max_text_width = max_item_width * 0.8f;
 430
 431         // start x for the top bar (one item to the right)
 432         int top_x_start = Multi_df_display_coords[gr_screen.res][0] + (int)max_item_width;
 433         int top_y_start = Multi_df_display_coords[gr_screen.res][1];
 434
 435         // start x for the side bar
 436         //int side_x_start = Multi_df_display_coords[gr_screen.res][0];
 437         int side_y_start = Multi_df_display_coords[gr_screen.res][1] + 10;
 438
 439         // draw the top bar
 440         cx = top_x_start;
 441         cy = top_y_start;
 442         for(idx=0; idx<Multi_df_score_count; idx++){
 443                 // force the string to fit nicely
 444                 SDL_strlcpy(squashed_string, Multi_df_score[idx].callsign, SDL_arraysize(squashed_string));
 445                 gr_force_fit_string(squashed_string, CALLSIGN_LEN, (int)max_text_width);
 446                 gr_get_string_size(&str_len, NULL, squashed_string);
 447
 448                 // set color and blit the string
 449                 SDL_assert(Multi_df_score[idx].np_index >= 0);
 450                 if(Multi_df_score[idx].np_index >= 0){
 451                         gr_set_color_fast(Color_netplayer[Multi_df_score[idx].np_index]);
 452                 }
 453                 gr_string(cx + (int)((max_item_width - (float)str_len)/2.0f), cy, squashed_string);
 454
 455                 // next spot
 456                 cx += (int)max_item_width;
 457         }
 458
 459         // draw the rest of the scoreboard
 460         //cx = side_x_start;
 461         cy = side_y_start;
 462         int row_total;
 463         for(idx=0; idx<Multi_df_score_count; idx++){
 464                 // draw a check if necessary
 465                 if(!MULTI_CONNECTED(Net_players[Multi_df_score[idx].np_index]) || (Net_players[Multi_df_score[idx].np_index].state == NETPLAYER_STATE_DEBRIEF_ACCEPT) || (Net_players[Multi_df_score[idx].np_index].state == NETPLAYER_STATE_DEBRIEF_REPLAY)){
 466                         if(Multi_common_icons[MICON_VALID] != -1){
 467                                 gr_set_bitmap(Multi_common_icons[MICON_VALID], GR_ALPHABLEND_NONE, GR_BITBLT_MODE_NORMAL, 1.0f, -1, -1);
 468                                 gr_bitmap(Multi_df_check_coords[gr_screen.res], cy);
 469                         }
 470                 }
 471
 472                 // draw the name
 473                 cx = Multi_df_display_coords[gr_screen.res][0];
 474                 SDL_strlcpy(squashed_string, Multi_df_score[idx].callsign, SDL_arraysize(squashed_string));
 475                 gr_force_fit_string(squashed_string, CALLSIGN_LEN, (int)max_text_width);
 476                 gr_get_string_size(&str_len, NULL, squashed_string);
 477                 SDL_assert(Multi_df_score[idx].np_index >= 0);
 478                 if(Multi_df_score[idx].np_index >= 0){
 479                         gr_set_color_fast(Color_netplayer[Multi_df_score[idx].np_index]);
 480                 }
 481                 gr_string(cx, cy, squashed_string);
 482
 483                 cx = top_x_start;
 484                 row_total = 0;
 485                 for(s_idx=0; s_idx<Multi_df_score_count; s_idx++){
 486                         // stuff the string to be displayed and select the proper display color
 487                         if(s_idx == idx){
 488                                 SDL_strlcpy(squashed_string, "-", SDL_arraysize(squashed_string));
 489                                 gr_set_color_fast(&Color_grey);
 490                         } else {
 491                                 row_total += multi_df_stuff_kills(squashed_string, SDL_arraysize(squashed_string), idx, s_idx);
 492                                 SDL_assert(Multi_df_score[idx].np_index >= 0);
 493                                 if(Multi_df_score[idx].np_index >= 0){
 494                                         gr_set_color_fast(Color_netplayer[Multi_df_score[idx].np_index]);
 495                                 }
 496                         }
 497
 498                         // draw the string
 499                         gr_force_fit_string(squashed_string, CALLSIGN_LEN, (int)max_text_width);
 500                         gr_get_string_size(&str_len, NULL, squashed_string);
 501                         gr_string(cx + (int)((max_item_width - (float)str_len)/2.0f), cy, squashed_string);
 502
 503                         // next spot
 504                         cx += (int)max_item_width;
 505                 }
 506
 507                 // draw the row total
 508                 gr_set_color_fast(Color_netplayer[Multi_df_score[idx].np_index]);
 509                 SDL_snprintf(squashed_string, SDL_arraysize(squashed_string), "(%d)", row_total);
 510                 gr_get_string_size(&str_len, NULL, squashed_string);
 511                 gr_string(Multi_df_display_coords[gr_screen.res][0] + Multi_df_display_coords[gr_screen.res][2] - (MULTI_DF_TOTAL_ADJUST + str_len), cy, squashed_string);
 512
 513                 cy += 10;
 514         }
 515
 516         /*
 517         // blit totals
 518         int column_total;
 519         cx = top_x_start;
 520         cy += 3;
 521         for(idx=0; idx<Multi_df_score_count; idx++){
 522                 // add up this column
 523                 column_total = 0;
 524                 for(s_idx=0; s_idx<Multi_df_score_count; s_idx++){
 525                         // add
 526                         column_total += Multi_df_score[idx].stats.m_dogfight_kills[s_idx];
 527                 }
 528
 529                 // draw
 530                 sprintf(squashed_string, "%d", column_total);
 531                 gr_set_color_fast(Color_netplayer[Multi_df_score[idx].np_index]);
 532                 gr_string(cx, cy, squashed_string);
 533
 534                 // next item
 535                 cx += (int)max_item_width;
 536         }
 537         */
 538 }
 539
 540 // stuff a string representing the # of kills, player X had on player Y (where X and Y are indices into Multi_df_score)
 541 // returns the # of kills
 542 int multi_df_stuff_kills(char *kills, const int max_klen, int player_x, int player_y)
 543 {
 544         SDL_strlcpy(kills, "", max_klen);
 545
 546 #ifndef MAKE_FS1
 547         multi_df_score *s = &Multi_df_score[player_x];
 548
 549         SDL_snprintf(kills, max_klen, "%d", s->stats.m_dogfight_kills[Multi_df_score[player_y].np_index]);
 550
 551         return s->stats.m_dogfight_kills[Multi_df_score[player_y].np_index];
 552 #else
 553         SDL_snprintf(kills, max_klen, "%d", 0);
 554
 555         return 0;
 556 #endif
 557 }