mirror of
https://github.com/kevinbentley/Descent3.git
synced 2025-01-22 19:55:23 +00:00
3233 lines
103 KiB
C++
3233 lines
103 KiB
C++
/*
|
|
* Descent 3
|
|
* Copyright (C) 2024 Parallax Software
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
--- HISTORICAL COMMENTS FOLLOW ---
|
|
|
|
* $Logfile: /DescentIII/Main/mtclient/mtclient.cpp $
|
|
* $Revision: 1.1.1.1 $
|
|
* $Date: 2003-08-26 03:58:40 $
|
|
* $Author: kevinb $
|
|
*
|
|
* Mastertracker Client DLL
|
|
*
|
|
* $Log: not supported by cvs2svn $
|
|
*
|
|
* 127 10/03/01 12:44a Kevin
|
|
* Smaller version of pxo packets
|
|
*
|
|
* 126 3/26/00 10:30p Kevin
|
|
* MOD Downloader for 1.4 patch.
|
|
*
|
|
* 125 3/20/00 12:29p Matt
|
|
* Merge of Duane's post-1.3 changes.
|
|
* Deleted Mac-only stricmp() function.
|
|
*
|
|
* 124 2/18/00 11:33p Kevin
|
|
* Fixed crash when sorting ping list bug, and clear the game list when
|
|
* joining a private lobby.
|
|
*
|
|
* 123 9/07/99 2:21p Kevin
|
|
* more CR/LF issues for the mac
|
|
*
|
|
* 122 9/07/99 10:24a Kevin
|
|
* Macintosh fixes!
|
|
*
|
|
* 121 9/02/99 3:16p Kevin
|
|
* Macintosh byte ordering fixes
|
|
*
|
|
* 120 8/24/99 5:47p Kevin
|
|
* Macintosh crap
|
|
*
|
|
* 119 8/24/99 10:39a Kevin
|
|
* Hopefully fixed the PXO return to chat bug
|
|
*
|
|
* 118 8/17/99 3:35p Kevin
|
|
* inverse sorts wouldn't show the last item! Doh!
|
|
*
|
|
* 117 8/17/99 1:52p Kevin
|
|
* fixed potential crash bugs as well as formatting for "CS Team Anarchy"
|
|
*
|
|
* 116 8/12/99 10:15a Kevin
|
|
* debugging stuff
|
|
*
|
|
* 115 8/10/99 12:53p Kevin
|
|
* fixed bug with return to chat & sorted gamelist
|
|
*
|
|
* 114 7/30/99 1:20p Kevin
|
|
* Fixed problems with sorted game list
|
|
*
|
|
* 113 7/26/99 11:45a Kevin
|
|
* possible return to chat crash fix
|
|
*
|
|
* 112 7/21/99 9:11a Kevin
|
|
* bandwidth reduction act #1
|
|
*
|
|
* 111 7/12/99 4:15p Kevin
|
|
* Changed the way we determine if we should report stats or not in PXO
|
|
*
|
|
* 110 7/07/99 3:38p Kevin
|
|
* Sorting in PXO gamelist!
|
|
*
|
|
* 109 7/06/99 5:52p Kevin
|
|
* PXO & multiplayer fixes for the patch
|
|
*
|
|
* 108 5/23/99 3:04a Jason
|
|
* fixed bug with player rankings not being updated correctly
|
|
*
|
|
* 107 5/23/99 2:38a Kevin
|
|
* fixed text overlapping thingy
|
|
*
|
|
* 106 5/20/99 9:17p Kevin
|
|
* removed invisible hotspot
|
|
*
|
|
* 105 5/17/99 5:19p Samir
|
|
* added ability for edit box to autoselect when hitting the max number of
|
|
* characters typable.
|
|
*
|
|
* 104 5/08/99 11:32a Kevin
|
|
* increased the gamelist update interval from pxo
|
|
*
|
|
* 103 5/05/99 5:23p Kevin
|
|
* fixed some bugs on the gamelist
|
|
*
|
|
* 102 5/05/99 11:04a Kevin
|
|
* added defer call to game over (previously it was only happening while
|
|
* writing stats
|
|
*
|
|
* 101 5/04/99 10:16p Kevin
|
|
* Fixed problem with 'set default screen'
|
|
*
|
|
* 100 5/04/99 5:39p Kevin
|
|
* connection dll & pxo game tracking improvements (added server type to
|
|
* list)
|
|
*
|
|
* 99 4/28/99 6:39p Kevin
|
|
* Build 182 fixes
|
|
*
|
|
* 98 4/27/99 1:54p Kevin
|
|
* Added pilot name to stats dialog
|
|
*
|
|
* 97 4/27/99 10:23a Kevin
|
|
* nifty titles for dialogs
|
|
*
|
|
* 96 4/25/99 5:02p Kevin
|
|
* Bunches of multiplayer UI improvements
|
|
*
|
|
* 95 4/24/99 11:59p Kevin
|
|
* game info dialog stuff
|
|
*
|
|
* 94 4/23/99 11:49p Kevin
|
|
*
|
|
* 93 4/22/99 3:43p Kevin
|
|
* Training missions show controls on screen
|
|
*
|
|
* 92 4/20/99 8:57p Jeff
|
|
* compile for Linux
|
|
*
|
|
* 91 4/19/99 7:56p Kevin
|
|
* ifdef'd out some win32 specific stuff
|
|
*
|
|
* 90 4/18/99 1:18p Kevin
|
|
* Demo2 build changes
|
|
*
|
|
* 89 4/17/99 3:44p Kevin
|
|
* Demo2 changes & fixes
|
|
*
|
|
* 88 4/16/99 6:00p Kevin
|
|
* Bunches of Demo stuff
|
|
*
|
|
* 87 4/14/99 1:37a Jeff
|
|
* fixed case mismatched #includes
|
|
*
|
|
* 86 4/02/99 12:19p Kevin
|
|
* Fixed chat server failed to connect
|
|
*
|
|
* 85 3/25/99 3:26p Kevin
|
|
* Made PXO games be based on your chat channel
|
|
*
|
|
* 84 3/17/99 4:08p Kevin
|
|
* Changed the way games appear and timeout in the game list.
|
|
*
|
|
* 83 3/05/99 11:35a Kevin
|
|
* new screens
|
|
*
|
|
* 82 3/04/99 12:07p Kevin
|
|
* Fixed stupid bug if you cancel out of connecting.
|
|
*
|
|
* 81 3/02/99 5:50p Kevin
|
|
* Ouch. Duplicate structures existed and were conflicting.
|
|
*
|
|
* 80 2/19/99 5:21p Kevin
|
|
* Fixed some connection DLLs and a Direct Sound bug with threads.
|
|
*
|
|
* 79 2/15/99 7:47p Jeff
|
|
* new pilot file class and read/write system checked in...should be more
|
|
* robust than old
|
|
*
|
|
* 78 2/03/99 4:20p Kevin
|
|
* Got multiplayer working with .mn3 files, and setup autodownloading
|
|
*
|
|
* 77 2/02/99 7:06p Jason
|
|
* added ranking system
|
|
*
|
|
* 76 1/23/99 3:20p Kevin
|
|
* Made gamelist boxes not sort
|
|
*
|
|
* 75 1/11/99 12:29p Jeff
|
|
* changes made not to call the module library directly
|
|
*
|
|
* 74 1/07/99 11:51a Kevin
|
|
* Added support for joining servers on alternate ports and hosting behind
|
|
* a proxy/firewall
|
|
*
|
|
* 73 1/04/99 5:43p Kevin
|
|
* new command line args
|
|
*
|
|
* 72 12/30/98 5:24p Kevin
|
|
* Added +name to specify a default pilot (for gamespy) fixed a gamespy
|
|
* bug, and improved the pxo dll game list screen
|
|
*
|
|
* 71 12/30/98 12:16p Kevin
|
|
* Auto Mission Download system
|
|
*
|
|
* 70 12/23/98 6:38p Kevin
|
|
* All UDP data (except gamespy) now uses one (registered) port number
|
|
*
|
|
* 69 12/14/98 10:53a Jason
|
|
* added bright player ships option
|
|
*
|
|
* 68 12/04/98 4:37p Kevin
|
|
* Fixed selection being reset in game lists...
|
|
*
|
|
* 67 12/01/98 12:47p Jason
|
|
* got rid of NF_DROPMISORDERED and added NF_USE_SMOOTHING
|
|
*
|
|
* 66 11/18/98 3:26p Kevin
|
|
* Put multiplayer options into con_dll.h
|
|
*
|
|
* 65 11/03/98 9:27a Kevin
|
|
* Added PXO message of the day
|
|
*
|
|
* 64 10/30/98 11:25a Kevin
|
|
* Message of the day for PXO
|
|
*
|
|
* 63 10/23/98 10:12a Kevin
|
|
* fixed bug when you hit cancel in the login screen
|
|
*
|
|
* 62 10/22/98 10:14a Kevin
|
|
* Made Stats dialog bigger
|
|
*
|
|
* 61 10/20/98 5:46p Kevin
|
|
* Gunboy and other fixes
|
|
*
|
|
* 60 10/20/98 2:07p Kevin
|
|
* changed tab order of login dialog, and changed strings
|
|
*
|
|
* 59 10/19/98 11:07p Kevin
|
|
* fixed bug
|
|
*
|
|
* 58 10/19/98 2:48p Kevin
|
|
* Added accurate weapon thingy for Chris
|
|
*
|
|
* 57 10/19/98 11:24a Kevin
|
|
* Fixed problem with help
|
|
*
|
|
* 56 10/17/98 2:32p Kevin
|
|
* FIxed problem with banned users getting stuck on the ban message
|
|
* screen.
|
|
*
|
|
* 55 10/17/98 12:46p Kevin
|
|
* Beta 4 fixes
|
|
*
|
|
* 54 10/15/98 3:29p Kevin
|
|
* Fixed dlls to not require runtime debug libraries in release builds
|
|
*
|
|
* 53 10/15/98 12:08p Kevin
|
|
* Changed game list to line up differently
|
|
*
|
|
* 52 10/13/98 3:42p Kevin
|
|
* bug fixes
|
|
*
|
|
* 51 10/12/98 8:39p Kevin
|
|
* removed mprintf's and fixed some smallish bugs
|
|
*
|
|
* 50 10/12/98 11:02a Kevin
|
|
* Changed directory of mtav file
|
|
*
|
|
* 49 10/09/98 2:56p Kevin
|
|
* Changed IP addresses for PXO demo
|
|
*
|
|
* 48 10/08/98 3:37p Jeff
|
|
* removed time_left from Netgame
|
|
*
|
|
* 47 10/05/98 11:00a Kevin
|
|
* Fixed bug with uninitialized variable
|
|
*
|
|
* 46 10/01/98 11:37a Kevin
|
|
* UI fixes and stuff
|
|
*
|
|
* 45 9/30/98 12:33p Kevin
|
|
* Added web launching support
|
|
*
|
|
* 44 9/29/98 2:23p Kevin
|
|
* More UI tweaks
|
|
*
|
|
* 43 9/28/98 4:55p Kevin
|
|
*
|
|
* 42 9/28/98 4:21p Kevin
|
|
* Redesigned game list menus
|
|
*
|
|
* 41 9/28/98 11:10a Kevin
|
|
* fuxed returning onf uninitialized variable
|
|
*
|
|
* 40 9/28/98 9:53a Kevin
|
|
* Fixing misc UI problems, and fixed some bugs that VC 6 found
|
|
*
|
|
* 39 9/25/98 11:07a Kevin
|
|
* fixed columns to line up and cleaned up some PXO bugs
|
|
*
|
|
* 38 9/24/98 12:50p Kevin
|
|
* Added UI for rotational velocity and drop out of order packets in net
|
|
* games
|
|
*
|
|
* 37 9/23/98 6:33p Kevin
|
|
* Fixed load settings
|
|
*
|
|
* 36 9/23/98 2:55p Kevin
|
|
* Saved multi config and changed UI to conform
|
|
*
|
|
* 35 9/22/98 3:55p Kevin
|
|
* Removed obsolete function
|
|
*
|
|
* 34 9/22/98 2:29p Kevin
|
|
* moved ships allowed code out of dll and into main app. Also added
|
|
* powerup exclusions
|
|
*
|
|
* 33 9/21/98 11:19a Kevin
|
|
* check protocol before entering multiplayer screens
|
|
*
|
|
* 32 9/16/98 8:06p Jason
|
|
* got mastertracker working with the dedicated server
|
|
*
|
|
* 31 9/14/98 12:34p Kevin
|
|
* Fixed problems with using strtok and grtext functions.
|
|
*
|
|
* 30 9/09/98 12:41p Kevin
|
|
* Fixed up some UI issues
|
|
*
|
|
* 29 9/04/98 1:51p Kevin
|
|
* implemented asyncronous gethostbyname
|
|
*
|
|
* 28 9/02/98 6:54p Kevin
|
|
* Fixed general directplay support up, and got modem-modem working
|
|
*
|
|
* 27 8/31/98 10:14a Kevin
|
|
* Misc. multi-UI fixes
|
|
*
|
|
* 26 8/27/98 5:03p Kevin
|
|
* Prettied up multiplayer screens and fixed some bugs.
|
|
*
|
|
* 25 8/26/98 3:28p Samir
|
|
* put focus thing back in
|
|
*
|
|
* 24 8/25/98 6:33p Kevin
|
|
* PXO screens
|
|
*
|
|
* 23 8/24/98 5:04p Kevin
|
|
* Made msn files have the option to not be playable in multiplayer
|
|
*
|
|
* 22 8/24/98 10:42a Kevin
|
|
* Updated DLL for directplay and PXO background
|
|
*
|
|
* 21 8/19/98 11:50a Kevin
|
|
* Got DirectPlay IPX working, and localized connection DLLs
|
|
*
|
|
* 20 8/17/98 2:26p Kevin
|
|
* fixed auto update dll directory
|
|
*
|
|
* 19 8/17/98 11:00a Kevin
|
|
* Moved DLLs into subdirectories
|
|
*
|
|
* 18 8/07/98 12:39p Jeff
|
|
* added "allowed ships" to multiplayer options
|
|
*
|
|
* 17 7/27/98 5:31p Kevin
|
|
* Sound/Bitmap exchange system
|
|
*
|
|
* 16 7/22/98 4:34p Kevin
|
|
* fixed bug in MT gamelist with >10 games
|
|
*
|
|
* 15 7/21/98 1:49p Kevin
|
|
* IPX support and peer-peer option for multi
|
|
*
|
|
* 14 7/20/98 2:34p Kevin
|
|
* Re-wrote the DLL wrapper, to allow for better expandability
|
|
*
|
|
* 11 6/30/98 3:20p Kevin
|
|
* fixed ping time
|
|
*
|
|
* 10 6/25/98 10:03a Kevin
|
|
* Minor chat fixes in PXO
|
|
*
|
|
* 9 6/24/98 6:40p Kevin
|
|
* Added help to main dll menu
|
|
*
|
|
* 8 6/24/98 3:24p Kevin
|
|
* Updated PXO screens with chat, etc.
|
|
*
|
|
* 7 6/18/98 4:49p Kevin
|
|
* Updated multiplayer menus
|
|
*
|
|
* 6 6/11/98 1:56p Jeff
|
|
* looks for d3m files instead of dll
|
|
*
|
|
* 5 6/05/98 2:16p Jeff
|
|
* Changes made so Dynamic loading of DLLs done through module library
|
|
*
|
|
* 4 6/05/98 12:40p Kevin
|
|
*
|
|
* 3 6/01/98 3:52p Kevin
|
|
* changed listbox item to be white
|
|
*
|
|
* 2 6/01/98 10:10a Kevin
|
|
* Added DLL connection interface and auto update DLL
|
|
*
|
|
* 1 5/18/98 12:47p Kevin
|
|
*
|
|
* $NoKeywords: $
|
|
*/
|
|
|
|
#include "ui.h"
|
|
#include "newui.h"
|
|
#include "grdefs.h"
|
|
#include "player.h"
|
|
#include "game.h"
|
|
#include "pilot.h"
|
|
#include "ddio_common.h"
|
|
#include "mt_net.h"
|
|
#include "mtgametrack.h"
|
|
#include "module.h"
|
|
#include "inetgetfile.h"
|
|
#include "chat_api.h"
|
|
#include "mtstrings.h"
|
|
|
|
#define TXT_DLL_SAVESETTINGS TXT(79)
|
|
#define TXT_DLL_LOADSETTINGS TXT(80)
|
|
|
|
#define TXT_GEN_MPLYROPTIONS TXT_PXO_MPLYROPTIONS
|
|
#define TXT_GEN_TIMELIMIT TXT_PXO_TIMELIMIT
|
|
#define TXT_GEN_KILLGOAL TXT_PXO_KILLGOAL
|
|
#define TXT_GEN_PPS TXT_PXO_PPS
|
|
#define TXT_GEN_RESPAWNRATE TXT_PXO_RESPAWNRATE
|
|
#define TXT_GEN_MAXPLAYERS TXT_PXO_MAXPLAYERS
|
|
#define TXT_GEN_PREVMENU TXT_PXO_PREVMENU
|
|
#define TXT_GEN_CANCEL TXT_PXO_CANCEL
|
|
#define TXT_GEN_CFGALLOWEDSHIP TXT_PXO_CFGALLOWEDSHIP
|
|
#define TXT_GEN_USEROTVEL TXT_PXO_USEROTVEL
|
|
#define TXT_GEN_USEROTVEL TXT_PXO_USEROTVEL
|
|
#define TXT_GEN_USESMOOTHING TXT_PXO_USESMOOTHING
|
|
#define TXT_GEN_CLIENTSERVER TXT_PXO_CLIENTSERVER
|
|
#define TXT_GEN_PEERPEER TXT_PXO_PEERPEER
|
|
#define TXT_GEN_ACC_WEAP_COLL TXT_PXO_ACC_WEAP_COLL
|
|
#define TXT_GEN_BRIGHT_PLAYERS TXT_PXO_BRIGHT_PLAYERS
|
|
|
|
#define MULTI_USE_ALL_OPTIONS 1
|
|
|
|
#include "mtclient.h"
|
|
#include "mtpilottrack.h"
|
|
|
|
#include "DLLUiItems.h"
|
|
|
|
char Ourlobby[50] = "";
|
|
bool Login_aborted = false;
|
|
bool Auto_start = false;
|
|
int Bypass_chat = 0;
|
|
int ChatStarted = 0;
|
|
extern int Motd_version;
|
|
|
|
d3_net_game_data_tiny DLLD3_tracker_info;
|
|
|
|
#define MTADDNEWURL TXT_PXO_REGURL
|
|
|
|
#define MAX_GAMELIST_ITEMS 300
|
|
|
|
pxo_game_list PXOGamelist[MAX_GAMELIST_ITEMS];
|
|
int NextGameItemNo = 0;
|
|
uint16_t DLLPXOPort = 0;
|
|
|
|
void AutoLoginAndStartGame();
|
|
|
|
int GetGameByHandle(uint32_t handle) {
|
|
int j;
|
|
for (j = 0; j < *DLLNum_network_games_known; j++) {
|
|
if (DLLNetwork_games[j].handle == handle) {
|
|
return j;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int GetPXOItemByHandle(uint32_t handle) {
|
|
for (int i = 0; i < MAX_GAMELIST_ITEMS; i++) {
|
|
if (PXOGamelist[i].used) {
|
|
if (PXOGamelist[i].handle == handle) {
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int GetGameByLBNo(int selno) {
|
|
for (int i = 0; i < MAX_GAMELIST_ITEMS; i++) {
|
|
if (PXOGamelist[i].used) {
|
|
if (PXOGamelist[i].lb_no == selno) {
|
|
return GetGameByHandle(PXOGamelist[i].handle);
|
|
}
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void FormatServerLine(char *fmt, int servernum, int pxonum) {
|
|
int k = servernum;
|
|
char server_mode[20];
|
|
char server_type[200];
|
|
|
|
if (DLLNetwork_games[k].flags & NF_PEER_PEER) {
|
|
strcpy(server_mode, "PP");
|
|
} else if (DLLNetwork_games[k].flags & NF_PERMISSABLE) {
|
|
strcpy(server_mode, "PS");
|
|
} else {
|
|
strcpy(server_mode, "CS");
|
|
}
|
|
|
|
if (DLLNetwork_games[k].flags & NF_ALLOW_MLOOK) {
|
|
strcat(server_mode, "-ML");
|
|
}
|
|
|
|
snprintf(server_type, sizeof(server_type), "%s %s", server_mode, DLLNetwork_games[k].scriptname);
|
|
|
|
int game_type_pos = strlen(server_type);
|
|
|
|
#define SERVER_TYPE_MAX_LEN 100
|
|
while (DLLgrtext_GetTextLineWidth(server_type) > SERVER_TYPE_MAX_LEN) {
|
|
server_type[game_type_pos] = 0;
|
|
game_type_pos--;
|
|
}
|
|
|
|
sprintf(fmt, "%.20s\t\x02\x02b%s\x02\x45%.15s\x02\x63%d\x02\x6d%d/%d\x02\x7e%.3f", DLLNetwork_games[k].name,
|
|
server_type, DLLNetwork_games[k].mission_name, DLLNetwork_games[k].level_num,
|
|
DLLNetwork_games[k].curr_num_players, DLLNetwork_games[k].max_num_players,
|
|
DLLNetwork_games[k].server_response_time);
|
|
}
|
|
|
|
void UpdateGamelist(void *lb) {
|
|
|
|
int i, j;
|
|
|
|
// Look for items that we need to remove
|
|
for (i = 0; i < MAX_GAMELIST_ITEMS; i++) {
|
|
bool found = false;
|
|
if (PXOGamelist[i].used) {
|
|
for (j = 0; j < *DLLNum_network_games_known; j++) {
|
|
if (DLLNetwork_games[j].handle == PXOGamelist[i].handle) {
|
|
found = true;
|
|
}
|
|
}
|
|
if (!found) {
|
|
// Remove this item!
|
|
/*
|
|
int gameid = GetGameByHandle(PXOGamelist[i].handle);
|
|
|
|
if(gameid!=-1)
|
|
{
|
|
DLLmprintf(0,"Removing %s\n",DLLNetwork_games[gameid].name);
|
|
}
|
|
*/
|
|
|
|
// Now we need to fix up the lb_no items because we removed this one!
|
|
int k = 0;
|
|
for (k = 0; k < MAX_GAMELIST_ITEMS; k++) {
|
|
if (!PXOGamelist[k].used)
|
|
continue;
|
|
|
|
// This is yucky, but it accounts for the shifting up of the game items in the list
|
|
if (PXOGamelist[i].lb_no < PXOGamelist[k].lb_no)
|
|
PXOGamelist[k].lb_no--;
|
|
}
|
|
NextGameItemNo--;
|
|
PXOGamelist[i].used = false;
|
|
PXOGamelist[i].handle = -1;
|
|
DLLListRemoveItem(lb, PXOGamelist[i].ti);
|
|
DLLRemoveUITextItem(PXOGamelist[i].ti);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Look for items to add
|
|
for (i = 0; i < *DLLNum_network_games_known; i++) {
|
|
bool found = false;
|
|
for (j = 0; j < MAX_GAMELIST_ITEMS; j++) {
|
|
if (DLLNetwork_games[i].handle == PXOGamelist[j].handle) {
|
|
found = true;
|
|
}
|
|
}
|
|
if (!found) {
|
|
// Add this item!
|
|
// Update PXOGamelist[i].ti
|
|
for (j = 0; j < MAX_GAMELIST_ITEMS; j++) {
|
|
if (!PXOGamelist[j].used) {
|
|
// Aha! an empty slot
|
|
break;
|
|
}
|
|
}
|
|
|
|
int k = i;
|
|
if (j < MAX_GAMELIST_ITEMS) {
|
|
char fmtline[200];
|
|
|
|
PXOGamelist[j].lb_no = NextGameItemNo;
|
|
NextGameItemNo++;
|
|
PXOGamelist[j].handle = DLLNetwork_games[k].handle;
|
|
PXOGamelist[j].used = true;
|
|
DLLmprintf(0, "Adding %s\n", DLLNetwork_games[k].name);
|
|
|
|
// DLLmprintf(0,"Found game: %s\n",DLLNetwork_games[k].name);
|
|
FormatServerLine(fmtline, k, j);
|
|
|
|
if (DLLNetwork_games[k].dedicated_server) {
|
|
PXOGamelist[j].ti = DLLCreateNewUITextItem(fmtline, UICOL_HOTSPOT_LO);
|
|
} else {
|
|
PXOGamelist[j].ti = DLLCreateNewUITextItem(fmtline, GR_LIGHTGRAY);
|
|
}
|
|
DLLListAddItem(lb, PXOGamelist[j].ti);
|
|
} else {
|
|
// DLLInt3();
|
|
// Out of slots???
|
|
}
|
|
}
|
|
}
|
|
|
|
for (j = 0; j < MAX_GAMELIST_ITEMS; j++) {
|
|
if (PXOGamelist[j].used && (PXOGamelist[j].handle != -1)) {
|
|
int gameid = GetGameByHandle(PXOGamelist[j].handle);
|
|
|
|
if (gameid != -1) {
|
|
int k = gameid;
|
|
// DLLmprintf(0,"Updating %s\n",DLLNetwork_games[gameid].name);
|
|
char fmtline[200];
|
|
FormatServerLine(fmtline, k, j);
|
|
DLLSetUITextItemText(PXOGamelist[j].ti, fmtline,
|
|
DLLNetwork_games[k].dedicated_server ? UICOL_HOTSPOT_LO : GR_LIGHTGRAY);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef MACINTOSH
|
|
#pragma export on
|
|
#endif
|
|
|
|
// These next two function prototypes MUST appear in the extern "C" block if called
|
|
// from a CPP file.
|
|
extern "C" {
|
|
DLLEXPORT void DLLFUNCCALL DLLMultiInit(int *api_func);
|
|
DLLEXPORT void DLLFUNCCALL DLLMultiCall(int eventnum);
|
|
DLLEXPORT void DLLFUNCCALL DLLMultiClose();
|
|
}
|
|
|
|
bool All_ok = true;
|
|
bool MT_Sock_inited = false;
|
|
|
|
// Initializes the game function pointers
|
|
void DLLFUNCCALL DLLMultiInit(int *api_func) {
|
|
Use_netgame_flags = 1;
|
|
#ifdef MACINTOSH
|
|
InitOTSockets();
|
|
#endif
|
|
#include "mdllinit.h"
|
|
DLLPXOPort = (uint16_t)((size_t)API.vp[32] & 0xffff);
|
|
DLLmprintf(0, "Inside DLLMultiInit...\n");
|
|
*DLLUse_DirectPlay = false;
|
|
Auto_start = false;
|
|
DLLmprintf(0, "About to create string table...\n");
|
|
DLLCreateStringTable("mtclient.str", &StringTable, &StringTableSize);
|
|
DLLmprintf(0, "%d strings loaded from string table\n", StringTableSize);
|
|
if (!StringTableSize) {
|
|
All_ok = false;
|
|
return;
|
|
}
|
|
|
|
memset(PXOGamelist, 0, sizeof(PXOGamelist));
|
|
}
|
|
|
|
// Called when the DLL is shutdown
|
|
void DLLFUNCCALL DLLMultiClose() {
|
|
DLLmprintf(0, "Closing down PXO DLL\n");
|
|
DLLDestroyStringTable(StringTable, StringTableSize);
|
|
DLLnw_UnRegisterCallback(PXO_NETID_USER_TRACKER);
|
|
DLLnw_UnRegisterCallback(PXO_NETID_GAME_TRACKER);
|
|
if (MT_Sock_inited) {
|
|
CloseMTSockets();
|
|
}
|
|
#ifdef MACINTOSH
|
|
ShutdownOTSockets();
|
|
#endif
|
|
}
|
|
|
|
// The main entry point where the game calls the dll
|
|
void DLLFUNCCALL DLLMultiCall(int eventnum) {
|
|
// We don't need eventnum right now.
|
|
|
|
switch (eventnum) {
|
|
case MT_EVT_GET_HELP:
|
|
strcpy(DLLHelpText1, TXT_PXO_HELP1);
|
|
strcpy(DLLHelpText2, TXT_PXO_HELP2);
|
|
strcpy(DLLHelpText3, TXT_PXO_HELP3);
|
|
strcpy(DLLHelpText4, TXT_PXO_HELP4);
|
|
break;
|
|
case MT_EVT_LOGIN:
|
|
DLLDatabaseReadInt("BypassChat", &Bypass_chat);
|
|
if (!DLLTCP_active) {
|
|
DLLDoMessageBox(TXT_PXO_ERROR, TXT_PXO_NO_TCPIP, MSGBOX_OK, UICOL_WINDOW_TITLE, UICOL_TEXT_NORMAL);
|
|
*DLLMultiGameStarting = 0;
|
|
break;
|
|
}
|
|
|
|
*DLLMultiGameStarting = 0;
|
|
if (*DLLDedicated_server) {
|
|
InitMTSockets();
|
|
} else {
|
|
DLLCreateSplashScreen(TXT_PXO_CONNECTING, 1);
|
|
InitMTSockets();
|
|
MT_Sock_inited = true;
|
|
DLLCloseSplashScreen();
|
|
}
|
|
if (!All_ok) {
|
|
*DLLMultiGameStarting = 0;
|
|
return;
|
|
}
|
|
{
|
|
UnvalidatedDLL = 0;
|
|
DLLCreateSplashScreen(TXT_PXO_CONNECTING, 1);
|
|
DLLPollUI();
|
|
if (MT_Initialized) {
|
|
DLLPollUI();
|
|
if (!MTVersionCheck()) {
|
|
if (Login_aborted) {
|
|
MT_Initialized = 0;
|
|
} else {
|
|
// If the first call fails, try again
|
|
DLLPollUI();
|
|
if (!MTVersionCheck()) {
|
|
DLLPollUI();
|
|
if (!MTVersionCheck()) {
|
|
// If this call fails, we have a problem, and when MT_EVT_LOGIN is called we will let the user know.
|
|
UnvalidatedDLL = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
DLLCloseSplashScreen();
|
|
if (!MT_Initialized) {
|
|
DLLDoMessageBox(TXT_PXO_MASTERTRACKER, TXT_PXO_CANTCONNECT, MSGBOX_OK, UICOL_WINDOW_TITLE, UICOL_TEXT_NORMAL);
|
|
return;
|
|
}
|
|
// Start off with a login to tracker dialog
|
|
if (UnvalidatedDLL) {
|
|
DLLDoMessageBox(TXT_PXO_MASTERTRACKER, TXT_PXO_CANTAUTOVALIDATE, MSGBOX_OK, UICOL_WINDOW_TITLE,
|
|
UICOL_TEXT_NORMAL);
|
|
return;
|
|
}
|
|
|
|
if (LoginMasterTracker()) {
|
|
// menu.... start a game, or join a game
|
|
if (MainMultiplayerMenu()) {
|
|
*DLLMultiGameStarting = 1;
|
|
} else {
|
|
*DLLMultiGameStarting = 0;
|
|
}
|
|
} else {
|
|
DLLmprintf(0, "Login failed!\n");
|
|
*DLLMultiGameStarting = 0;
|
|
return;
|
|
}
|
|
}
|
|
break;
|
|
case MT_EVT_FRAME:
|
|
DoMTFrame();
|
|
break;
|
|
case MT_EVT_FIRST_FRAME:
|
|
MTWritingPilot = -1;
|
|
MTReadingPilot = -1;
|
|
*DLLGame_is_master_tracker_game = 1;
|
|
// strcpy(DLLD3_tracker_info.game_name,DLLNetgame->name);
|
|
// strcpy(DLLD3_tracker_info.mission_name,DLLNetgame->mission);
|
|
strcpy(DLLD3_tracker_info.lobby, DLLPXO_hosted_lobby_name);
|
|
StartTrackerGame(&DLLD3_tracker_info);
|
|
break;
|
|
case MT_EVT_GAME_OVER:
|
|
DoMTGameOver();
|
|
/*
|
|
if(!All_ok)
|
|
break;
|
|
//menu.... start a game, or join a game
|
|
if(MainMultiplayerMenu())
|
|
{
|
|
*DLLMultiGameStarting = 1;
|
|
}
|
|
else
|
|
{
|
|
*DLLMultiGameStarting = 0;
|
|
}
|
|
*/
|
|
break;
|
|
case MT_AUTO_LOGIN:
|
|
if (!DLLTCP_active) {
|
|
DLLDoMessageBox(TXT_PXO_ERROR, TXT_PXO_NO_TCPIP, MSGBOX_OK, UICOL_WINDOW_TITLE, UICOL_TEXT_NORMAL);
|
|
*DLLMultiGameStarting = 0;
|
|
break;
|
|
}
|
|
InitMTSockets();
|
|
if (!All_ok) {
|
|
*DLLMultiGameStarting = 0;
|
|
return;
|
|
}
|
|
AutoLoginAndJoinGame();
|
|
break;
|
|
case MT_AUTO_START:
|
|
InitMTSockets();
|
|
if (!All_ok) {
|
|
*DLLMultiGameStarting = 0;
|
|
return;
|
|
}
|
|
Auto_start = true;
|
|
AutoLoginAndStartGame();
|
|
break;
|
|
case MT_RETURN_TO_GAME_LIST:
|
|
Bypass_chat = 1;
|
|
|
|
// menu.... start a game, or join a game
|
|
if (MainMultiplayerMenu()) {
|
|
*DLLMultiGameStarting = 1;
|
|
} else {
|
|
*DLLMultiGameStarting = 0;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
#ifdef MACINTOSH
|
|
#pragma export off
|
|
#endif
|
|
|
|
int LoginMasterTracker() {
|
|
|
|
void *title_text = DLLCreateNewUITextItem(TXT_PXO_LOGINMASTERTRKR, UICOL_WINDOW_TITLE);
|
|
void *cancel_on_text = DLLCreateNewUITextItem(TXT_PXO_CANCEL, UICOL_HOTSPOT_HI);
|
|
void *login_on_text = DLLCreateNewUITextItem(TXT_PXO_LOGIN, UICOL_HOTSPOT_HI);
|
|
|
|
void *cancel_off_text = DLLCreateNewUITextItem(TXT_PXO_CANCEL, UICOL_HOTSPOT_LO);
|
|
void *login_off_text = DLLCreateNewUITextItem(TXT_PXO_LOGIN, UICOL_HOTSPOT_LO);
|
|
|
|
void *login_id_text = DLLCreateNewUITextItem(TXT_PXO_LOGINID, UICOL_TEXT_NORMAL);
|
|
void *tracker_id_text = DLLCreateNewUITextItem(TXT_PXO_TRACKERID, UICOL_TEXT_NORMAL);
|
|
void *password_text = DLLCreateNewUITextItem(TXT_PXO_PASSWORD, UICOL_TEXT_NORMAL);
|
|
|
|
void *new_prof_on_text = DLLCreateNewUITextItem(TXT_PXO_CREATENEWPROFILE, UICOL_HOTSPOT_HI);
|
|
void *new_prof_off_text = DLLCreateNewUITextItem(TXT_PXO_CREATENEWPROFILE, UICOL_HOTSPOT_LO);
|
|
|
|
void *blank_text = DLLCreateNewUITextItem(TXT_PXO_BLANK, GR_BLACK);
|
|
|
|
int exit_menu = 0;
|
|
int ret = 0;
|
|
|
|
int loginlen = LOGIN_LEN;
|
|
int passlen = PASSWORD_LEN;
|
|
|
|
void *main_wnd = DLLNewUIGameWindowCreate(TRACKER_MENU_X, TRACKER_MENU_Y, TRACKER_MENU_W, TRACKER_MENU_H,
|
|
UIF_PROCESS_ALL | UIF_CENTER | NUWF_TITLEMED);
|
|
|
|
void *title = DLLTextCreate(main_wnd, title_text, 0, 7, UIF_CENTER);
|
|
|
|
void *password = DLLTextCreate(main_wnd, password_text, 30, 130, UIF_CENTER);
|
|
void *login_id = DLLTextCreate(main_wnd, login_id_text, 50, 80, UIF_CENTER);
|
|
|
|
void *pass_edit = DLLEditCreate(main_wnd, UID_OK, 100, 140, 130, 15, UIF_CENTER | UIED_PASSWORD);
|
|
|
|
void *login_hs =
|
|
DLLHotSpotCreate(main_wnd, UID_OK, KEY_ENTER, login_off_text, login_on_text, 60, TRACKER_MENU_H - 80, 60, 20, 0);
|
|
|
|
void *cancel_hs = DLLHotSpotCreate(main_wnd, UID_CANCEL, KEY_ESC, cancel_off_text, cancel_on_text, 130,
|
|
TRACKER_MENU_H - 80, 60, 20, 0);
|
|
|
|
void *new_id_hs =
|
|
DLLHotSpotCreate(main_wnd, 4, KEY_N, new_prof_off_text, new_prof_on_text, 0, 45, 120, 20, UIF_CENTER | UIF_FIT);
|
|
|
|
void *login_edit = DLLEditCreate(main_wnd, 3, 100, 90, 130, 15, UIF_CENTER);
|
|
|
|
// Read defaults
|
|
|
|
DLLDatabaseRead("TrackerLogin", szloginid, &loginlen);
|
|
DLLDatabaseRead("TrackerPassword", szpassword, &passlen);
|
|
|
|
DLLEditSetText(login_edit, szloginid);
|
|
DLLEditSetText(pass_edit, szpassword);
|
|
|
|
DLLNewUIGameWindowOpen(main_wnd);
|
|
|
|
while (!exit_menu) {
|
|
int res;
|
|
|
|
res = DLLDoUI();
|
|
|
|
// handle all UI results.
|
|
|
|
switch (res) {
|
|
case 3:
|
|
DLLmprintf(0, "Got event 3!\n");
|
|
break;
|
|
case 4:
|
|
#ifdef WIN32
|
|
// TODO: reacivate for site opening
|
|
// ShellExecute(NULL, "open", MTADDNEWURL, NULL, NULL, SW_SHOW);
|
|
#endif
|
|
break;
|
|
case UID_OK: {
|
|
DLLEditGetText(login_edit, szloginid, LOGIN_LEN);
|
|
DLLEditGetText(pass_edit, szpassword, PASSWORD_LEN);
|
|
|
|
DLLDatabaseWrite("TrackerLogin", szloginid, strlen(szloginid) + 1);
|
|
DLLDatabaseWrite("TrackerPassword", szpassword, strlen(szpassword) + 1);
|
|
|
|
if ((!*szloginid) || (!*szpassword)) {
|
|
DLLDoMessageBox(TXT_PXO_MASTERTRACKER, TXT_PXO_BADLOGIN, MSGBOX_OK, UICOL_WINDOW_TITLE, UICOL_TEXT_NORMAL);
|
|
break;
|
|
}
|
|
|
|
// Fill out the validate struct and send off the packet
|
|
validate_id_request val_user{};
|
|
strcpy(val_user.tracker_id, sztrackerid);
|
|
strcpy(val_user.login, szloginid);
|
|
strcpy(val_user.password, szpassword);
|
|
|
|
DLLCreateSplashScreen(TXT_PXO_CONNECTING, 1);
|
|
|
|
int valret = ValidateUser(&val_user, sztrackerid);
|
|
|
|
while (valret == 0) {
|
|
valret = ValidateUser(nullptr, nullptr);
|
|
res = DLLPollUI();
|
|
if (res == 99) {
|
|
valret = -2;
|
|
}
|
|
DLLDescentDefer();
|
|
}
|
|
DLLCloseSplashScreen();
|
|
if (valret == 1) {
|
|
// User was validated
|
|
DLLmprintf(0, "Mastertracker user validated!\n");
|
|
// Run this to make sure we properly ACK the server.
|
|
for (int j = 0; j < 10; j++)
|
|
PollPTrackNet();
|
|
strcpy(DLLTracker_id, sztrackerid);
|
|
strcpy(DLLMPlayers[DLLPlayer_num].tracker_id, sztrackerid);
|
|
exit_menu = 1;
|
|
ret = 1;
|
|
|
|
break;
|
|
} else if (valret == -1) {
|
|
// User invalid!
|
|
DLLmprintf(0, "Mastertracker user not validated!\n");
|
|
DLLDoMessageBox(TXT_PXO_MASTERTRACKER, TXT_PXO_BADLOGIN, MSGBOX_OK, UICOL_WINDOW_TITLE, UICOL_TEXT_NORMAL);
|
|
// Run this to make sure we properly ACK the server.
|
|
for (int j = 0; j < 10; j++)
|
|
PollPTrackNet();
|
|
break;
|
|
} else {
|
|
// timeout waiting for tracker!
|
|
DLLmprintf(0, "Mastertracker timeout!\n");
|
|
DLLDoMessageBox(TXT_PXO_MASTERTRACKER, TXT_PXO_TIMEOUTMT, MSGBOX_OK, UICOL_WINDOW_TITLE, UICOL_TEXT_NORMAL);
|
|
// Run this to make sure we properly ACK the server.
|
|
for (int j = 0; j < 10; j++)
|
|
PollPTrackNet();
|
|
break;
|
|
}
|
|
}
|
|
case UID_CANCEL:
|
|
exit_menu = 1;
|
|
ret = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
DLLNewUIGameWindowClose(main_wnd);
|
|
DLLNewUIGameWindowDestroy(main_wnd);
|
|
|
|
DLLRemoveUITextItem(title_text);
|
|
DLLRemoveUITextItem(cancel_on_text);
|
|
DLLRemoveUITextItem(login_on_text);
|
|
DLLRemoveUITextItem(cancel_off_text);
|
|
DLLRemoveUITextItem(login_off_text);
|
|
DLLRemoveUITextItem(login_id_text);
|
|
DLLRemoveUITextItem(tracker_id_text);
|
|
DLLRemoveUITextItem(password_text);
|
|
DLLRemoveUITextItem(new_prof_on_text);
|
|
DLLRemoveUITextItem(new_prof_off_text);
|
|
DLLRemoveUITextItem(blank_text);
|
|
|
|
DLLDeleteUIItem(main_wnd);
|
|
DLLDeleteUIItem(title);
|
|
DLLDeleteUIItem(cancel_hs);
|
|
DLLDeleteUIItem(login_hs);
|
|
DLLDeleteUIItem(new_id_hs);
|
|
DLLDeleteUIItem(login_edit);
|
|
DLLDeleteUIItem(password);
|
|
DLLDeleteUIItem(login_id);
|
|
DLLDeleteUIItem(pass_edit);
|
|
|
|
return ret;
|
|
}
|
|
|
|
// The first multiplayer menu that the user will see...all multiplayer stuff is
|
|
// reached from this menu
|
|
// Returns true if we're starting a multiplayer game
|
|
#define CONNECT_PXO_TIMEOUT 60.0
|
|
#define MAX_CHAT_SEND_LEN 200
|
|
#define MAX_CHAT_CHANNELS 50
|
|
#define CHAT_INFO_LEN 200
|
|
#define CHAT_COUNT_LEN 10
|
|
#define CHAT_MAX_USERLIST 200
|
|
#define CHAT_USER_REFRESH_TIME 5
|
|
#define CHAT_LIST_REFRESH_TIME 10
|
|
|
|
struct {
|
|
char name[CHAT_INFO_LEN];
|
|
char origname[CHAT_INFO_LEN];
|
|
char topic[CHAT_INFO_LEN];
|
|
char count[CHAT_COUNT_LEN];
|
|
char games[CHAT_COUNT_LEN];
|
|
} chan_info[MAX_CHAT_CHANNELS];
|
|
|
|
int MainMultiplayerMenu() {
|
|
|
|
DLLmprintf(0, "%d", DESCENT3_BLOCK_SIZE);
|
|
if (!ShowMessageOfTheDay()) {
|
|
return 0;
|
|
}
|
|
|
|
DLLmprintf(0, "Inside MainMultiplayerMenu()\n");
|
|
if (Bypass_chat && !ChatStarted) {
|
|
int rcode1 = SearchMasterTrackerGameMenu();
|
|
if (rcode1 == -1)
|
|
rcode1 = 0;
|
|
return rcode1;
|
|
}
|
|
|
|
DLLToggleUICallback(0);
|
|
ChatStarted = 1;
|
|
void *title_text = DLLCreateNewUITextItem(TXT_PXO_CONNECTING, UICOL_WINDOW_TITLE);
|
|
|
|
void *cancel_on_text = DLLCreateNewUITextItem(TXT_PXO_CANCEL, UICOL_HOTSPOT_HI);
|
|
void *cancel_off_text = DLLCreateNewUITextItem(TXT_PXO_CANCEL, UICOL_HOTSPOT_LO);
|
|
|
|
void *exit_on_text = DLLCreateNewUITextItem(TXT_PXO_EXIT, UICOL_HOTSPOT_HI);
|
|
void *exit_off_text = DLLCreateNewUITextItem(TXT_PXO_EXIT, UICOL_HOTSPOT_LO);
|
|
|
|
void *priv_msg_on_text = DLLCreateNewUITextItem(TXT_PXO_SENDPRIV, UICOL_HOTSPOT_HI);
|
|
void *priv_msg_off_text = DLLCreateNewUITextItem(TXT_PXO_SENDPRIV, UICOL_HOTSPOT_LO);
|
|
|
|
void *join_lobby_on_text = DLLCreateNewUITextItem(TXT_PXO_JOINPRIV, UICOL_HOTSPOT_HI);
|
|
void *join_lobby_off_text = DLLCreateNewUITextItem(TXT_PXO_JOINPRIV, UICOL_HOTSPOT_LO);
|
|
|
|
void *join_chan_on_text = DLLCreateNewUITextItem(TXT_PXO_JOINCHAN, UICOL_HOTSPOT_HI);
|
|
void *join_chan_off_text = DLLCreateNewUITextItem(TXT_PXO_JOINCHAN, UICOL_HOTSPOT_LO);
|
|
|
|
void *find_pilot_on_text = DLLCreateNewUITextItem(TXT_PXO_FINDPILOT, UICOL_HOTSPOT_HI);
|
|
void *find_pilot_off_text = DLLCreateNewUITextItem(TXT_PXO_FINDPILOT, UICOL_HOTSPOT_LO);
|
|
|
|
void *get_pilot_on_text = DLLCreateNewUITextItem(TXT_PXO_GETPILOTINFO, UICOL_HOTSPOT_HI);
|
|
void *get_pilot_off_text = DLLCreateNewUITextItem(TXT_PXO_GETPILOTINFO, UICOL_HOTSPOT_LO);
|
|
|
|
void *game_on_text = DLLCreateNewUITextItem(TXT_PXO_JOINSTARTGAME, UICOL_HOTSPOT_HI);
|
|
void *game_off_text = DLLCreateNewUITextItem(TXT_PXO_JOINSTARTGAME, UICOL_HOTSPOT_LO);
|
|
|
|
void *send_on_text = DLLCreateNewUITextItem(TXT_PXO_SEND, UICOL_HOTSPOT_HI);
|
|
void *send_off_text = DLLCreateNewUITextItem(TXT_PXO_SEND, UICOL_HOTSPOT_LO);
|
|
|
|
char fmtlobbytext[200];
|
|
snprintf(fmtlobbytext, sizeof(fmtlobbytext), TXT_PXO_YOUAREINLOBBY, Ourlobby);
|
|
void *lobby_text = DLLCreateNewUITextItem(fmtlobbytext, UICOL_TEXT_AUX);
|
|
|
|
void *blank_text = DLLCreateNewUITextItem(TXT_PXO_BLANK, UICOL_TEXT_AUX);
|
|
char sendline[MAX_CHAT_SEND_LEN];
|
|
int exit_menu = 0;
|
|
int ret = 0;
|
|
int res;
|
|
const char *p;
|
|
int i;
|
|
float lastlisttime = 0;
|
|
float lastchanlisttime = 0;
|
|
void *chan_ti[MAX_CHAT_CHANNELS];
|
|
void *user_ti[CHAT_MAX_USERLIST];
|
|
char selpilot[MAX_CHAT_SEND_LEN];
|
|
char oldselchan[200];
|
|
for (i = 0; i < MAX_CHAT_CHANNELS; i++)
|
|
chan_ti[i] = nullptr;
|
|
for (i = 0; i < CHAT_MAX_USERLIST; i++)
|
|
user_ti[i] = nullptr;
|
|
|
|
uint8_t oldalpha = *DLLNewUIWindow_alpha;
|
|
|
|
int colx1 = 0;
|
|
int colx2 = 148;
|
|
DLLSetScreenMode(SM_MENU);
|
|
*DLLNewUIWindow_alpha = 255;
|
|
|
|
for (i = 0; i < MAX_CHAT_CHANNELS; i++) {
|
|
chan_info[i].origname[0] = '\0';
|
|
}
|
|
|
|
// Create our buttons
|
|
void *main_wnd = DLLNewUIWindowCreate(0, 0, 640, 480, UIF_PROCESS_ALL);
|
|
|
|
// void HotSpotCreate(int item,int parentitem, int id, int key, int txtitemoff, int txtitemon, int x, int y, int w,
|
|
// int h, int flags,int winnum)
|
|
void *exit_hs = DLLHotSpotCreate(main_wnd, 5, KEY_ESC, exit_off_text, exit_on_text, 33, 427, 70, 15, 0);
|
|
|
|
void *priv_hs = DLLHotSpotCreate(main_wnd, 6, 0, priv_msg_off_text, priv_msg_on_text, 328, 403, 170, 15, 0);
|
|
|
|
#define JOIN_ROW 131
|
|
void *join_lobby_hs =
|
|
DLLHotSpotCreate(main_wnd, 7, 0, join_lobby_off_text, join_lobby_on_text, 400, JOIN_ROW, 170, 15, 0);
|
|
void *join_chan_hs =
|
|
DLLHotSpotCreate(main_wnd, 14, 0, join_chan_off_text, join_chan_on_text, 178, JOIN_ROW, 170, 15, 0);
|
|
|
|
void *find_hs = DLLHotSpotCreate(main_wnd, 9, 0, find_pilot_off_text, find_pilot_on_text, 156, 403, 140, 15, 0);
|
|
void *get_pilot_hs =
|
|
DLLHotSpotCreate(main_wnd, 10, 0, get_pilot_off_text, get_pilot_on_text, colx1 + 10, 372, 130, 15, 0);
|
|
void *game_hs = DLLHotSpotCreate(main_wnd, 11, 0, game_off_text, game_on_text, 505, 431, 135, 15, 0);
|
|
|
|
void *enter_hs = DLLHotSpotCreate(main_wnd, 15, KEY_ENTER, send_off_text, send_on_text, 550, 370, 70, 15, 0);
|
|
|
|
// lobby_text
|
|
void *lobby_txt_gadget = DLLTextCreate(main_wnd, lobby_text, 200, 450, UIF_CENTER);
|
|
|
|
// User list box, id #10
|
|
void *user_list = DLLOldListCreate(main_wnd, 10, colx1 + 20, 100, 108, 265, 0);
|
|
// Channel list box, id #14
|
|
void *chan_list = DLLOldListCreate(main_wnd, 14, colx2, 25, 470, 96, 0);
|
|
|
|
// Edit box for typing in chat, id # 15
|
|
void *send_edit = DLLOldEditCreate(main_wnd, 15, colx2 + 10, 372, 390, 20, UIED_AUTOSELECT);
|
|
DLLNewUIWindowLoadBackgroundImage(main_wnd, "pxomain.ogf");
|
|
DLLSetOldEditBufferLen(send_edit, 100);
|
|
void *console_item = DLLUIConsoleGadgetCreate(main_wnd, 16, colx2, 165, 0, 51, 16, 0);
|
|
pconsole = console_item;
|
|
|
|
DLLNewUIWindowOpen(main_wnd);
|
|
// Menu loop
|
|
// Create status window while we are connecting
|
|
|
|
DLLCreateSplashScreen(TXT_PXO_CONNECTING, 1);
|
|
Chat_command *cmd;
|
|
int gotcancel = 0;
|
|
int chat_connected = 0;
|
|
float chat_conn_time = 0;
|
|
char oldseluser[100];
|
|
char chat_whois_info[PILOT_NAME_LEN + TRACKER_ID_LEN + 4];
|
|
|
|
char pilot_name[PILOT_STRING_SIZE];
|
|
CurrentPilotName(pilot_name);
|
|
|
|
snprintf(chat_whois_info, sizeof(chat_whois_info), "%s %s", sztrackerid, pilot_name);
|
|
chat_conn_time = DLLtimer_GetTime();
|
|
// DLLNewUIWindowSetFocusOnEditGadget(send_edit,main_wnd);
|
|
DLLmprintf(0, "About to connect...\n");
|
|
do {
|
|
chat_connected = ConnectToChatServer(CHATTRACKERNAME, CHATPORT, pilot_name, chat_whois_info);
|
|
// chat_connected = ConnectToChatServer("plasma.outrage.com:7000",pilot_name,chat_whois_info);
|
|
p = GetChatText();
|
|
if (p) {
|
|
DLLUIConsoleGadgetputs(console_item, p);
|
|
DLLUIConsoleGadgetputs(console_item, "\x0a\x0d");
|
|
}
|
|
if ((chat_connected == -1) || ((DLLtimer_GetTime() - chat_conn_time) > CONNECT_PXO_TIMEOUT)) {
|
|
DLLDoMessageBox(TXT_PXO_MASTERTRACKER, TXT_PXO_CANTCONNECT, MSGBOX_OK, UICOL_WINDOW_TITLE, UICOL_TEXT_NORMAL);
|
|
// Go ahead to the game screen.
|
|
// SearchMasterTrackerGameMenu();
|
|
int rcode1 = SearchMasterTrackerGameMenu();
|
|
if (rcode1 == -1)
|
|
rcode1 = 0;
|
|
ret = rcode1;
|
|
exit_menu = 1;
|
|
DLLCloseSplashScreen();
|
|
DLLNewUIWindowClose(main_wnd);
|
|
goto shutdownpxo;
|
|
// gotcancel = 1;
|
|
break;
|
|
}
|
|
res = DLLPollUI();
|
|
if (res == 99) {
|
|
SearchMasterTrackerGameMenu();
|
|
gotcancel = 1;
|
|
}
|
|
|
|
} while ((!gotcancel) && (chat_connected == 0));
|
|
DLLCloseSplashScreen();
|
|
|
|
if (gotcancel) {
|
|
ret = 0;
|
|
exit_menu = 1;
|
|
DLLNewUIWindowClose(main_wnd);
|
|
goto shutdownpxo;
|
|
}
|
|
DLLmprintf(0, "Connected to chat server!\n");
|
|
if (!JoinNewLobby("#autoselect")) {
|
|
ret = 0;
|
|
exit_menu = 1;
|
|
}
|
|
SendChatString("/list");
|
|
// DLLNewUIWindowSetFocusOnEditGadget(send_edit,main_wnd);
|
|
while (!exit_menu) {
|
|
|
|
// Handle commands...
|
|
cmd = GetChatCommandFromQueue();
|
|
if (cmd) {
|
|
switch (cmd->command) {
|
|
case CC_USER_JOINING:
|
|
case CC_USER_LEAVING:
|
|
case CC_KICKED:
|
|
case CC_NICKCHANGED:
|
|
// We will ignore all these things for now
|
|
break;
|
|
case CC_YOURCHANNEL: {
|
|
strcpy(Ourlobby, cmd->data);
|
|
char fmtlobbytext[200];
|
|
char cleanlobby[50];
|
|
memset(cleanlobby, 0, 29);
|
|
strcpy(cleanlobby, Ourlobby + 1);
|
|
for (int l = 0; l < 18; l++) {
|
|
if (cleanlobby[l] == '_')
|
|
cleanlobby[l] = ' ';
|
|
// if(cleanlobby[l]==NULL) cleanlobby[l]= ' ';
|
|
}
|
|
snprintf(fmtlobbytext, sizeof(fmtlobbytext), TXT_PXO_YOUAREINLOBBY, cleanlobby);
|
|
|
|
DLLRemoveUITextItem(lobby_text);
|
|
DLLGadgetDestroy(lobby_txt_gadget);
|
|
DLLDeleteUIItem(lobby_txt_gadget);
|
|
lobby_text = DLLCreateNewUITextItem(fmtlobbytext, UICOL_TEXT_AUX);
|
|
lobby_txt_gadget = DLLTextCreate(main_wnd, lobby_text, 0, 450, UIF_CENTER);
|
|
// Now update the text on the bottom of the screen
|
|
} break;
|
|
case CC_DISCONNECTED:
|
|
// Display a message box letting the user know we are disconnected.
|
|
DLLDoMessageBox(TXT_PXO_MASTERTRACKER, TXT_PXO_CHATDISCONNECTED, MSGBOX_OK, UICOL_WINDOW_TITLE,
|
|
UICOL_TEXT_NORMAL);
|
|
DLLNewUIWindowClose(main_wnd);
|
|
exit_menu = 1;
|
|
break;
|
|
default:
|
|
DLLmprintf(0, "Warning: Received an unknown chat command!\n");
|
|
break;
|
|
}
|
|
}
|
|
if (exit_menu)
|
|
break;
|
|
p = GetChatText();
|
|
if (p) {
|
|
DLLUIConsoleGadgetputs(console_item, p);
|
|
DLLUIConsoleGadgetputs(console_item, "\x0a\x0d");
|
|
}
|
|
// refresh the userlist
|
|
if ((DLLtimer_GetTime() - lastlisttime) > CHAT_USER_REFRESH_TIME) {
|
|
lastlisttime = DLLtimer_GetTime();
|
|
p = GetChatUserList();
|
|
if (p) {
|
|
|
|
char *oldsel = DLLOldListGetItem(user_list, DLLOldListGetSelectedIndex(user_list));
|
|
oldseluser[0] = 0;
|
|
if (oldsel)
|
|
strcpy(oldseluser, oldsel);
|
|
void *old_ti = nullptr; // = DLLCreateNewUITextItem(TXT_PXO_JOINSTARTGAME,GR_WHITE);
|
|
// int oldsel = DLLOldListGetSelectedIndex(user_list);
|
|
// void * old_ti =
|
|
|
|
DLLOldListRemoveAll(user_list);
|
|
for (i = 0; i < CHAT_MAX_USERLIST; i++) {
|
|
if (user_ti[i] != nullptr)
|
|
DLLRemoveUITextItem(user_ti[i]);
|
|
user_ti[i] = nullptr;
|
|
}
|
|
char seps[] = " ";
|
|
char *tokp;
|
|
tokp = strtok((char *)p, seps);
|
|
if (tokp) {
|
|
for (i = 0; i < CHAT_MAX_USERLIST; i++) {
|
|
user_ti[i] = DLLCreateNewUITextItem(tokp, GR_WHITE);
|
|
DLLOldListAddItem(user_list, user_ti[i]);
|
|
if (strcmp(tokp, oldseluser) == 0)
|
|
old_ti = user_ti[i];
|
|
tokp = strtok(nullptr, seps);
|
|
if (!tokp)
|
|
break;
|
|
}
|
|
if (old_ti)
|
|
DLLOldListSelectItem(user_list, old_ti);
|
|
}
|
|
}
|
|
}
|
|
// refresh the channellist
|
|
if ((DLLtimer_GetTime() - lastchanlisttime) > CHAT_LIST_REFRESH_TIME) {
|
|
lastchanlisttime = DLLtimer_GetTime();
|
|
SendChatString("/list");
|
|
}
|
|
p = GetChannelList();
|
|
if (p) {
|
|
char *pchanlist;
|
|
pchanlist = (char *)DLLmem_malloc(strlen(p) + 1);
|
|
memset(pchanlist, 0, strlen(p));
|
|
strcpy(pchanlist, p);
|
|
char *tokp = nullptr;
|
|
char *nexttok;
|
|
// tokp = strtok(pchanlist,seps);
|
|
nexttok = strchr(pchanlist, '$');
|
|
if (nexttok) {
|
|
*nexttok = '\0';
|
|
nexttok++;
|
|
tokp = nexttok;
|
|
if (nexttok) {
|
|
nexttok = strchr(nexttok, '$');
|
|
if (nexttok) {
|
|
*nexttok = '\0';
|
|
nexttok++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (tokp) {
|
|
// Remove all previous items
|
|
DLLmprintf(0, "Refreshing channel list\n");
|
|
// get the text of the currently selected channel.
|
|
// char * oldsel = DLLOldListGetItem(chan_list,DLLOldListGetSelectedIndex(chan_list));
|
|
//
|
|
int selitem = DLLOldListGetSelectedIndex(chan_list);
|
|
char *oldsel = nullptr;
|
|
oldselchan[0] = 0;
|
|
|
|
if ((selitem > 0) && (selitem < MAX_CHAT_CHANNELS)) {
|
|
oldsel = chan_info[selitem].origname;
|
|
strcpy(oldselchan, oldsel);
|
|
}
|
|
|
|
DLLOldListRemoveAll(chan_list);
|
|
for (i = 0; i < MAX_CHAT_CHANNELS; i++) {
|
|
if (chan_ti[i] != nullptr)
|
|
DLLRemoveUITextItem(chan_ti[i]);
|
|
chan_ti[i] = nullptr;
|
|
}
|
|
for (i = 0; i < MAX_CHAT_CHANNELS; i++) {
|
|
char fmtchan[500];
|
|
char *pcount = strchr(tokp, ' ');
|
|
// if(pcount)
|
|
{
|
|
if (!pcount) {
|
|
pcount = (char *)"";
|
|
} else {
|
|
// pcount++;
|
|
*pcount = '\0';
|
|
}
|
|
|
|
// 17 is the magic number we want all channel names to align with
|
|
memset(chan_info[i].name, 0, 19);
|
|
strcpy(chan_info[i].origname, tokp);
|
|
strcpy(chan_info[i].name, tokp + 1); // skip the #
|
|
for (int l = 0; l < 18; l++) {
|
|
if (chan_info[i].name[l] == '_')
|
|
chan_info[i].name[l] = ' ';
|
|
if (chan_info[i].name[l] == '\0')
|
|
chan_info[i].name[l] = ' ';
|
|
}
|
|
pcount++;
|
|
char *ptopic = pcount;
|
|
while (isdigit(*ptopic)) {
|
|
ptopic++;
|
|
}
|
|
*ptopic = '\0';
|
|
ptopic++;
|
|
// count
|
|
strcpy(chan_info[i].count, pcount);
|
|
// topic
|
|
strcpy(chan_info[i].topic, ptopic);
|
|
// Now we want it formatted nicely.....
|
|
char chan_name[100];
|
|
memset(chan_name, ' ', 99);
|
|
chan_name[99] = '\0';
|
|
char count_list[10];
|
|
memset(count_list, ' ', 9);
|
|
count_list[9] = '\0';
|
|
|
|
memset(fmtchan, 0, 500);
|
|
|
|
int textx = 0;
|
|
int charpos = 0;
|
|
int endpos;
|
|
#define LIST_ROW1 90
|
|
#define LIST_ROW2 130
|
|
|
|
strcpy(chan_name, chan_info[i].name);
|
|
endpos = strlen(chan_info[i].name);
|
|
chan_name[endpos] = ' ';
|
|
|
|
strcpy(count_list, chan_info[i].count);
|
|
endpos = strlen(chan_info[i].count);
|
|
count_list[endpos] = ' ';
|
|
|
|
while (DLLgrtext_GetTextLineWidth(fmtchan) < LIST_ROW1) {
|
|
endpos = strlen(fmtchan);
|
|
fmtchan[endpos] = chan_name[charpos];
|
|
fmtchan[endpos + 1] = NULL;
|
|
charpos++;
|
|
}
|
|
strcat(fmtchan, "\t\0");
|
|
charpos = 0;
|
|
while (DLLgrtext_GetTextLineWidth(fmtchan) < LIST_ROW2) {
|
|
endpos = strlen(fmtchan);
|
|
fmtchan[endpos] = count_list[charpos];
|
|
fmtchan[endpos + 1] = NULL;
|
|
charpos++;
|
|
}
|
|
strcat(fmtchan, "\t\0");
|
|
|
|
strcat(fmtchan, chan_info[i].topic);
|
|
// sprintf(fmtchan,"%.15s\t%s\t%s",chan_info[i].name,chan_info[i].count,chan_info[i].topic);
|
|
chan_ti[i] = DLLCreateNewUITextItem(fmtchan, GR_WHITE);
|
|
DLLOldListAddItem(chan_list, chan_ti[i]);
|
|
if (strcmp(oldselchan, chan_info[i].origname) == 0) {
|
|
DLLOldListSelectItem(chan_list, chan_ti[i]);
|
|
}
|
|
}
|
|
tokp = nexttok;
|
|
if (nexttok) {
|
|
nexttok = strchr(nexttok, '$');
|
|
if (nexttok) {
|
|
*nexttok = '\0';
|
|
nexttok++;
|
|
}
|
|
}
|
|
// tokp = strtok(NULL,seps);
|
|
if (!tokp)
|
|
break;
|
|
}
|
|
}
|
|
DLLmem_free(pchanlist);
|
|
}
|
|
|
|
res = DLLPollUI();
|
|
if (res != -1) {
|
|
// DLLNewUIWindowSetFocusOnEditGadget(send_edit,main_wnd);
|
|
}
|
|
// handle all UI results.
|
|
switch (res) {
|
|
case -1:
|
|
break;
|
|
case 3:
|
|
// Join Mastertracker game
|
|
{
|
|
DLLmprintf(0, "Sending Mastertracker game list request.\n");
|
|
RequestGameList();
|
|
DLLmprintf(0, "Calling SearchMasterTrackerGameMenu().\n");
|
|
DLLNewUIWindowClose(main_wnd);
|
|
*DLLGame_is_master_tracker_game = 1;
|
|
int gamestart = SearchMasterTrackerGameMenu();
|
|
if (gamestart == 1) {
|
|
exit_menu = 1;
|
|
ret = 1;
|
|
} else if (gamestart == 0) {
|
|
DLLNewUIWindowOpen(main_wnd);
|
|
} else if (gamestart == -1) {
|
|
exit_menu = 1;
|
|
ret = 0;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 4:
|
|
|
|
// Start Mastertracker game
|
|
// Start a netgame
|
|
DLLNewUIWindowClose(main_wnd);
|
|
*DLLGame_is_master_tracker_game = 1;
|
|
if (StartMultiplayerGameMenu()) {
|
|
exit_menu = 1;
|
|
ret = 1;
|
|
} else {
|
|
DLLNewUIWindowOpen(main_wnd);
|
|
}
|
|
break;
|
|
case 5:
|
|
DLLNewUIWindowClose(main_wnd);
|
|
exit_menu = 1;
|
|
ret = 0;
|
|
break;
|
|
case 6:
|
|
// Send a private message
|
|
// Create new dialog box, prompt for user and message, then send message
|
|
DLLmprintf(0, "Sending private Message\n");
|
|
// Get the currently selected pilot name
|
|
strcpy(selpilot, DLLOldListGetItem(user_list, DLLOldListGetSelectedIndex(user_list)));
|
|
SendWhisper(selpilot);
|
|
break;
|
|
case 7:
|
|
// Join a private channel
|
|
if (!JoinPrivateLobby()) {
|
|
ret = 0;
|
|
exit_menu = 0;
|
|
}
|
|
break;
|
|
case 8:
|
|
// Join a channel
|
|
// unused
|
|
break;
|
|
case 9:
|
|
// Find a pilot
|
|
DLLmprintf(0, "Finding a pilot\n");
|
|
FindPilot();
|
|
break;
|
|
case 10:
|
|
// Get pilot stats
|
|
DLLmprintf(0, "Getting pilot statistics\n");
|
|
strcpy(selpilot, DLLOldListGetItem(user_list, DLLOldListGetSelectedIndex(user_list)));
|
|
GetPilotStats(selpilot);
|
|
break;
|
|
case 11: {
|
|
DLLmprintf(0, "Sending Mastertracker game list request.\n");
|
|
RequestGameList();
|
|
DLLmprintf(0, "Calling SearchMasterTrackerGameMenu().\n");
|
|
DLLNewUIWindowClose(main_wnd);
|
|
*DLLGame_is_master_tracker_game = 1;
|
|
int gamestart = SearchMasterTrackerGameMenu();
|
|
if (gamestart == 1) {
|
|
exit_menu = 1;
|
|
ret = 1;
|
|
} else if (gamestart == 0) {
|
|
DLLNewUIWindowOpen(main_wnd);
|
|
} else if (gamestart == -1) {
|
|
exit_menu = 1;
|
|
ret = 0;
|
|
}
|
|
break;
|
|
} break;
|
|
case 14:
|
|
// Channel list box
|
|
DLLmprintf(0, "Joining new public channel\n");
|
|
{
|
|
int selitem = 0;
|
|
DLLmprintf(0, "Joining new public channel\n");
|
|
selitem = DLLOldListGetSelectedIndex(chan_list);
|
|
if (!JoinNewLobby(chan_info[selitem].origname)) {
|
|
ret = 0;
|
|
exit_menu = 0;
|
|
} else {
|
|
char txtmessage[200];
|
|
char cleanlobby[50];
|
|
memset(cleanlobby, 0, 29);
|
|
strcpy(cleanlobby, chan_info[selitem].origname + 1);
|
|
for (int l = 0; l < 18; l++) {
|
|
if (cleanlobby[l] == '_')
|
|
cleanlobby[l] = ' ';
|
|
}
|
|
snprintf(txtmessage, sizeof(txtmessage), TXT_PXO_INNEWLOBBY, cleanlobby);
|
|
DLLDoMessageBox(TXT_PXO_MASTERTRACKER, txtmessage, MSGBOX_OK, UICOL_WINDOW_TITLE, UICOL_TEXT_NORMAL);
|
|
}
|
|
}
|
|
|
|
break;
|
|
case 15:
|
|
// Send a message
|
|
DLLOldEditGetText(send_edit, sendline, MAX_CHAT_SEND_LEN - 1);
|
|
if (*sendline == '\0') {
|
|
break;
|
|
}
|
|
DLLOldEditSetText(send_edit, "");
|
|
p = SendChatString(sendline);
|
|
if (p) {
|
|
DLLUIConsoleGadgetputs(console_item, p);
|
|
DLLUIConsoleGadgetputs(console_item, "\x0a\x0d");
|
|
}
|
|
DLLNewUIWindowSetFocusOnEditGadget(send_edit, main_wnd);
|
|
break;
|
|
}
|
|
}
|
|
shutdownpxo:
|
|
|
|
DLLNewUIWindowDestroy(main_wnd);
|
|
DLLOldListRemoveAll(chan_list);
|
|
DLLOldListRemoveAll(user_list);
|
|
for (i = 0; i < MAX_CHAT_CHANNELS; i++) {
|
|
if (chan_ti[i] != nullptr)
|
|
DLLRemoveUITextItem(chan_ti[i]);
|
|
chan_ti[i] = nullptr;
|
|
}
|
|
for (i = 0; i < CHAT_MAX_USERLIST; i++) {
|
|
if (user_ti[i] != nullptr)
|
|
DLLRemoveUITextItem(user_ti[i]);
|
|
user_ti[i] = nullptr;
|
|
}
|
|
*DLLNewUIWindow_alpha = oldalpha;
|
|
DLLmprintf(0, "Disconnecting from PXO.\n");
|
|
DisconnectFromChatServer();
|
|
ChatStarted = 0;
|
|
DLLmprintf(0, "Disconnected.\n");
|
|
DLLToggleUICallback(1);
|
|
|
|
// Delete all those items we created
|
|
DLLDeleteUIItem(main_wnd);
|
|
DLLDeleteUIItem(priv_hs);
|
|
DLLDeleteUIItem(join_lobby_hs);
|
|
DLLDeleteUIItem(join_chan_hs);
|
|
DLLDeleteUIItem(find_hs);
|
|
DLLDeleteUIItem(get_pilot_hs);
|
|
DLLDeleteUIItem(game_hs);
|
|
DLLDeleteUIItem(enter_hs);
|
|
DLLDeleteUIItem(user_list);
|
|
DLLDeleteUIItem(chan_list);
|
|
DLLDeleteUIItem(send_edit);
|
|
DLLDeleteUIItem(console_item);
|
|
DLLDeleteUIItem(lobby_txt_gadget);
|
|
|
|
DLLRemoveUITextItem(title_text);
|
|
DLLRemoveUITextItem(lobby_text);
|
|
DLLRemoveUITextItem(cancel_on_text);
|
|
DLLRemoveUITextItem(cancel_off_text);
|
|
DLLRemoveUITextItem(exit_on_text);
|
|
DLLRemoveUITextItem(exit_off_text);
|
|
DLLRemoveUITextItem(priv_msg_on_text);
|
|
DLLRemoveUITextItem(priv_msg_off_text);
|
|
DLLRemoveUITextItem(join_lobby_on_text);
|
|
DLLRemoveUITextItem(join_lobby_off_text);
|
|
DLLRemoveUITextItem(join_chan_on_text);
|
|
DLLRemoveUITextItem(join_chan_off_text);
|
|
DLLRemoveUITextItem(find_pilot_on_text);
|
|
DLLRemoveUITextItem(find_pilot_off_text);
|
|
DLLRemoveUITextItem(get_pilot_on_text);
|
|
DLLRemoveUITextItem(get_pilot_off_text);
|
|
DLLRemoveUITextItem(game_on_text);
|
|
DLLRemoveUITextItem(game_off_text);
|
|
DLLRemoveUITextItem(blank_text);
|
|
DLLRemoveUITextItem(send_on_text);
|
|
DLLRemoveUITextItem(send_off_text);
|
|
return ret;
|
|
}
|
|
|
|
#define SORT_GAMENAME 30
|
|
#define SORT_GAMETYPE 31
|
|
#define SORT_MISSION 32
|
|
#define SORT_LEVEL 33
|
|
#define SORT_PLAYERS 34
|
|
#define SORT_PING 35
|
|
|
|
int sort_type;
|
|
|
|
bool invert_sort_gamename = true;
|
|
bool invert_sort_gametype = true;
|
|
bool invert_sort_mission = true;
|
|
bool invert_sort_levels = true;
|
|
bool invert_sort_players = true;
|
|
bool invert_sort_ping = true;
|
|
|
|
int net_game_compare(const void *arg1, const void *arg2) {
|
|
|
|
network_game *net1 = (network_game *)arg1;
|
|
network_game *net2 = (network_game *)arg2;
|
|
|
|
if ((!arg1) || (!arg2))
|
|
return 0;
|
|
|
|
switch (sort_type) {
|
|
case SORT_GAMENAME: {
|
|
return stricmp(net1->name, net2->name);
|
|
} break;
|
|
case SORT_GAMETYPE: {
|
|
return stricmp(net1->scriptname, net2->scriptname);
|
|
} break;
|
|
case SORT_MISSION: {
|
|
return stricmp(net1->mission_name, net2->mission_name);
|
|
} break;
|
|
case SORT_LEVEL: {
|
|
if (net1->level_num == net2->level_num)
|
|
return 0;
|
|
else
|
|
return (net1->level_num - net2->level_num);
|
|
} break;
|
|
case SORT_PLAYERS: {
|
|
if (net1->curr_num_players == net2->curr_num_players)
|
|
return 0;
|
|
else
|
|
return (net1->curr_num_players - net2->curr_num_players);
|
|
} break;
|
|
case SORT_PING: {
|
|
if (net1->server_response_time == net2->server_response_time)
|
|
return 0;
|
|
else
|
|
return (net1->server_response_time < net2->server_response_time) ? 1 : -1;
|
|
} break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void ResortGameList(void *lb, int type, bool invert) {
|
|
|
|
if (!*DLLNum_network_games_known) {
|
|
return;
|
|
}
|
|
// Make a copy of the games list
|
|
network_game *net_game_copy;
|
|
net_game_copy = (network_game *)DLLmem_malloc(sizeof(network_game) * (*DLLNum_network_games_known));
|
|
memcpy(net_game_copy, &DLLNetwork_games[0], sizeof(network_game) * (*DLLNum_network_games_known));
|
|
|
|
// Set the sort type
|
|
sort_type = type;
|
|
|
|
// Do the actual sort
|
|
qsort(net_game_copy, *DLLNum_network_games_known, sizeof(network_game), net_game_compare);
|
|
|
|
// Now populate the list in the order sorted...
|
|
NextGameItemNo = 0;
|
|
DLLListRemoveAll(lb);
|
|
int i;
|
|
if (!invert) {
|
|
for (i = 0; i < *DLLNum_network_games_known; i++) {
|
|
int pxo_item = GetPXOItemByHandle(net_game_copy[i].handle);
|
|
if (pxo_item != -1) {
|
|
PXOGamelist[pxo_item].lb_no = NextGameItemNo;
|
|
NextGameItemNo++;
|
|
DLLListAddItem(lb, PXOGamelist[pxo_item].ti);
|
|
}
|
|
}
|
|
} else {
|
|
for (i = *DLLNum_network_games_known; i >= 0; i--) {
|
|
int pxo_item = GetPXOItemByHandle(net_game_copy[i].handle);
|
|
if (pxo_item != -1) {
|
|
PXOGamelist[pxo_item].lb_no = NextGameItemNo;
|
|
NextGameItemNo++;
|
|
DLLListAddItem(lb, PXOGamelist[pxo_item].ti);
|
|
}
|
|
}
|
|
}
|
|
|
|
DLLmem_free(net_game_copy);
|
|
}
|
|
|
|
#define GET_MT_GAME_TIME 5
|
|
#define REQ_GAME_LIST_INTERVAL 8
|
|
|
|
#define GET_INFO_ID 50
|
|
|
|
int SearchMasterTrackerGameMenu() {
|
|
|
|
int exit_menu = 0;
|
|
int cury = 40;
|
|
int ret = 0;
|
|
int res;
|
|
|
|
game_list *games = nullptr;
|
|
int i = 0;
|
|
float last_req_time;
|
|
char selgame[200];
|
|
void *selti = nullptr;
|
|
void *return_text_on = DLLCreateNewUITextItem(TXT_PXO_RETURNTOCHAT, UICOL_HOTSPOT_HI);
|
|
void *return_text_off = DLLCreateNewUITextItem(TXT_PXO_RETURNTOCHAT, UICOL_HOTSPOT_LO);
|
|
void *game_head_text = DLLCreateNewUITextItem(TXT_PXO_GAMELISTHDR, UICOL_TEXT_NORMAL);
|
|
void *exit_on_text = DLLCreateNewUITextItem(TXT_PXO_EXIT, UICOL_HOTSPOT_HI);
|
|
void *exit_off_text = DLLCreateNewUITextItem(TXT_PXO_EXIT, UICOL_HOTSPOT_LO);
|
|
void *join_on_text = DLLCreateNewUITextItem(TXT_PXO_JOINSEL, UICOL_HOTSPOT_HI);
|
|
void *join_off_text = DLLCreateNewUITextItem(TXT_PXO_JOINSEL, UICOL_HOTSPOT_LO);
|
|
void *start_on_text = DLLCreateNewUITextItem(TXT_PXO_STARTNEW, UICOL_HOTSPOT_HI);
|
|
void *start_off_text = DLLCreateNewUITextItem(TXT_PXO_STARTNEW, UICOL_HOTSPOT_LO);
|
|
|
|
void *gname_on_text = DLLCreateNewUITextItem(TXT_PXO_GAMENAME2, UICOL_HOTSPOT_HI);
|
|
void *gname_off_text = DLLCreateNewUITextItem(TXT_PXO_GAMENAME2, UICOL_HOTSPOT_LO);
|
|
void *gtype_on_text = DLLCreateNewUITextItem(TXT_PXO_GAMETYPE, UICOL_HOTSPOT_HI);
|
|
void *gtype_off_text = DLLCreateNewUITextItem(TXT_PXO_GAMETYPE, UICOL_HOTSPOT_LO);
|
|
void *msn_on_text = DLLCreateNewUITextItem(TXT_PXO_MISSION, UICOL_HOTSPOT_HI);
|
|
void *msn_off_text = DLLCreateNewUITextItem(TXT_PXO_MISSION, UICOL_HOTSPOT_LO);
|
|
void *lvl_on_text = DLLCreateNewUITextItem(TXT_PXO_LEVEL, UICOL_HOTSPOT_HI);
|
|
void *lvl_off_text = DLLCreateNewUITextItem(TXT_PXO_LEVEL, UICOL_HOTSPOT_LO);
|
|
void *plrs_on_text = DLLCreateNewUITextItem(TXT_PXO_PLAYERS, UICOL_HOTSPOT_HI);
|
|
void *plrs_off_text = DLLCreateNewUITextItem(TXT_PXO_PLAYERS, UICOL_HOTSPOT_LO);
|
|
void *ping_on_text = DLLCreateNewUITextItem(TXT_PXO_PING, UICOL_HOTSPOT_HI);
|
|
void *ping_off_text = DLLCreateNewUITextItem(TXT_PXO_PING, UICOL_HOTSPOT_LO);
|
|
|
|
char fmt_textstr[200];
|
|
snprintf(fmt_textstr, sizeof(fmt_textstr), TXT_PXO_MAKEGAMEDEFAULT, 28);
|
|
void *default_on_text = DLLCreateNewUITextItem(fmt_textstr, UICOL_HOTSPOT_HI);
|
|
snprintf(fmt_textstr, sizeof(fmt_textstr), TXT_PXO_MAKEGAMEDEFAULT, 28);
|
|
|
|
void *default_off_text = DLLCreateNewUITextItem(fmt_textstr, UICOL_HOTSPOT_LO);
|
|
void *game_hdr_text = DLLCreateNewUITextItem(TXT_PXO_GAME_HDR, UICOL_WINDOW_TITLE);
|
|
|
|
void *info_on_text = DLLCreateNewUITextItem("", UICOL_HOTSPOT_HI);
|
|
void *info_off_text = DLLCreateNewUITextItem("", UICOL_HOTSPOT_LO);
|
|
|
|
memset(PXOGamelist, 0, sizeof(PXOGamelist));
|
|
NextGameItemNo = 0;
|
|
|
|
void *return_hs;
|
|
void *set_dft_hs;
|
|
|
|
void *net_game_txt_items[MAX_NET_GAMES];
|
|
int a;
|
|
bool hardexit = false;
|
|
for (a = 0; a < MAX_NET_GAMES; a++)
|
|
net_game_txt_items[a] = nullptr;
|
|
uint8_t oldalpha = *DLLNewUIWindow_alpha;
|
|
|
|
DLLSetScreenMode(SM_MENU);
|
|
*DLLNewUIWindow_alpha = 255;
|
|
|
|
void *main_wnd = DLLNewUIWindowCreate(0, 0, 640, 480, UIF_PROCESS_ALL);
|
|
|
|
void *screen_header = DLLTextCreate(main_wnd, game_hdr_text, 5, 15, UIF_CENTER);
|
|
cury += 30;
|
|
void *start_hs = DLLHotSpotCreate(main_wnd, 7, KEY_S, start_off_text, start_on_text, 320, cury, 150, 15, UIF_CENTER);
|
|
cury += 30; // 25;
|
|
|
|
int setdfty;
|
|
|
|
return_hs = DLLHotSpotCreate(main_wnd, 8, KEY_R, return_text_off, return_text_on, 490, cury, 250, 15, UIF_CENTER);
|
|
cury += 20;
|
|
|
|
if (Bypass_chat) {
|
|
|
|
snprintf(fmt_textstr, sizeof(fmt_textstr), TXT_PXO_MAKEGAMEDEFAULT, 29);
|
|
default_on_text = DLLCreateNewUITextItem(fmt_textstr, UICOL_HOTSPOT_HI);
|
|
snprintf(fmt_textstr, sizeof(fmt_textstr), TXT_PXO_MAKEGAMEDEFAULT, 29);
|
|
default_off_text = DLLCreateNewUITextItem(fmt_textstr, UICOL_HOTSPOT_LO);
|
|
setdfty = cury;
|
|
set_dft_hs = DLLHotSpotCreate(main_wnd, 9, 0, default_off_text, default_on_text, 490, cury, 300, 15, UIF_CENTER);
|
|
cury += 20;
|
|
} else {
|
|
snprintf(fmt_textstr, sizeof(fmt_textstr), TXT_PXO_MAKEGAMEDEFAULT, 28);
|
|
default_on_text = DLLCreateNewUITextItem(fmt_textstr, UICOL_HOTSPOT_HI);
|
|
snprintf(fmt_textstr, sizeof(fmt_textstr), TXT_PXO_MAKEGAMEDEFAULT, 28);
|
|
default_off_text = DLLCreateNewUITextItem(fmt_textstr, UICOL_HOTSPOT_LO);
|
|
setdfty = cury;
|
|
set_dft_hs = DLLHotSpotCreate(main_wnd, 9, 0, default_off_text, default_on_text, 490, cury, 300, 15, UIF_CENTER);
|
|
cury += 30;
|
|
}
|
|
// void * game_head = DLLTextCreate(main_wnd,game_head_text,45,cury,0);
|
|
|
|
void *gname_hs = DLLHotSpotCreate(main_wnd, SORT_GAMENAME, 0, gname_off_text, gname_on_text, 44, cury,
|
|
DLLgrtext_GetTextLineWidth(TXT_PXO_GAMENAME2) + 1, 15, 0);
|
|
void *gtype_hs = DLLHotSpotCreate(main_wnd, SORT_GAMETYPE, 0, gtype_off_text, gtype_on_text, 215, cury,
|
|
DLLgrtext_GetTextLineWidth(TXT_PXO_GAMETYPE) + 1, 15, 0);
|
|
void *msn_hs = DLLHotSpotCreate(main_wnd, SORT_MISSION, 0, msn_off_text, msn_on_text, 320, cury,
|
|
DLLgrtext_GetTextLineWidth(TXT_PXO_MISSION) + 1, 15, 0);
|
|
void *lvl_hs = DLLHotSpotCreate(main_wnd, SORT_LEVEL, 0, lvl_off_text, lvl_on_text, 428, cury,
|
|
DLLgrtext_GetTextLineWidth(TXT_PXO_LEVEL) + 1, 15, 0);
|
|
void *players_hs = DLLHotSpotCreate(main_wnd, SORT_PLAYERS, 0, plrs_off_text, plrs_on_text, 479, cury,
|
|
DLLgrtext_GetTextLineWidth(TXT_PXO_PLAYERS) + 1, 15, 0);
|
|
void *ping_hs = DLLHotSpotCreate(main_wnd, SORT_PING, 0, ping_off_text, ping_on_text, 549, cury,
|
|
DLLgrtext_GetTextLineWidth(TXT_PXO_PING) + 1, 15, 0);
|
|
|
|
cury += 15;
|
|
void *game_list = DLLListCreate(main_wnd, 6, 10, cury, 600, 230, UIF_CENTER | UILB_NOSORT);
|
|
cury += 260;
|
|
void *join_hs = DLLHotSpotCreate(main_wnd, 6, KEY_ENTER, join_off_text, join_on_text, 100, cury, 130, 15, 0);
|
|
void *exit_hs = DLLHotSpotCreate(main_wnd, 5, KEY_ESC, exit_off_text, exit_on_text, 400, cury, 70, 15, 0);
|
|
|
|
void *info_hs = DLLHotSpotCreate(main_wnd, GET_INFO_ID, KEY_I, info_off_text, info_on_text, 1, 1, 1, 1, 0);
|
|
|
|
DLLNewUIWindowLoadBackgroundImage(main_wnd, "pxogame.ogf");
|
|
DLLNewUIWindowOpen(main_wnd);
|
|
*DLLNum_network_games_known = 0;
|
|
int lastgamesfound = 0;
|
|
int itemp;
|
|
last_req_time = DLLtimer_GetTime();
|
|
RequestGameList();
|
|
*DLLNum_network_games_known = 0;
|
|
DLLmprintf(0, "Waiting for Mastertracker response.\n");
|
|
|
|
// Menu loop
|
|
while (!exit_menu) {
|
|
if (ChatStarted)
|
|
const char *p = GetChatText();
|
|
|
|
DLLDescentDefer();
|
|
IdleGameTracker();
|
|
games = GetGameList();
|
|
res = DLLPollUI();
|
|
if (games) {
|
|
// DLLmprintf(0,"GetGameList() returned a gamedata.\n");
|
|
for (i = 0; i < (MAX_GAME_LISTS_PER_PACKET * 4); i++) {
|
|
// char *gn = games->game_name[i];
|
|
if (games->game_type == GT_D3TNG) {
|
|
DLLSearchForGamesPXO(games->game_server[i], games->game_port[i]);
|
|
} else {
|
|
if (games->game_server[i] && games->game_port[i]) {
|
|
DLLmprintf(0, "Bad bad bad!!!!\n");
|
|
DLLSearchForGamesPXO(games->game_server[i], games->game_port[i]);
|
|
}
|
|
}
|
|
}
|
|
games = nullptr;
|
|
}
|
|
if ((DLLtimer_GetTime() - last_req_time) > REQ_GAME_LIST_INTERVAL) {
|
|
last_req_time = DLLtimer_GetTime();
|
|
RequestGameList();
|
|
*DLLMulti_Gamelist_changed = true;
|
|
int selno = DLLListGetSelectedIndex(game_list);
|
|
if (selno >= 0) {
|
|
strcpy(selgame, DLLNetwork_games[selno].name);
|
|
} else {
|
|
selgame[0] = '\0';
|
|
}
|
|
}
|
|
DLLUpdateAndPackGameList();
|
|
|
|
if ((itemp = DLLSearchForGamesPXO(0, 0)) || *DLLMulti_Gamelist_changed) {
|
|
UpdateGamelist(game_list);
|
|
}
|
|
|
|
if (res == -1) {
|
|
continue;
|
|
}
|
|
// handle all UI results.
|
|
switch (res) {
|
|
|
|
case 5:
|
|
// Hard exit. Don't return to chat if in bypass chat mode
|
|
hardexit = true;
|
|
DLLNewUIWindowClose(main_wnd);
|
|
exit_menu = 1;
|
|
break;
|
|
case 6:
|
|
// Double click on listbox, or join selected hit.
|
|
if (*DLLNum_network_games_known) {
|
|
// Get the appropriate game address
|
|
int gameno;
|
|
gameno = DLLListGetSelectedIndex(game_list);
|
|
|
|
int gameid = GetGameByLBNo(gameno);
|
|
|
|
if (gameid == -1)
|
|
break;
|
|
gameno = gameid;
|
|
|
|
DLLmprintf(0, "Selected item is %s\n", DLLNetwork_games[gameno].name);
|
|
|
|
network_address s_address;
|
|
s_address.connection_type = NP_TCP;
|
|
memcpy(&s_address.address, &DLLNetwork_games[gameno].addr, sizeof(network_address));
|
|
s_address.port = DLLNetwork_games[gameno].addr.port;
|
|
*DLLGame_is_master_tracker_game = 1;
|
|
DLLMultiStartClient(nullptr);
|
|
|
|
if (DLLDoPlayerMouselookCheck(DLLNetwork_games[gameno].flags)) {
|
|
char script_file[500];
|
|
snprintf(script_file, sizeof(script_file), "%s.d3m", DLLNetwork_games[gameno].scriptname);
|
|
if (DLLCheckGetD3M(script_file)) {
|
|
// Check to see if this mission exists!
|
|
if (DLLmsn_CheckGetMission(&s_address, DLLNetwork_games[gameno].mission)) {
|
|
if ((DLLTryToJoinServer(&s_address))) {
|
|
DLLmprintf(0, "Menu: Game joined!\n");
|
|
DLLNewUIWindowClose(main_wnd);
|
|
exit_menu = 1;
|
|
ret = 1;
|
|
} else {
|
|
DLLNewUIWindowClose(main_wnd);
|
|
DLLNewUIWindowOpen(main_wnd);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
DLLListRemoveAll(game_list);
|
|
last_req_time = DLLtimer_GetTime() - (REQ_GAME_LIST_INTERVAL * 2);
|
|
DLLDoMessageBox(TXT_PXO_ERROR, TXT_PXO_NO_GAMES, MSGBOX_OK, UICOL_WINDOW_TITLE, UICOL_TEXT_NORMAL);
|
|
}
|
|
break;
|
|
case 7:
|
|
// Start a new game
|
|
|
|
DLLNewUIWindowClose(main_wnd);
|
|
*DLLGame_is_master_tracker_game = 1;
|
|
if (StartMultiplayerGameMenu()) {
|
|
exit_menu = 1;
|
|
ret = 1;
|
|
} else {
|
|
DLLNewUIWindowOpen(main_wnd);
|
|
}
|
|
break;
|
|
case 8:
|
|
// We just want to return to chat, not totally exit PXO
|
|
DLLNewUIWindowClose(main_wnd);
|
|
exit_menu = 1;
|
|
ret = 0;
|
|
break;
|
|
case 9:
|
|
// Change the current selection
|
|
{
|
|
int bypass_chat_curr_val;
|
|
DLLDatabaseReadInt("BypassChat", &bypass_chat_curr_val);
|
|
|
|
DLLRemoveUITextItem(default_on_text);
|
|
DLLRemoveUITextItem(default_off_text);
|
|
DLLGadgetDestroy(set_dft_hs);
|
|
DLLDeleteUIItem(set_dft_hs);
|
|
if (bypass_chat_curr_val) {
|
|
bypass_chat_curr_val = 0;
|
|
DLLDatabaseWriteInt("BypassChat", bypass_chat_curr_val);
|
|
snprintf(fmt_textstr, sizeof(fmt_textstr), TXT_PXO_MAKEGAMEDEFAULT, 28);
|
|
default_on_text = DLLCreateNewUITextItem(fmt_textstr, UICOL_HOTSPOT_HI);
|
|
snprintf(fmt_textstr, sizeof(fmt_textstr), TXT_PXO_MAKEGAMEDEFAULT, 28);
|
|
default_off_text = DLLCreateNewUITextItem(fmt_textstr, UICOL_HOTSPOT_LO);
|
|
set_dft_hs =
|
|
DLLHotSpotCreate(main_wnd, 9, 0, default_off_text, default_on_text, 490, setdfty, 300, 15, UIF_CENTER);
|
|
} else {
|
|
bypass_chat_curr_val = 1;
|
|
DLLDatabaseWriteInt("BypassChat", bypass_chat_curr_val);
|
|
snprintf(fmt_textstr, sizeof(fmt_textstr), TXT_PXO_MAKEGAMEDEFAULT, 29);
|
|
default_on_text = DLLCreateNewUITextItem(fmt_textstr, UICOL_HOTSPOT_HI);
|
|
snprintf(fmt_textstr, sizeof(fmt_textstr), TXT_PXO_MAKEGAMEDEFAULT, 29);
|
|
default_off_text = DLLCreateNewUITextItem(fmt_textstr, UICOL_HOTSPOT_LO);
|
|
set_dft_hs =
|
|
DLLHotSpotCreate(main_wnd, 9, 0, default_off_text, default_on_text, 490, setdfty, 300, 15, UIF_CENTER);
|
|
}
|
|
}
|
|
break;
|
|
case GET_INFO_ID: {
|
|
if (*DLLNum_network_games_known) {
|
|
int gameno;
|
|
gameno = DLLListGetSelectedIndex(game_list);
|
|
int gameid = GetGameByLBNo(gameno);
|
|
gameno = gameid;
|
|
if (gameid == -1)
|
|
break;
|
|
DLLmprintf(0, "Selected item is %s\n", DLLNetwork_games[gameno].name);
|
|
DLLShowNetgameInfo(&DLLNetwork_games[gameno]);
|
|
}
|
|
} break;
|
|
|
|
case SORT_GAMENAME: {
|
|
DLLmprintf(0, "Sorting by game name.\n");
|
|
invert_sort_gamename = !invert_sort_gamename;
|
|
ResortGameList(game_list, res, invert_sort_gamename);
|
|
} break;
|
|
case SORT_GAMETYPE: {
|
|
DLLmprintf(0, "Sorting by game type.\n");
|
|
invert_sort_gametype = !invert_sort_gametype;
|
|
ResortGameList(game_list, res, invert_sort_gametype);
|
|
} break;
|
|
case SORT_MISSION: {
|
|
DLLmprintf(0, "Sorting by mission.\n");
|
|
invert_sort_mission = !invert_sort_mission;
|
|
ResortGameList(game_list, res, invert_sort_mission);
|
|
} break;
|
|
case SORT_LEVEL: {
|
|
DLLmprintf(0, "Sorting by level.\n");
|
|
invert_sort_levels = !invert_sort_levels;
|
|
ResortGameList(game_list, res, invert_sort_levels);
|
|
} break;
|
|
case SORT_PLAYERS: {
|
|
DLLmprintf(0, "Sorting by players.\n");
|
|
invert_sort_players = !invert_sort_players;
|
|
ResortGameList(game_list, res, invert_sort_players);
|
|
} break;
|
|
case SORT_PING: {
|
|
DLLmprintf(0, "Sorting by ping.\n");
|
|
invert_sort_ping = !invert_sort_ping;
|
|
ResortGameList(game_list, res, invert_sort_ping);
|
|
} break;
|
|
}
|
|
}
|
|
DLLNewUIWindowDestroy(main_wnd);
|
|
|
|
*DLLNewUIWindow_alpha = oldalpha;
|
|
|
|
// Look for items that we need to remove
|
|
for (i = 0; i < MAX_GAMELIST_ITEMS; i++) {
|
|
if (PXOGamelist[i].used) {
|
|
DLLRemoveUITextItem(PXOGamelist[i].ti);
|
|
PXOGamelist[i].used = false;
|
|
}
|
|
}
|
|
|
|
/*
|
|
for(a=0;a<MAX_NET_GAMES;a++)
|
|
if(net_game_txt_items[a])
|
|
DLLRemoveUITextItem(net_game_txt_items[a]);
|
|
*/
|
|
|
|
// Clean up
|
|
DLLDeleteUIItem(main_wnd);
|
|
DLLDeleteUIItem(game_list);
|
|
// DLLDeleteUIItem(game_head);
|
|
DLLDeleteUIItem(exit_hs);
|
|
DLLDeleteUIItem(join_hs);
|
|
DLLDeleteUIItem(start_hs);
|
|
DLLDeleteUIItem(screen_header);
|
|
DLLDeleteUIItem(set_dft_hs);
|
|
DLLDeleteUIItem(return_hs);
|
|
DLLDeleteUIItem(info_hs);
|
|
DLLDeleteUIItem(gname_hs);
|
|
DLLDeleteUIItem(gtype_hs);
|
|
DLLDeleteUIItem(msn_hs);
|
|
DLLDeleteUIItem(lvl_hs);
|
|
DLLDeleteUIItem(players_hs);
|
|
DLLDeleteUIItem(ping_hs);
|
|
|
|
DLLRemoveUITextItem(info_on_text);
|
|
DLLRemoveUITextItem(info_off_text);
|
|
DLLRemoveUITextItem(game_hdr_text);
|
|
DLLRemoveUITextItem(return_text_on);
|
|
DLLRemoveUITextItem(return_text_off);
|
|
DLLRemoveUITextItem(game_head_text);
|
|
DLLRemoveUITextItem(exit_on_text);
|
|
DLLRemoveUITextItem(exit_off_text);
|
|
DLLRemoveUITextItem(join_on_text);
|
|
DLLRemoveUITextItem(join_off_text);
|
|
DLLRemoveUITextItem(start_on_text);
|
|
DLLRemoveUITextItem(start_off_text);
|
|
DLLRemoveUITextItem(default_on_text);
|
|
DLLRemoveUITextItem(default_off_text);
|
|
|
|
DLLRemoveUITextItem(gname_on_text);
|
|
DLLRemoveUITextItem(gname_off_text);
|
|
DLLRemoveUITextItem(gtype_on_text);
|
|
DLLRemoveUITextItem(gtype_off_text);
|
|
DLLRemoveUITextItem(msn_on_text);
|
|
DLLRemoveUITextItem(msn_off_text);
|
|
DLLRemoveUITextItem(lvl_on_text);
|
|
DLLRemoveUITextItem(lvl_off_text);
|
|
DLLRemoveUITextItem(plrs_on_text);
|
|
DLLRemoveUITextItem(plrs_off_text);
|
|
DLLRemoveUITextItem(ping_on_text);
|
|
DLLRemoveUITextItem(ping_off_text);
|
|
|
|
if (hardexit)
|
|
return -1;
|
|
|
|
if (!ret && !ChatStarted && Bypass_chat) {
|
|
ChatStarted = 1;
|
|
ret = MainMultiplayerMenu();
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
// This is just a function that does some debugging
|
|
void CheckPXOForAnomalies() {
|
|
int i, j;
|
|
for (i = 0; i < MAX_NET_PLAYERS; i++) {
|
|
if (!(DLLMNetPlayers[i].flags & NPF_CONNECTED))
|
|
continue;
|
|
for (j = 0; j < MAX_NET_PLAYERS; j++) {
|
|
if (!(DLLMNetPlayers[j].flags & NPF_CONNECTED))
|
|
continue;
|
|
if (i == j)
|
|
continue;
|
|
if (stricmp(DLLMPlayers[i].tracker_id, DLLMPlayers[j].tracker_id) == 0) {
|
|
// Ok, what we have here is multiple users with the same tracker ID.
|
|
// This is bad. It could be user error, but it could be something worse.
|
|
FILE *errfile;
|
|
char errfilepath[_MAX_PATH];
|
|
DLLddio_MakePath(errfilepath, DLLLocalD3Dir, "pxo.err", NULL);
|
|
errfile = fopen(errfilepath, "at");
|
|
if (errfile) {
|
|
fprintf(errfile, "Dup TID: %s & %s / %s\n", DLLMPlayers[j].callsign, DLLMPlayers[i].callsign,
|
|
DLLMPlayers[i].tracker_id);
|
|
fclose(errfile);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#define MT_DATA_UPDATE_INTERVAL 10 // 30 seconds
|
|
void DoMTFrame() {
|
|
int i;
|
|
int rcode;
|
|
IdleGameTracker();
|
|
PollPTrackNet();
|
|
// Periodically update the master tracker's info.
|
|
if ((DLLtimer_GetTime() - LastTrackerDataUpdate) > MT_DATA_UPDATE_INTERVAL) {
|
|
UpdateGameData(&DLLD3_tracker_info);
|
|
LastTrackerDataUpdate = DLLtimer_GetTime();
|
|
}
|
|
|
|
if (DLLNetgame->flags & NF_TRACK_RANK) {
|
|
// Loop through all DLLMNetPlayers looking to see if we need to send or receive
|
|
if (MTWritingPilot != -1) {
|
|
// We are already sending a pilot
|
|
rcode = SendD3PilotData(nullptr);
|
|
if (rcode != 0) {
|
|
if (rcode == 1) {
|
|
// Copy data from the DLLMTPilotinfo[MTReadingPilot] struct here
|
|
DLLMNetPlayers[MTWritingPilot].flags &= ~NPF_MT_WRITING_PILOT;
|
|
DLLmprintf(0, "Pilot data wrote to the Mastertracker for Player[%d] %s (tid=%s).\n", MTWritingPilot,
|
|
DLLMTPilotinfo[MTWritingPilot].pilot_name, DLLMTPilotinfo[MTWritingPilot].tracker_id);
|
|
MTWritingPilot = -1;
|
|
|
|
} else {
|
|
DLLMNetPlayers[MTWritingPilot].flags &= ~NPF_MT_WRITING_PILOT;
|
|
DLLmprintf(0, "Pilot write to the mastertracker failed. Error code %d.\n", rcode);
|
|
MTWritingPilot = -1;
|
|
}
|
|
}
|
|
} else {
|
|
// See if se need to look for another
|
|
for (i = 0; i < MAX_NET_PLAYERS; i++) {
|
|
|
|
if (DLLMNetPlayers[i].flags & NPF_MT_WRITING_PILOT) {
|
|
if ((!(DLLMNetPlayers[i].flags & NPF_MT_READING_PILOT)) &&
|
|
(DLLMNetPlayers[i].flags & NPF_MT_HAS_PILOT_DATA)) {
|
|
strcpy(DLLMTPilotinfo[i].tracker_id, DLLMPlayers[i].tracker_id);
|
|
strcpy(DLLMTPilotinfo[i].pilot_name, DLLMPlayers[i].callsign);
|
|
DLLMTPilotinfo[i].kills = DLLMPlayers[i].kills;
|
|
DLLMTPilotinfo[i].deaths = DLLMPlayers[i].deaths;
|
|
DLLMTPilotinfo[i].suicides = DLLMPlayers[i].suicides;
|
|
DLLMTPilotinfo[i].rank = (DLLMPlayers[i].rank * 65536.0);
|
|
DLLmprintf(0, "Sending pilot %d rank of %f\n", i, DLLMTPilotinfo[i].rank / 65536.0);
|
|
|
|
DLLMTPilotinfo[i].lateral_thrust = DLLMPlayers[i].lateral_thrust;
|
|
DLLMTPilotinfo[i].rotational_thrust = DLLMPlayers[i].rotational_thrust;
|
|
DLLMTPilotinfo[i].online_time += DLLtimer_GetTime() - DLLMPlayers[i].time_in_game;
|
|
DLLMTPilotinfo[i].sliding_pct = 0; // FIXME
|
|
DLLMPlayers[i].time_in_game = DLLtimer_GetTime(); // when we write this data multiple times we need this
|
|
|
|
DLLmprintf(0, "Sending User info to the Mastertracker for Player[%d] %s (tid=%s).\n", i,
|
|
DLLMTPilotinfo[i].pilot_name, DLLMTPilotinfo[i].tracker_id);
|
|
SendD3PilotData(&DLLMTPilotinfo[i]);
|
|
|
|
MTWritingPilot = i;
|
|
i = MAX_NET_PLAYERS + 1;
|
|
break;
|
|
} else {
|
|
// If we never read this pilot's stats, we really don't care what they were.
|
|
DLLMNetPlayers[i].flags &= ~NPF_MT_READING_PILOT;
|
|
DLLMNetPlayers[i].flags &= ~NPF_MT_WRITING_PILOT;
|
|
DLLmprintf(0, "Didn't write Mastertracker stats for %s because we never received any from the tracker!\n",
|
|
DLLMPlayers[i].callsign);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Don't want to read and write at the same time at this point
|
|
if (MTWritingPilot == -1) {
|
|
if (MTReadingPilot != -1) {
|
|
// We are already waiting on a pilot
|
|
rcode = GetD3PilotData(nullptr, nullptr, nullptr);
|
|
if (rcode != 0) {
|
|
if (rcode == 1) {
|
|
DLLMNetPlayers[MTReadingPilot].flags &= ~NPF_MT_READING_PILOT;
|
|
// Copy data into the DLLMTPilotinfo[MTReadingPilot] struct here
|
|
DLLMPlayers[MTReadingPilot].kills = DLLMTPilotinfo[MTReadingPilot].kills;
|
|
DLLMPlayers[MTReadingPilot].deaths = DLLMTPilotinfo[MTReadingPilot].deaths;
|
|
DLLMPlayers[MTReadingPilot].suicides = DLLMTPilotinfo[MTReadingPilot].suicides;
|
|
DLLMPlayers[MTReadingPilot].rank = DLLMTPilotinfo[MTReadingPilot].rank / 65536.0;
|
|
DLLmprintf(0, "Read pilot %s rank of %f\n", DLLMPlayers[MTReadingPilot].callsign,
|
|
DLLMPlayers[MTReadingPilot].rank);
|
|
DLLMPlayers[MTReadingPilot].lateral_thrust = DLLMTPilotinfo[MTReadingPilot].lateral_thrust;
|
|
DLLMPlayers[MTReadingPilot].rotational_thrust = DLLMTPilotinfo[MTReadingPilot].rotational_thrust;
|
|
// DLLMPlayers[MTReadingPilot].time_in_game = DLLMTPilotinfo[MTReadingPilot].online_time;
|
|
// Something = DLLMTPilotinfo[i].sliding_pct;//FIXME
|
|
|
|
DLLMNetPlayers[MTReadingPilot].flags |= NPF_MT_HAS_PILOT_DATA;
|
|
DLLmprintf(0, "Pilot data received from the Mastertracker for Player[%d] %s (tid=%s).\n", MTReadingPilot,
|
|
DLLMTPilotinfo[MTReadingPilot].pilot_name, DLLMTPilotinfo[MTReadingPilot].tracker_id);
|
|
MTReadingPilot = -1;
|
|
} else {
|
|
// DLLMNetPlayers[MTReadingPilot].flags &= ~NPF_MT_READING_PILOT;
|
|
DLLmprintf(0, "Pilot read from mastertracker failed. Error code %d.\n", rcode);
|
|
MTReadingPilot = -1;
|
|
}
|
|
}
|
|
} else {
|
|
// See if se need to look for another
|
|
for (i = 0; i < MAX_NET_PLAYERS; i++) {
|
|
if (DLLMNetPlayers[i].flags & NPF_MT_READING_PILOT) {
|
|
MTReadingPilot = i;
|
|
DLLmprintf(0, "Requesting User info from the Mastertracker for Player[%d] %s (tid=%s).\n", i,
|
|
DLLMTPilotinfo[i].pilot_name, DLLMTPilotinfo[i].tracker_id);
|
|
GetD3PilotData(&DLLMTPilotinfo[i], DLLMPlayers[i].callsign, DLLMPlayers[i].tracker_id);
|
|
CheckPXOForAnomalies();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void DoMTGameOver(void) {
|
|
int i;
|
|
|
|
DLLShowProgressScreen(TXT_PXO_WRITINGGAMESTATS, nullptr);
|
|
|
|
if (DLLNetgame->local_role != LR_SERVER) {
|
|
return;
|
|
}
|
|
// Send all player info to the mastertracker
|
|
for (i = 0; i < MAX_NET_PLAYERS; i++) {
|
|
if ((DLLMNetPlayers[i].flags & NPF_CONNECTED) || (DLLMNetPlayers[i].flags & NPF_MT_WRITING_PILOT)) {
|
|
if (!(DLLMNetPlayers[i].flags & NPF_MT_READING_PILOT)) {
|
|
if (DLLMNetPlayers[i].flags & NPF_MT_HAS_PILOT_DATA) // Security will do this for us
|
|
{
|
|
strcpy(DLLMTPilotinfo[i].tracker_id, DLLMPlayers[i].tracker_id);
|
|
strcpy(DLLMTPilotinfo[i].pilot_name, DLLMPlayers[i].callsign);
|
|
DLLMTPilotinfo[i].kills = DLLMPlayers[i].kills;
|
|
DLLMTPilotinfo[i].deaths = DLLMPlayers[i].deaths;
|
|
DLLMTPilotinfo[i].suicides = DLLMPlayers[i].suicides;
|
|
DLLMTPilotinfo[i].rank = DLLMPlayers[i].rank * 65536.0;
|
|
DLLMTPilotinfo[i].lateral_thrust = DLLMPlayers[i].lateral_thrust;
|
|
DLLMTPilotinfo[i].rotational_thrust = DLLMPlayers[i].rotational_thrust;
|
|
DLLMTPilotinfo[i].online_time += DLLtimer_GetTime() - DLLMPlayers[i].time_in_game;
|
|
DLLMTPilotinfo[i].sliding_pct = 0; // FIXME
|
|
DLLmprintf(0, "Sending User info to the Mastertracker for Player[%d] %s (tid=%s).\n", i,
|
|
DLLMTPilotinfo[i].pilot_name, DLLMTPilotinfo[i].tracker_id);
|
|
DLLmprintf(0, "Sending pilot %d rank of %f\n", i, DLLMTPilotinfo[i].rank / 65536.0);
|
|
SendD3PilotData(&DLLMTPilotinfo[i]);
|
|
while (SendD3PilotData(nullptr) == 0) {
|
|
DLLDescentDefer();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
DLLShowProgressScreen(TXT_PXO_SENDINGGAMEOVER, nullptr);
|
|
while (!SendGameOver())
|
|
DLLDescentDefer();
|
|
}
|
|
|
|
int MTVersionCheck() {
|
|
#ifdef WIN32
|
|
int rcode;
|
|
InetGetFile *inetfile;
|
|
char sznewdll[_MAX_PATH], szolddll[_MAX_PATH], szbakdll[_MAX_PATH];
|
|
char fulldllpath[_MAX_PATH * 2];
|
|
// char dllpath[_MAX_PATH];
|
|
DLLAVInit = NULL;
|
|
DLLAVCall = NULL;
|
|
DLLAVClose = NULL;
|
|
DLLAVGetVersion = NULL;
|
|
DLLRunCheck = NULL;
|
|
// Start by getting the current MT version and see if a newer is needed
|
|
// Load the DLL and get it's version
|
|
|
|
// Specify the correct path
|
|
DLLddio_MakePath(fulldllpath, DLLLocalD3Dir, "mtav.dll", NULL);
|
|
if (!DLLmod_LoadModule(&MTAVDLLHandle, fulldllpath, MODF_LAZY)) {
|
|
DLLmprintf(0, "Unable to load Mastertracker Auto version update DLL (mtav.dll)\n");
|
|
// Try restoring a backup of the DLL
|
|
DLLddio_MakePath(szolddll, DLLLocalD3Dir, "mtav.dll", NULL);
|
|
DLLddio_MakePath(szbakdll, DLLLocalD3Dir, "mtav.bak", NULL);
|
|
CopyFile(szbakdll, szolddll, FALSE);
|
|
return 0;
|
|
}
|
|
DLLAVInit = (DLLAVInit_fp *)DLLmod_GetSymbol(&MTAVDLLHandle, "DLLAVInit", 4);
|
|
if (!DLLAVInit) {
|
|
DLLmprintf(0, "Unable to Find DLLAVInit() function in mtav.dll\n");
|
|
DLLmod_FreeModule(&MTAVDLLHandle);
|
|
// Try restoring a backup of the DLL
|
|
DLLddio_MakePath(szolddll, DLLLocalD3Dir, "mtav.dll", NULL);
|
|
DLLddio_MakePath(szbakdll, DLLLocalD3Dir, "mtav.bak", NULL);
|
|
CopyFile(szbakdll, szolddll, FALSE);
|
|
return 0;
|
|
}
|
|
DLLAVGetVersion = (DLLAVGetVersion_fp *)DLLmod_GetSymbol(&MTAVDLLHandle, "DLLAVGetVersion", 4);
|
|
if (!DLLAVGetVersion) {
|
|
DLLmprintf(0, "Unable to Find DLLAVGetVersion() function in mtav.dll\n");
|
|
DLLmod_FreeModule(&MTAVDLLHandle);
|
|
// Try restoring a backup of the DLL
|
|
DLLddio_MakePath(szolddll, DLLLocalD3Dir, "mtav.dll", NULL);
|
|
DLLddio_MakePath(szbakdll, DLLLocalD3Dir, "mtav.bak", NULL);
|
|
CopyFile(szbakdll, szolddll, FALSE);
|
|
return 0;
|
|
}
|
|
DLLRunCheck = (DLLRunCheck_fp *)DLLmod_GetSymbol(&MTAVDLLHandle, "DLLRunCheck", 4);
|
|
if (!DLLRunCheck) {
|
|
DLLmprintf(0, "Unable to Find DLLRunCheck() function in mtav.dll\n");
|
|
DLLmod_FreeModule(&MTAVDLLHandle);
|
|
// Try restoring a backup of the DLL
|
|
DLLddio_MakePath(szolddll, DLLLocalD3Dir, "mtav.dll", NULL);
|
|
DLLddio_MakePath(szbakdll, DLLLocalD3Dir, "mtav.bak", NULL);
|
|
CopyFile(szbakdll, szolddll, FALSE);
|
|
return 0;
|
|
}
|
|
uint32_t mtver;
|
|
DLLAVGetVersion((int *)&mtver);
|
|
if (MTAVersionCheck(mtver, MTUpdateURL)) {
|
|
DLLmprintf(0, "VersionCheck() returned an unexpected return code!\n");
|
|
DLLmod_FreeModule(&MTAVDLLHandle);
|
|
return 0;
|
|
}
|
|
DLLmprintf(0, "Getting Version # from Mastertracker.\n");
|
|
do {
|
|
//
|
|
rcode = MTAVersionCheck(0, NULL);
|
|
} while (rcode == 0);
|
|
|
|
if (rcode == -2) {
|
|
// Don't try anymore... it timed out.
|
|
Login_aborted = true;
|
|
}
|
|
if (rcode == 1) {
|
|
if (MTUpdateURL[0]) {
|
|
// We need to get a new DLL
|
|
DLLmprintf(0, "Mastertracker says we need a new version, which is at %s.\n", MTUpdateURL);
|
|
sprintf(sznewdll, "%s\\newmtav.dll", DLLLocalD3Dir);
|
|
DLLddio_MakePath(sznewdll, DLLLocalD3Dir, "newmtav.dll", NULL);
|
|
inetfile = new InetGetFile(MTUpdateURL, sznewdll);
|
|
while (1) {
|
|
DLLPollUI();
|
|
if (inetfile->IsFileError()) {
|
|
// Error here
|
|
DLLmprintf(0, "Mastertracker update DLL not received. Error code: %d.\n", inetfile->GetErrorCode());
|
|
DLLmod_FreeModule(&MTAVDLLHandle);
|
|
return 0;
|
|
}
|
|
if (inetfile->IsFileReceived()) {
|
|
DLLmprintf(0, "Mastertracker update DLL received.\n");
|
|
DLLmod_FreeModule(&MTAVDLLHandle);
|
|
DLLddio_MakePath(szolddll, DLLLocalD3Dir, "mtav.dll", NULL);
|
|
DLLddio_MakePath(szbakdll, DLLLocalD3Dir, "mtav.bak", NULL);
|
|
|
|
// We have the file, now backup & copy it and try to reload.
|
|
CopyFile(szolddll, szbakdll, FALSE);
|
|
CopyFile(sznewdll, szolddll, FALSE);
|
|
return 0;
|
|
}
|
|
};
|
|
} else {
|
|
DLLmprintf(0, "Mastertracker says we are up to date\n");
|
|
// Here is where we call into the DLL so it can do it's magic
|
|
DLLAVInit(0);
|
|
DLLmod_FreeModule(&MTAVDLLHandle);
|
|
return 1;
|
|
}
|
|
} else {
|
|
DLLmprintf(0, "Mastertracker timeout while getting version\n");
|
|
DLLmod_FreeModule(&MTAVDLLHandle);
|
|
return 0;
|
|
}
|
|
#endif
|
|
return 1;
|
|
}
|
|
|
|
int JoinNewLobby(const char *lobby) {
|
|
int rcode;
|
|
const char *p;
|
|
DLLmprintf(0, "Entering new lobby");
|
|
void *title_text = DLLCreateNewUITextItem(TXT_PXO_ENTERINGLOBBY, UICOL_WINDOW_TITLE);
|
|
|
|
void *cancel_on_text = DLLCreateNewUITextItem(TXT_PXO_CANCEL, UICOL_HOTSPOT_HI);
|
|
void *cancel_off_text = DLLCreateNewUITextItem(TXT_PXO_CANCEL, UICOL_HOTSPOT_LO);
|
|
|
|
void *main_wnd = DLLNewUIGameWindowCreate(0, 256, 128, 128, UIF_CENTER | UIF_PROCESS_ALL | NUWF_TITLEMED);
|
|
void *title = DLLTextCreate(main_wnd, title_text, 0, 7, UIF_CENTER);
|
|
void *cancel_hs =
|
|
DLLHotSpotCreate(main_wnd, 5, KEY_ESC, cancel_off_text, cancel_on_text, 20, 100, 70, 15, UIF_CENTER);
|
|
DLLNewUIGameWindowOpen(main_wnd);
|
|
do {
|
|
rcode = SetNewChatChannel(lobby);
|
|
p = GetChatText();
|
|
if (p && pconsole) {
|
|
DLLUIConsoleGadgetputs(pconsole, p);
|
|
DLLUIConsoleGadgetputs(pconsole, "\x0a\x0d");
|
|
}
|
|
} while (rcode == 0);
|
|
|
|
DLLNewUIGameWindowClose(main_wnd);
|
|
DLLNewUIGameWindowDestroy(main_wnd);
|
|
|
|
if (rcode == 1) {
|
|
strcpy(DLLPXO_hosted_lobby_name, lobby);
|
|
return 1;
|
|
} else {
|
|
DLLmprintf(0, "Unable to join lobby: %d\n", rcode);
|
|
char txtmessage[200];
|
|
char cleanlobby[50];
|
|
memset(cleanlobby, 0, 29);
|
|
strcpy(cleanlobby, lobby + 1);
|
|
for (int l = 0; l < 18; l++) {
|
|
if (cleanlobby[l] == '_')
|
|
cleanlobby[l] = ' ';
|
|
}
|
|
snprintf(txtmessage, sizeof(txtmessage), TXT_PXO_CANTJOINLOBBY, cleanlobby);
|
|
DLLDoMessageBox(TXT_PXO_MASTERTRACKER, txtmessage, MSGBOX_OK, UICOL_WINDOW_TITLE, UICOL_TEXT_NORMAL);
|
|
return 0;
|
|
}
|
|
|
|
DLLDeleteUIItem(main_wnd);
|
|
DLLDeleteUIItem(title);
|
|
DLLDeleteUIItem(cancel_hs);
|
|
|
|
DLLRemoveUITextItem(title_text);
|
|
DLLRemoveUITextItem(cancel_on_text);
|
|
DLLRemoveUITextItem(cancel_off_text);
|
|
}
|
|
|
|
const char *SendWhisper(const char *name) {
|
|
|
|
int exit_menu = 0;
|
|
const char *p;
|
|
char message[MAX_CHAT_SEND_LEN];
|
|
char pilot_name[MAX_CHAT_SEND_LEN];
|
|
static char fmt_msg[MAX_CHAT_SEND_LEN * 2];
|
|
void *title_text = DLLCreateNewUITextItem(TXT_PXO_PRIVATEMESSAGE, UICOL_WINDOW_TITLE);
|
|
|
|
void *cancel_on_text = DLLCreateNewUITextItem(TXT_PXO_CANCEL, UICOL_HOTSPOT_HI);
|
|
void *cancel_off_text = DLLCreateNewUITextItem(TXT_PXO_CANCEL, UICOL_HOTSPOT_LO);
|
|
void *send_on_text = DLLCreateNewUITextItem(TXT_PXO_SEND, UICOL_HOTSPOT_HI);
|
|
void *send_off_text = DLLCreateNewUITextItem(TXT_PXO_SEND, UICOL_HOTSPOT_LO);
|
|
|
|
void *pilot_text = DLLCreateNewUITextItem(TXT_PXO_PILOTNAME, UICOL_TEXT_NORMAL);
|
|
void *message_text = DLLCreateNewUITextItem(TXT_PXO_MESSAGE, UICOL_TEXT_NORMAL);
|
|
|
|
void *main_wnd = DLLNewUIGameWindowCreate(0, 0, 384, 256, UIF_PROCESS_ALL | UIF_CENTER | NUWF_TITLEMED);
|
|
|
|
void *title = DLLTextCreate(main_wnd, title_text, 0, 7, UIF_CENTER);
|
|
void *pilot = DLLTextCreate(main_wnd, pilot_text, 50, 55, 0);
|
|
void *message_t = DLLTextCreate(main_wnd, message_text, 50, 110, 0);
|
|
void *user_edit = DLLEditCreate(main_wnd, 10, 50, 75, 130, 15, 0);
|
|
void *msg_edit = DLLEditCreate(main_wnd, 3, 50, 130, 200, 15, 0);
|
|
|
|
// HotSpotCreate(int item,int parentitem, int id, int key, int txtitemoff, int txtitemon, int x, int y, int w, int h,
|
|
// int flags,int winnum)
|
|
void *cancel_hs =
|
|
DLLHotSpotCreate(main_wnd, UID_CANCEL, KEY_ESC, cancel_on_text, cancel_off_text, 130, 256 - 80, 60, 20, 0);
|
|
void *send_hs = DLLHotSpotCreate(main_wnd, UID_OK, KEY_ENTER, send_on_text, send_off_text, 60, 256 - 80, 60, 20, 0);
|
|
DLLNewUIGameWindowOpen(main_wnd);
|
|
// DLLNewUIWindowSetFocusOnEditGadget(msg_edit,main_wnd);
|
|
DLLEditSetText(user_edit, name);
|
|
while (!exit_menu) {
|
|
int res;
|
|
|
|
res = DLLDoUI();
|
|
|
|
// handle all UI results.
|
|
|
|
switch (res) {
|
|
|
|
case 3:
|
|
case UID_OK:
|
|
DLLEditGetText(user_edit, pilot_name, MAX_CHAT_SEND_LEN);
|
|
DLLEditGetText(msg_edit, message, MAX_CHAT_SEND_LEN);
|
|
snprintf(fmt_msg, sizeof(fmt_msg), "/msg %s %s", pilot_name, message);
|
|
p = SendChatString(fmt_msg);
|
|
if (p && pconsole) {
|
|
DLLUIConsoleGadgetputs(pconsole, p);
|
|
DLLUIConsoleGadgetputs(pconsole, "\x0a\x0d");
|
|
}
|
|
exit_menu = 1;
|
|
break;
|
|
case UID_CANCEL:
|
|
exit_menu = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
DLLNewUIGameWindowClose(main_wnd);
|
|
DLLNewUIGameWindowDestroy(main_wnd);
|
|
|
|
// Clean up
|
|
DLLRemoveUITextItem(title_text);
|
|
DLLRemoveUITextItem(cancel_on_text);
|
|
DLLRemoveUITextItem(cancel_off_text);
|
|
DLLRemoveUITextItem(send_on_text);
|
|
DLLRemoveUITextItem(send_off_text);
|
|
DLLRemoveUITextItem(pilot_text);
|
|
DLLRemoveUITextItem(message_text);
|
|
|
|
DLLDeleteUIItem(main_wnd);
|
|
DLLDeleteUIItem(title);
|
|
DLLDeleteUIItem(pilot);
|
|
DLLDeleteUIItem(message_t);
|
|
DLLDeleteUIItem(user_edit);
|
|
DLLDeleteUIItem(msg_edit);
|
|
DLLDeleteUIItem(cancel_hs);
|
|
DLLDeleteUIItem(send_hs);
|
|
|
|
return "";
|
|
}
|
|
|
|
int JoinPrivateLobby() {
|
|
int exit_menu = 0;
|
|
int ret = 0;
|
|
char message[MAX_CHAT_SEND_LEN];
|
|
char priv_channel[MAX_CHAT_SEND_LEN];
|
|
|
|
void *title_text = DLLCreateNewUITextItem(TXT_PXO_JOINPRIV, UICOL_WINDOW_TITLE);
|
|
|
|
void *cancel_on_text = DLLCreateNewUITextItem(TXT_PXO_CANCEL, UICOL_HOTSPOT_HI);
|
|
void *cancel_off_text = DLLCreateNewUITextItem(TXT_PXO_CANCEL, UICOL_HOTSPOT_LO);
|
|
void *join_on_text = DLLCreateNewUITextItem(TXT_PXO_JOIN, UICOL_HOTSPOT_HI);
|
|
void *join_off_text = DLLCreateNewUITextItem(TXT_PXO_JOIN, UICOL_HOTSPOT_LO);
|
|
|
|
void *channel_text = DLLCreateNewUITextItem(TXT_PXO_CHANNELNAME, UICOL_TEXT_NORMAL);
|
|
|
|
void *main_wnd = DLLNewUIGameWindowCreate(0, 0, 256, 256, UIF_PROCESS_ALL | UIF_CENTER | NUWF_TITLELARGE);
|
|
|
|
void *title = DLLTextCreate(main_wnd, title_text, 0, 7, UIF_CENTER);
|
|
void *channel_t = DLLTextCreate(main_wnd, channel_text, 50, 95, UIF_CENTER);
|
|
void *chan_edit = DLLEditCreate(main_wnd, 3, 50, 115, 130, 15, UIF_CENTER);
|
|
|
|
// DLLNewUIWindowSetFocusOnEditGadget(chan_edit,main_wnd);
|
|
// HotSpotCreate(int item,int parentitem, int id, int key, int txtitemoff, int txtitemon, int x, int y, int w, int h,
|
|
// int flags,int winnum)
|
|
void *cancel_hs =
|
|
DLLHotSpotCreate(main_wnd, UID_CANCEL, KEY_ESC, cancel_on_text, cancel_off_text, 130, 256 - 80, 60, 20, 0);
|
|
void *join_hs = DLLHotSpotCreate(main_wnd, UID_OK, KEY_ENTER, join_on_text, join_off_text, 60, 256 - 80, 60, 20, 0);
|
|
DLLNewUIGameWindowOpen(main_wnd);
|
|
while (!exit_menu) {
|
|
int res;
|
|
|
|
res = DLLDoUI();
|
|
|
|
// handle all UI results.
|
|
|
|
switch (res) {
|
|
case 3:
|
|
case UID_OK: {
|
|
DLLEditGetText(chan_edit, priv_channel, MAX_CHAT_SEND_LEN);
|
|
for (uint32_t i = 0; i < strlen(priv_channel); i++) {
|
|
if (priv_channel[i] == ' ') {
|
|
priv_channel[i] = '_';
|
|
}
|
|
}
|
|
snprintf(message, sizeof(message), "+%s", priv_channel);
|
|
ret = JoinNewLobby(message);
|
|
exit_menu = 1;
|
|
if (ret) {
|
|
char txtmessage[200];
|
|
char cleanlobby[50];
|
|
memset(cleanlobby, 0, 29);
|
|
strcpy(cleanlobby, message + 1);
|
|
for (int l = 0; l < 18; l++) {
|
|
if (cleanlobby[l] == '_')
|
|
cleanlobby[l] = ' ';
|
|
}
|
|
snprintf(txtmessage, sizeof(txtmessage), TXT_PXO_INNEWLOBBY, cleanlobby);
|
|
DLLDoMessageBox(TXT_PXO_MASTERTRACKER, txtmessage, MSGBOX_OK, UICOL_WINDOW_TITLE, UICOL_TEXT_NORMAL);
|
|
*DLLNum_network_games_known = 0;
|
|
}
|
|
} break;
|
|
case UID_CANCEL:
|
|
exit_menu = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
DLLNewUIGameWindowClose(main_wnd);
|
|
DLLNewUIGameWindowDestroy(main_wnd);
|
|
|
|
DLLRemoveUITextItem(title_text);
|
|
DLLRemoveUITextItem(cancel_on_text);
|
|
DLLRemoveUITextItem(cancel_off_text);
|
|
DLLRemoveUITextItem(join_on_text);
|
|
DLLRemoveUITextItem(join_off_text);
|
|
DLLRemoveUITextItem(channel_text);
|
|
|
|
DLLDeleteUIItem(main_wnd);
|
|
DLLDeleteUIItem(title);
|
|
DLLDeleteUIItem(channel_t);
|
|
DLLDeleteUIItem(chan_edit);
|
|
DLLDeleteUIItem(cancel_hs);
|
|
DLLDeleteUIItem(join_hs);
|
|
return ret;
|
|
}
|
|
|
|
int FindPilot() {
|
|
|
|
int exit_menu = 0;
|
|
const char *p;
|
|
char message[MAX_CHAT_SEND_LEN];
|
|
char pilot_name[MAX_CHAT_SEND_LEN];
|
|
static char fmt_msg[MAX_CHAT_SEND_LEN * 2];
|
|
void *title_text = DLLCreateNewUITextItem(TXT_PXO_FINDPILOT, UICOL_WINDOW_TITLE);
|
|
|
|
void *cancel_on_text = DLLCreateNewUITextItem(TXT_PXO_CANCEL, UICOL_HOTSPOT_HI);
|
|
void *cancel_off_text = DLLCreateNewUITextItem(TXT_PXO_CANCEL, UICOL_HOTSPOT_LO);
|
|
void *search_on_text = DLLCreateNewUITextItem(TXT_PXO_SEARCH, UICOL_HOTSPOT_HI);
|
|
void *search_off_text = DLLCreateNewUITextItem(TXT_PXO_SEARCH, UICOL_HOTSPOT_LO);
|
|
|
|
void *pilot_text = DLLCreateNewUITextItem(TXT_PXO_PILOTNAME, UICOL_TEXT_NORMAL);
|
|
|
|
void *main_wnd = DLLNewUIGameWindowCreate(0, 0, 256, 256, UIF_PROCESS_ALL | UIF_CENTER | NUWF_TITLEMED);
|
|
|
|
void *title_t = DLLTextCreate(main_wnd, title_text, 0, 7, UIF_CENTER);
|
|
void *pilot_t = DLLTextCreate(main_wnd, pilot_text, 50, 95, UIF_CENTER);
|
|
void *pilot_edit = DLLEditCreate(main_wnd, 3, 50, 115, 130, 15, UIF_CENTER);
|
|
|
|
// DLLNewUIWindowSetFocusOnEditGadget(pilot_edit,main_wnd);
|
|
// HotSpotCreate(int item,int parentitem, int id, int key, int txtitemoff, int txtitemon, int x, int y, int w, int h,
|
|
// int flags,int winnum)
|
|
void *cancel_hs =
|
|
DLLHotSpotCreate(main_wnd, UID_CANCEL, KEY_ESC, cancel_on_text, cancel_off_text, 130, 256 - 80, 60, 20, 0);
|
|
void *search_hs =
|
|
DLLHotSpotCreate(main_wnd, UID_OK, KEY_ENTER, search_on_text, search_off_text, 60, 256 - 80, 60, 20, 0);
|
|
DLLNewUIGameWindowOpen(main_wnd);
|
|
while (!exit_menu) {
|
|
int res;
|
|
|
|
res = DLLDoUI();
|
|
|
|
// handle all UI results.
|
|
|
|
switch (res) {
|
|
case 3:
|
|
case UID_OK: {
|
|
DLLEditGetText(pilot_edit, pilot_name, MAX_CHAT_SEND_LEN);
|
|
DLLCreateSplashScreen(TXT_PXO_SEARCHINGPILOT, 1);
|
|
p = GetChannelByUser(pilot_name);
|
|
while (p == nullptr) {
|
|
int sres = DLLPollUI();
|
|
// Detect if cancel is hit
|
|
if (sres == 99) {
|
|
p = nullptr;
|
|
// Cancel the lookup
|
|
GetChannelByUser((char *)-1);
|
|
break;
|
|
}
|
|
DLLDescentDefer();
|
|
p = GetChatText();
|
|
if (p && pconsole) {
|
|
DLLUIConsoleGadgetputs(pconsole, p);
|
|
DLLUIConsoleGadgetputs(pconsole, "\x0a\x0d");
|
|
}
|
|
p = GetChannelByUser(pilot_name);
|
|
}
|
|
if ((p == nullptr) || (p == (char *)-1)) {
|
|
exit_menu = 1;
|
|
DLLCloseSplashScreen();
|
|
break;
|
|
}
|
|
strcpy(message, p + 1);
|
|
for (uint32_t i = 0; i < strlen(message); i++)
|
|
if (message[i] == '_')
|
|
message[i] = ' ';
|
|
snprintf(fmt_msg, sizeof(fmt_msg), TXT_PXO_CANBEFOUNDIN, pilot_name, message);
|
|
if (pconsole) {
|
|
DLLUIConsoleGadgetputs(pconsole, fmt_msg);
|
|
DLLUIConsoleGadgetputs(pconsole, "\x0a\x0d");
|
|
}
|
|
exit_menu = 1;
|
|
DLLCloseSplashScreen();
|
|
break;
|
|
}
|
|
case UID_CANCEL:
|
|
exit_menu = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
DLLNewUIGameWindowClose(main_wnd);
|
|
DLLNewUIGameWindowDestroy(main_wnd);
|
|
|
|
DLLRemoveUITextItem(title_text);
|
|
DLLRemoveUITextItem(cancel_on_text);
|
|
DLLRemoveUITextItem(cancel_off_text);
|
|
DLLRemoveUITextItem(search_on_text);
|
|
DLLRemoveUITextItem(search_off_text);
|
|
DLLRemoveUITextItem(pilot_text);
|
|
|
|
DLLDeleteUIItem(main_wnd);
|
|
DLLDeleteUIItem(title_t);
|
|
DLLDeleteUIItem(pilot_t);
|
|
DLLDeleteUIItem(pilot_edit);
|
|
DLLDeleteUIItem(cancel_hs);
|
|
DLLDeleteUIItem(search_hs);
|
|
|
|
return 1;
|
|
}
|
|
|
|
const char *GetRankString(float ranking) {
|
|
int val = 0;
|
|
|
|
if (ranking >= 0 && ranking < 600)
|
|
val = 0;
|
|
else if (ranking >= 600 && ranking < 900)
|
|
val = 1;
|
|
else if (ranking >= 900 && ranking < 1200)
|
|
val = 2;
|
|
else if (ranking >= 1200 && ranking < 1500)
|
|
val = 3;
|
|
else if (ranking >= 1500 && ranking < 1800)
|
|
val = 4;
|
|
else if (ranking >= 1800 && ranking < 2100)
|
|
val = 5;
|
|
else if (ranking >= 2100 && ranking < 2400)
|
|
val = 6;
|
|
else if (ranking >= 2400 && ranking < 2600)
|
|
val = 7;
|
|
else if (ranking >= 2600 && ranking < 3000)
|
|
val = 8;
|
|
else if (ranking >= 3000)
|
|
val = 9;
|
|
return TXT(TXT_RANKING0 + val);
|
|
}
|
|
|
|
int GetNextRank(float ranking) {
|
|
int val = 0;
|
|
|
|
if (ranking >= 0 && ranking < 600)
|
|
val = 600;
|
|
else if (ranking >= 600 && ranking < 900)
|
|
val = 900;
|
|
else if (ranking >= 900 && ranking < 1200)
|
|
val = 1200;
|
|
else if (ranking >= 1200 && ranking < 1500)
|
|
val = 1500;
|
|
else if (ranking >= 1500 && ranking < 1800)
|
|
val = 1800;
|
|
else if (ranking >= 1800 && ranking < 2100)
|
|
val = 2100;
|
|
else if (ranking >= 2100 && ranking < 2400)
|
|
val = 2400;
|
|
else if (ranking >= 2400 && ranking < 2600)
|
|
val = 2600;
|
|
else if (ranking >= 2600 && ranking < 3000)
|
|
val = 3000;
|
|
else if (ranking >= 3000)
|
|
val = 3000;
|
|
return val;
|
|
}
|
|
|
|
int GetPilotStats(const char *pilot) {
|
|
int res;
|
|
const char *p;
|
|
char *tokp;
|
|
char tid[MAX_CHAT_SEND_LEN];
|
|
char real_pilot[MAX_CHAT_SEND_LEN];
|
|
char tmp_text[MAX_CHAT_SEND_LEN];
|
|
vmt_descent3_struct d3_pilot_info;
|
|
|
|
void *eff_text;
|
|
void *time_text;
|
|
void *main_wnd;
|
|
void *title_t;
|
|
void *kill_t;
|
|
void *death_t;
|
|
void *suicide_t;
|
|
void *eff_t;
|
|
void *time_in_game_t;
|
|
void *pilot_t;
|
|
void *rank_t;
|
|
|
|
void *title_text;
|
|
void *pilot_name_text;
|
|
void *close_on_text;
|
|
void *close_off_text;
|
|
void *kills_text;
|
|
void *deaths_text;
|
|
void *suicide_text;
|
|
void *rank_text;
|
|
|
|
DLLCreateSplashScreen(TXT_PXO_GETTINGPILOTSTAT, 1);
|
|
// Cancel previously active lookups
|
|
// GetD3PilotData((vmt_descent3_struct *)-1, NULL, NULL);
|
|
GetD3PilotDataCancel();
|
|
GetTrackerIdByUser((char *)-1);
|
|
p = GetTrackerIdByUser(pilot);
|
|
while (p == NULL) {
|
|
res = DLLPollUI();
|
|
DLLDescentDefer();
|
|
p = GetChatText();
|
|
if (p && pconsole) {
|
|
DLLUIConsoleGadgetputs(pconsole, p);
|
|
DLLUIConsoleGadgetputs(pconsole, "\x0a\x0d");
|
|
}
|
|
p = GetTrackerIdByUser(pilot);
|
|
if (res == 99) {
|
|
// cancel was hit
|
|
// Cancel the look
|
|
GetTrackerIdByUser((char *)-1);
|
|
DLLCloseSplashScreen();
|
|
}
|
|
}
|
|
if (p == (char *)-1) {
|
|
DLLmprintf(0, "Timeout looking for user\n");
|
|
DLLDoMessageBox(TXT_PXO_MASTERTRACKER, TXT_PXO_TIMEOUTMT, MSGBOX_OK, UICOL_WINDOW_TITLE, UICOL_TEXT_NORMAL);
|
|
DLLCloseSplashScreen();
|
|
return 0;
|
|
}
|
|
tokp = strchr((char *)p, ' ');
|
|
if (tokp) {
|
|
*tokp = '\0';
|
|
tokp++;
|
|
strcpy(tid, p);
|
|
strcpy(real_pilot, tokp);
|
|
DLLmprintf(0, "Requesting pilot info for %s %s\n", tid, real_pilot);
|
|
memset(&d3_pilot_info, 0, sizeof(vmt_descent3_struct));
|
|
GetD3PilotData(&d3_pilot_info, real_pilot, tid);
|
|
int iresult = 0;
|
|
while (iresult == 0) {
|
|
iresult = GetD3PilotData(nullptr, nullptr, nullptr);
|
|
res = DLLPollUI();
|
|
if (res == 99) {
|
|
// cancel was hit
|
|
// GetD3PilotData((vmt_descent3_struct *)-1, NULL, NULL);
|
|
GetD3PilotDataCancel();
|
|
iresult = -1;
|
|
}
|
|
DLLDescentDefer();
|
|
p = GetChatText();
|
|
if (p && pconsole) {
|
|
DLLUIConsoleGadgetputs(pconsole, p);
|
|
DLLUIConsoleGadgetputs(pconsole, "\x0a\x0d");
|
|
}
|
|
}
|
|
if (iresult == 1) {
|
|
DLLmprintf(0, "Got pilot info for %s %s\n", tid, real_pilot);
|
|
|
|
// Do rank thingy here.
|
|
snprintf(tmp_text, sizeof(tmp_text), "Rank: %s (%d) Next Advance at %d",
|
|
GetRankString(d3_pilot_info.rank / 65536), d3_pilot_info.rank / 65536,
|
|
GetNextRank(d3_pilot_info.rank / 65536));
|
|
rank_text = DLLCreateNewUITextItem(tmp_text, UICOL_TEXT_NORMAL);
|
|
|
|
title_text = DLLCreateNewUITextItem(TXT_PXO_PILOTSTATS, UICOL_WINDOW_TITLE);
|
|
|
|
pilot_name_text = DLLCreateNewUITextItem(real_pilot, UICOL_WINDOW_TITLE, DLL_BIG_BRIEFING_FONT);
|
|
|
|
close_on_text = DLLCreateNewUITextItem(TXT_PXO_CLOSE, UICOL_HOTSPOT_HI);
|
|
close_off_text = DLLCreateNewUITextItem(TXT_PXO_CLOSE, UICOL_HOTSPOT_LO);
|
|
|
|
snprintf(tmp_text, sizeof(tmp_text), TXT_PXO_TOTALKILLS, d3_pilot_info.kills);
|
|
kills_text = DLLCreateNewUITextItem(tmp_text, UICOL_TEXT_NORMAL);
|
|
|
|
snprintf(tmp_text, sizeof(tmp_text), TXT_PXO_TOTALDEATHS, d3_pilot_info.deaths);
|
|
deaths_text = DLLCreateNewUITextItem(tmp_text, UICOL_TEXT_NORMAL);
|
|
|
|
snprintf(tmp_text, sizeof(tmp_text), TXT_PXO_SUICIDES, d3_pilot_info.suicides);
|
|
suicide_text = DLLCreateNewUITextItem(tmp_text, UICOL_TEXT_NORMAL);
|
|
|
|
int leff = 0;
|
|
int cury;
|
|
if (d3_pilot_info.kills && d3_pilot_info.deaths) {
|
|
// leff = d3_pilot_info.kills/d3_pilot_info.deaths+d3_pilot_info.suicides+d3_pilot_info.kills;
|
|
leff = (int)((float)((float)d3_pilot_info.kills / ((float)d3_pilot_info.deaths + (float)d3_pilot_info.kills +
|
|
(float)d3_pilot_info.suicides)) *
|
|
100.0);
|
|
}
|
|
|
|
snprintf(tmp_text, sizeof(tmp_text), TXT_PXO_EFFECIENCY, leff);
|
|
eff_text = DLLCreateNewUITextItem(tmp_text, UICOL_TEXT_NORMAL);
|
|
snprintf(tmp_text, sizeof(tmp_text), TXT_PXO_TIMEINGAME, d3_pilot_info.online_time / 60);
|
|
time_text = DLLCreateNewUITextItem(tmp_text, UICOL_TEXT_NORMAL);
|
|
|
|
main_wnd = DLLNewUIGameWindowCreate(0, 0, 384, 256, UIF_PROCESS_ALL | UIF_CENTER | NUWF_TITLEMED);
|
|
|
|
title_t = DLLTextCreate(main_wnd, title_text, 0, 7, UIF_CENTER);
|
|
cury = 30;
|
|
pilot_t = DLLTextCreate(main_wnd, pilot_name_text, 0, cury, UIF_CENTER);
|
|
cury += 30;
|
|
|
|
rank_t = DLLTextCreate(main_wnd, rank_text, 0, cury, UIF_CENTER);
|
|
cury += 20;
|
|
kill_t = DLLTextCreate(main_wnd, kills_text, 0, cury, UIF_CENTER);
|
|
cury += 20;
|
|
death_t = DLLTextCreate(main_wnd, deaths_text, 0, cury, UIF_CENTER);
|
|
cury += 20;
|
|
suicide_t = DLLTextCreate(main_wnd, suicide_text, 0, cury, UIF_CENTER);
|
|
cury += 20;
|
|
eff_t = DLLTextCreate(main_wnd, eff_text, 0, cury, UIF_CENTER);
|
|
cury += 20;
|
|
time_in_game_t = DLLTextCreate(main_wnd, time_text, 0, cury, UIF_CENTER);
|
|
cury += 30;
|
|
|
|
// HotSpotCreate(int item,int parentitem, int id, int key, int txtitemoff, int txtitemon, int x, int y, int w, int
|
|
// h, int flags,int winnum)
|
|
DLLHotSpotCreate(main_wnd, UID_CANCEL, KEY_ESC, close_on_text, close_off_text, 130, cury, 60, 20, UIF_CENTER);
|
|
DLLNewUIGameWindowOpen(main_wnd);
|
|
int exit_menu = 0;
|
|
while (!exit_menu) {
|
|
int res;
|
|
|
|
res = DLLDoUI();
|
|
if (res == UID_CANCEL) {
|
|
exit_menu = 1;
|
|
}
|
|
}
|
|
DLLNewUIGameWindowClose(main_wnd);
|
|
DLLNewUIGameWindowDestroy(main_wnd);
|
|
// Cleanup
|
|
DLLRemoveUITextItem(rank_text);
|
|
DLLRemoveUITextItem(title_text);
|
|
DLLRemoveUITextItem(close_on_text);
|
|
DLLRemoveUITextItem(close_off_text);
|
|
DLLRemoveUITextItem(kills_text);
|
|
DLLRemoveUITextItem(deaths_text);
|
|
DLLRemoveUITextItem(suicide_text);
|
|
DLLRemoveUITextItem(eff_text);
|
|
DLLRemoveUITextItem(time_text);
|
|
DLLRemoveUITextItem(pilot_name_text);
|
|
|
|
DLLDeleteUIItem(pilot_t);
|
|
DLLDeleteUIItem(main_wnd);
|
|
DLLDeleteUIItem(title_t);
|
|
DLLDeleteUIItem(kill_t);
|
|
DLLDeleteUIItem(death_t);
|
|
DLLDeleteUIItem(suicide_t);
|
|
DLLDeleteUIItem(eff_t);
|
|
DLLDeleteUIItem(rank_t);
|
|
DLLDeleteUIItem(time_in_game_t);
|
|
}
|
|
}
|
|
DLLCloseSplashScreen();
|
|
|
|
return 1;
|
|
}
|
|
|
|
void AutoLoginAndJoinGame() {
|
|
|
|
int loginlen = LOGIN_LEN;
|
|
int passlen = PASSWORD_LEN;
|
|
int valret;
|
|
uint16_t port;
|
|
uint32_t iaddr;
|
|
|
|
*DLLMultiGameStarting = 0;
|
|
DLLCreateSplashScreen(TXT_PXO_CONNECTING, 0);
|
|
DLLDatabaseRead("TrackerLogin", szloginid, &loginlen);
|
|
DLLDatabaseRead("TrackerPassword", szpassword, &passlen);
|
|
if (!*DLLAuto_login_addr) {
|
|
DLLmprintf(0, "Can't autostart because no IP address was specified!!\n");
|
|
*DLLMultiGameStarting = 0;
|
|
goto failed_login;
|
|
}
|
|
if (*DLLAuto_login_port) {
|
|
port = atoi(DLLAuto_login_port);
|
|
} else {
|
|
port = DEFAULT_GAME_PORT;
|
|
}
|
|
if (!*szloginid || !*szpassword) {
|
|
if (LoginMasterTracker()) {
|
|
// Uh... now connect to the server
|
|
} else {
|
|
goto failed_login;
|
|
}
|
|
}
|
|
|
|
// Fill out the validate struct and send off the packet
|
|
validate_id_request val_user;
|
|
strcpy(val_user.tracker_id, sztrackerid);
|
|
strcpy(val_user.login, szloginid);
|
|
strcpy(val_user.password, szpassword);
|
|
|
|
valret = ValidateUser(&val_user, sztrackerid);
|
|
while (valret == 0) {
|
|
valret = ValidateUser(nullptr, nullptr);
|
|
DLLDescentDefer();
|
|
}
|
|
if (valret == 1) {
|
|
// User was validated
|
|
DLLmprintf(0, "Mastertracker user validated!\n");
|
|
strcpy(DLLTracker_id, sztrackerid);
|
|
strcpy(DLLMPlayers[DLLPlayer_num].tracker_id, sztrackerid);
|
|
|
|
} else if (valret == -1) {
|
|
// User invalid!
|
|
DLLmprintf(0, "Mastertracker user not validated!\n");
|
|
DLLDoMessageBox(TXT_PXO_MASTERTRACKER, TXT_PXO_BADLOGIN, MSGBOX_OK, UICOL_WINDOW_TITLE, UICOL_TEXT_NORMAL);
|
|
goto failed_login;
|
|
} else {
|
|
// timeout waiting for tracker!
|
|
DLLmprintf(0, "Mastertracker timeout!\n");
|
|
DLLDoMessageBox(TXT_PXO_MASTERTRACKER, TXT_PXO_TIMEOUTMT, MSGBOX_OK, UICOL_WINDOW_TITLE, UICOL_TEXT_NORMAL);
|
|
goto failed_login;
|
|
}
|
|
|
|
// Now actually connect to the server!
|
|
|
|
network_address s_address;
|
|
iaddr = inet_addr(DLLAuto_login_addr);
|
|
memcpy(&s_address.address, &iaddr, sizeof(uint32_t));
|
|
s_address.port = port;
|
|
s_address.connection_type = NP_TCP;
|
|
*DLLGame_is_master_tracker_game = 1;
|
|
DLLMultiStartClient(nullptr);
|
|
|
|
if ((DLLTryToJoinServer(&s_address))) {
|
|
DLLmprintf(0, "Menu: Game joined!\n");
|
|
*DLLMultiGameStarting = 1;
|
|
}
|
|
|
|
failed_login:
|
|
// Run this to make sure we properly ACK the server.
|
|
for (int j = 0; j < 10; j++)
|
|
PollPTrackNet();
|
|
DLLCloseSplashScreen();
|
|
}
|
|
|
|
void AutoLoginAndStartGame() {
|
|
int loginlen = LOGIN_LEN;
|
|
int passlen = PASSWORD_LEN;
|
|
int valret;
|
|
|
|
*DLLMultiGameStarting = 0;
|
|
|
|
DLLDatabaseRead("TrackerLogin", szloginid, &loginlen);
|
|
DLLDatabaseRead("TrackerPassword", szpassword, &passlen);
|
|
|
|
if (!*szloginid || !*szpassword) {
|
|
if (LoginMasterTracker()) {
|
|
// Uh... now connect to the server
|
|
} else {
|
|
goto failed_login;
|
|
}
|
|
}
|
|
|
|
// Fill out the validate struct and send off the packet
|
|
validate_id_request val_user;
|
|
strcpy(val_user.tracker_id, sztrackerid);
|
|
strcpy(val_user.login, szloginid);
|
|
strcpy(val_user.password, szpassword);
|
|
|
|
valret = ValidateUser(&val_user, sztrackerid);
|
|
while (valret == 0) {
|
|
valret = ValidateUser(nullptr, nullptr);
|
|
DLLDescentDefer();
|
|
}
|
|
if (valret == 1) {
|
|
// User was validated
|
|
DLLmprintf(0, "Mastertracker user validated!\n");
|
|
DLLPrintDedicatedMessage("Mastertracker user validated.\n");
|
|
strcpy(DLLTracker_id, sztrackerid);
|
|
strcpy(DLLMPlayers[DLLPlayer_num].tracker_id, sztrackerid);
|
|
|
|
} else if (valret == -1) {
|
|
// User invalid!
|
|
DLLmprintf(0, "Mastertracker user not validated!\n");
|
|
DLLPrintDedicatedMessage("Mastertracker user not validated!\n");
|
|
goto failed_login;
|
|
} else {
|
|
// timeout waiting for tracker!
|
|
DLLmprintf(0, "Mastertracker timeout!\n");
|
|
DLLPrintDedicatedMessage("Mastertracker timeout!\n");
|
|
goto failed_login;
|
|
}
|
|
|
|
*DLLMultiGameStarting = 1;
|
|
*DLLGame_is_master_tracker_game = 1;
|
|
// strcpy(DLLD3_tracker_info.game_name,DLLNetgame->name);
|
|
// strcpy(DLLD3_tracker_info.mission_name,DLLNetgame->mission);
|
|
strcpy(DLLD3_tracker_info.lobby, DLLPXO_hosted_lobby_name);
|
|
|
|
failed_login:
|
|
// Run this to make sure we properly ACK the server.
|
|
for (int j = 0; j < 10; j++)
|
|
PollPTrackNet();
|
|
}
|
|
|
|
#define MAX_MOTD_LEN 400
|
|
#define NUM_MOTD_LINES 6
|
|
#define MOTD_WIDTH 384
|
|
#define MOTD_HEIGHT 256
|
|
|
|
int ShowMessageOfTheDay(void) {
|
|
static char szlastmotd[MAX_MOTD_LEN];
|
|
static char sznewmotd[MAX_MOTD_LEN];
|
|
int motdlen = MAX_MOTD_LEN;
|
|
int res;
|
|
int rval = 0;
|
|
static void *main_wnd;
|
|
void *close_hs;
|
|
|
|
int last_motd_version = 0;
|
|
|
|
DLLDatabaseReadInt("MOTDVersion", &last_motd_version);
|
|
|
|
if (Motd_version == last_motd_version) {
|
|
// MOTD is old....
|
|
DLLmprintf(0, "MOTD is old, skipping\n");
|
|
return 1;
|
|
}
|
|
|
|
DLLDatabaseWriteInt("MOTDVersion", Motd_version);
|
|
|
|
void *close_on_text = DLLCreateNewUITextItem(TXT_PXO_CLOSE, UICOL_HOTSPOT_HI);
|
|
void *close_off_text = DLLCreateNewUITextItem(TXT_PXO_CLOSE, UICOL_HOTSPOT_LO);
|
|
void *motd_text = DLLCreateNewUITextItem("PXO Message of the day", UICOL_WINDOW_TITLE);
|
|
|
|
main_wnd = DLLNewUIGameWindowCreate(0, 0, MOTD_WIDTH, MOTD_HEIGHT, UIF_PROCESS_ALL | UIF_CENTER | NUWF_TITLELARGE);
|
|
|
|
void *console_item = DLLUIConsoleGadgetCreate(main_wnd, 15, 20, 30, 0, 40, 20, 0);
|
|
void *title = DLLTextCreate(main_wnd, motd_text, 0, 7, UIF_CENTER);
|
|
|
|
close_hs = DLLHotSpotCreate(main_wnd, UID_OK, KEY_ENTER, close_off_text, close_on_text, 60, MOTD_HEIGHT - 60, 60, 20,
|
|
UIF_CENTER);
|
|
|
|
DLLDatabaseRead("LastMOTD", szlastmotd, &motdlen);
|
|
|
|
DLLmprintf(0, "Getting message of the day...\n");
|
|
DLLCreateSplashScreen(TXT_PXO_CONNECTING, 1);
|
|
int mcode = GetD3MOTD(sznewmotd, MAX_MOTD_LEN);
|
|
do {
|
|
mcode = GetD3MOTD(nullptr, 0);
|
|
res = DLLPollUI();
|
|
if (res == 99) {
|
|
GetD3MOTDCancel();
|
|
DLLCloseSplashScreen();
|
|
goto close_motd;
|
|
}
|
|
DLLDescentDefer();
|
|
} while (mcode == 0);
|
|
|
|
DLLCloseSplashScreen();
|
|
|
|
if (mcode == 1) {
|
|
DLLmprintf(0, "Message of the day: %s\n", sznewmotd);
|
|
if (strcmp(szlastmotd, sznewmotd) != 0) {
|
|
DLLNewUIGameWindowOpen(main_wnd);
|
|
DLLUIConsoleGadgetputs(console_item, sznewmotd);
|
|
DLLDatabaseWrite("LastMOTD", sznewmotd, strlen(sznewmotd) + 1);
|
|
do {
|
|
res = DLLPollUI();
|
|
DLLDescentDefer();
|
|
} while (res != UID_OK);
|
|
DLLNewUIGameWindowClose(main_wnd);
|
|
rval = 1;
|
|
goto close_motd;
|
|
} else {
|
|
DLLmprintf(0, "Message of the day is old, ignoring!\n");
|
|
rval = 1;
|
|
goto close_motd;
|
|
}
|
|
} else {
|
|
DLLmprintf(0, "Get message of the day failed (%d)!\n", mcode);
|
|
goto close_motd;
|
|
}
|
|
|
|
close_motd:
|
|
DLLmprintf(0, "Ending motd\n");
|
|
DLLNewUIGameWindowDestroy(main_wnd);
|
|
DLLRemoveUITextItem(motd_text);
|
|
DLLRemoveUITextItem(close_on_text);
|
|
DLLRemoveUITextItem(close_off_text);
|
|
|
|
DLLDeleteUIItem(console_item);
|
|
DLLDeleteUIItem(title);
|
|
DLLDeleteUIItem(close_hs);
|
|
DLLDeleteUIItem(main_wnd);
|
|
return rval;
|
|
}
|