开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
game.c
资源名称：pvpgn-1.6.2.rar　[点击查看]
上传用户：tany51
上传日期：2013-06-12
资源大小：1397k
文件大小：56k
源码类别：

MySQL数据库

开发平台：

Visual C++

game.c：源码内容
  1. /*
  2.  * Copyright (C) 1998  Mark Baysinger (mbaysing@ucsd.edu)
  3.  * Copyright (C) 1998,1999,2000 Ross Combs (rocombs@cs.nmsu.edu)
  4.  *
  5.  * This program is free software; you can redistribute it and/or
  6.  * modify it under the terms of the GNU General Public License
  7.  * as published by the Free Software Foundation; either version 2
  8.  * of the License, or (at your option) any later version.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18.  */
  19. #define GAME_INTERNAL_ACCESS
  20. #include "common/setup_before.h"
  21. #include <stdio.h>
  22. #ifdef HAVE_STDDEF_H
  23. # include <stddef.h>
  24. #else
  25. # ifndef NULL
  26. #  define NULL ((void *)0)
  27. # endif
  28. #endif
  29. #ifdef STDC_HEADERS
  30. # include <stdlib.h>
  31. #else
  32. # ifdef HAVE_MALLOC_H
  33. #  include <malloc.h>
  34. # endif
  35. #endif
  36. #ifdef HAVE_STRING_H
  37. # include <string.h>
  38. #else
  39. # ifdef HAVE_STRINGS_H
  40. #  include <strings.h>
  41. # endif
  42. #endif
  43. #include "compat/strdup.h"
  44. #include "compat/strcasecmp.h"
  45. #include <errno.h>
  46. #include "compat/strerror.h"
  47. #ifdef HAVE_UNISTD_H
  48. # include <unistd.h>
  49. #endif
  50. #ifdef TIME_WITH_SYS_TIME
  51. # include <sys/time.h>
  52. # include <time.h>
  53. #else
  54. # ifdef HAVE_SYS_TIME_H
  55. #  include <sys/time.h>
  56. # else
  57. #  include <time.h>
  58. # endif
  59. #endif
  60. #include "compat/difftime.h"
  61. #ifdef HAVE_SYS_TYPES_H
  62. # include <sys/types.h>
  63. #endif
  64. #include "common/eventlog.h"
  65. #include "prefs.h"
  66. #include "connection.h"
  67. #include "account.h"
  68. #include "ladder.h"
  69. #include "ladder_calc.h"
  70. #include "common/bnettime.h"
  71. #include "common/util.h"
  72. #include "common/list.h"
  73. #include "common/tag.h"
  74. #include "common/addr.h"
  75. #include "realm.h"
  76. #include "watch.h"
  77. #include "game_conv.h"
  78. #include "game.h"
  79. #include "common/setup_after.h"
  81. static t_list * gamelist_head=NULL;
  82. static int totalcount=0;
  85. static void game_choose_host(t_game * game);
  86. static void game_destroy(t_game const * game);
  87. static int game_report(t_game * game);
  90. static void game_choose_host(t_game * game)
  91. {
  92.     unsigned int i;
  93.     
  94.     if (game->count<1)
  95.     {
  96. eventlog(eventlog_level_error,"game_choose_host","game has had no connections?!");
  97. return;
  98.     }
  99.     if (!game->connections)
  100.     {
  101. eventlog(eventlog_level_error,"game_choose_host","game has NULL connections array");
  102. return;
  103.     }
  104.     
  105.     for (i=0; i<game->count; i++)
  106. if (game->connections[i])
  107. {
  108.     game->owner = game->connections[i];
  109.     game->addr  = conn_get_game_addr(game->connections[i]);
  110.     game->port  = conn_get_game_port(game->connections[i]);
  111.     return;
  112. }
  113.     eventlog(eventlog_level_warn,"game_choose_host","no valid connections found");
  114. }
  117. extern char const * game_type_get_str(t_game_type type)
  118. {
  119.     switch (type)
  120.     {
  121.     case game_type_none:
  122. return "NONE";
  124.     case game_type_melee:
  125. return "melee";
  127.     case game_type_topvbot:
  128. return "top vs bottom";
  130.     case game_type_ffa:
  131. return "free for all";
  133.     case game_type_oneonone:
  134. return "one on one";
  136.     case game_type_ctf:
  137. return "capture the flag";
  139.     case game_type_greed:
  140. return "greed";
  142.     case game_type_slaughter:
  143. return "slaughter";
  145.     case game_type_sdeath:
  146. return "sudden death";
  148.     case game_type_ladder:
  149. return "ladder";
  151.     case game_type_ironman:
  152. return "ironman";
  154.     case game_type_mapset:
  155. return "mapset";
  157.     case game_type_teammelee:
  158. return "team melee";
  160.     case game_type_teamffa:
  161. return "team free for all";
  163.     case game_type_teamctf:
  164. return "team capture the flag";
  166.     case game_type_pgl:
  167. return "PGL";
  169.     case game_type_diablo:
  170. return "Diablo";
  172.     case game_type_diablo2open:
  173. return "Diablo II (open)";
  175.     case game_type_diablo2closed:
  176. return "Diablo II (closed)";
  178.     case game_type_all:
  179.     default:
  180. return "UNKNOWN";
  181.     }
  182. }
  185. extern char const * game_status_get_str(t_game_status status)
  186. {
  187.     switch (status)
  188.     {
  189.     case game_status_started:
  190. return "started";
  192.     case game_status_full:
  193. return "full";
  195.     case game_status_open:
  196. return "open";
  198.     case game_status_done:
  199. return "done";
  201.     default:
  202. return "UNKNOWN";
  203.     }
  204. }
  207. extern char const * game_result_get_str(t_game_result result)
  208. {
  209.     switch (result)
  210.     {
  211.     case game_result_none:
  212.         return "NONE";
  214.     case game_result_win:
  215.         return "WIN";
  217.     case game_result_loss:
  218.         return "LOSS";
  220.     case game_result_draw:
  221.         return "DRAW";
  223.     case game_result_disconnect:
  224.         return "DISCONNECT";
  226.     case game_result_observer:
  227. return "OBSERVER";
  229.     default:
  230.         return "UNKNOWN";
  231.     }
  232. }
  235. extern char const * game_option_get_str(t_game_option option)
  236. {
  237.     switch (option)
  238.     {
  239.     case game_option_melee_normal:
  240. return "normal";
  241.     case game_option_ffa_normal:
  242. return "normal";
  243.     case game_option_oneonone_normal:
  244. return "normal";
  245.     case game_option_ctf_normal:
  246. return "normal";
  247.     case game_option_greed_10000:
  248. return "10000 minerals";
  249.     case game_option_greed_7500:
  250. return "7500 minerals";
  251.     case game_option_greed_5000:
  252. return "5000 minerals";
  253.     case game_option_greed_2500:
  254. return "2500 minerals";
  255.     case game_option_slaughter_60:
  256. return "60 minutes";
  257.     case game_option_slaughter_45:
  258. return "45 minutes";
  259.     case game_option_slaughter_30:
  260. return "30 minutes";
  261.     case game_option_slaughter_15:
  262. return "15 minutes";
  263.     case game_option_sdeath_normal:
  264. return "normal";
  265.     case game_option_ladder_countasloss:
  266. return "count as loss";
  267.     case game_option_ladder_nopenalty:
  268. return "no penalty";
  269.     case game_option_mapset_normal:
  270. return "normal";
  271.     case game_option_teammelee_4:
  272. return "4 teams";
  273.     case game_option_teammelee_3:
  274. return "3 teams";
  275.     case game_option_teammelee_2:
  276. return "2 teams";
  277.     case game_option_teamffa_4:
  278. return "4 teams";
  279.     case game_option_teamffa_3:
  280. return "3 teams";
  281.     case game_option_teamffa_2:
  282. return "2 teams";
  283.     case game_option_teamctf_4:
  284. return "4 teams";
  285.     case game_option_teamctf_3:
  286. return "3 teams";
  287.     case game_option_teamctf_2:
  288. return "2 teams";
  289.     case game_option_none:
  290. return "none";
  291.     default:
  292. return "UNKNOWN";
  293.     }
  294. }
  297. extern char const * game_maptype_get_str(t_game_maptype maptype)
  298. {
  299.     switch (maptype)
  300.     {
  301.     case game_maptype_selfmade:
  302. return "Self-Made";
  303.     case game_maptype_blizzard:
  304. return "Blizzard";
  305.     case game_maptype_ladder:
  306. return "Ladder";
  307.     case game_maptype_pgl:
  308. return "PGL";
  309.     default:
  310. return "Unknown";
  311.     }
  312. }
  315. extern char const * game_tileset_get_str(t_game_tileset tileset)
  316. {
  317.     switch (tileset)
  318.     {
  319.     case game_tileset_badlands:
  320. return "Badlands";
  321.     case game_tileset_space:
  322. return "Space";
  323.     case game_tileset_installation:
  324. return "Installation";
  325.     case game_tileset_ashworld:
  326. return "Ash World";
  327.     case game_tileset_jungle:
  328. return "Jungle";
  329.     case game_tileset_desert:
  330. return "Desert";
  331.     case game_tileset_ice:
  332. return "Ice";
  333.     case game_tileset_twilight:
  334. return "Twilight";
  335.     default:
  336. return "Unknown";
  337.     }
  338. }
  341. extern char const * game_speed_get_str(t_game_speed speed)
  342. {
  343.     switch (speed)
  344.     {
  345.     case game_speed_slowest:
  346. return "slowest";
  347.     case game_speed_slower:
  348. return "slower";
  349.     case game_speed_slow:
  350. return "slow";
  351.     case game_speed_normal:
  352. return "normal";
  353.     case game_speed_fast:
  354. return "fast";
  355.     case game_speed_faster:
  356. return "faster";
  357.     case game_speed_fastest:
  358. return "fastest";
  359.     default:
  360. return "unknown";
  361.     }
  362. }
  365. extern char const * game_difficulty_get_str(t_game_difficulty difficulty)
  366. {
  367.     switch (difficulty)
  368.     {
  369.     case game_difficulty_normal:
  370. return "normal";
  371.     case game_difficulty_nightmare:
  372. return "nightmare";
  373.     case game_difficulty_hell:
  374. return "hell";
  375.     case game_difficulty_hardcore_normal:
  376. return "hardcore normal";
  377.     case game_difficulty_hardcore_nightmare:
  378. return "hardcore nightmare";
  379.     case game_difficulty_hardcore_hell:
  380. return "hardcore hell";
  381.     default:
  382. return "unknown";
  383.     }
  384. }
  387. extern t_game * game_create(char const * name, char const * pass, char const * info, t_game_type type, int startver, char const * clienttag, unsigned long gameversion)
  388. {
  389.     t_game * game;
  390.     time_t now;
  392.     now = time(NULL);
  393.     
  394.     if (!name)
  395.     {
  396. eventlog(eventlog_level_info,"game_create","got NULL game name");
  397. return NULL;
  398.     }
  399.     if (!pass)
  400.     {
  401. eventlog(eventlog_level_info,"game_create","got NULL game pass");
  402. return NULL;
  403.     }
  404.     if (!info)
  405.     {
  406. eventlog(eventlog_level_info,"game_create","got NULL game info");
  407. return NULL;
  408.     }
  409.     
  410.     if (gamelist_find_game(name,game_type_all))
  411.     {
  412. eventlog(eventlog_level_info,"game_create","game "%s" not created because it already exists",name);
  413. return NULL; /* already have a game by that name */
  414.     }
  415.     
  416.     if (!(game = malloc(sizeof(t_game))))
  417.     {
  418. eventlog(eventlog_level_error,"game_create","could not allocate memory for game");
  419. return NULL;
  420.     }
  421.     
  422.     if (!(game->name = strdup(name)))
  423.     {
  424. free(game);
  425. return NULL;
  426.     }
  427.     if (!(game->pass = strdup(pass)))
  428.     {
  429. free((void *)game->name); /* avoid warning */
  430. free(game);
  431. return NULL;
  432.     }
  433.     if (!(game->info = strdup(info)))
  434.     {
  435. free((void *)game->pass); /* avoid warning */
  436. free((void *)game->name); /* avoid warning */
  437. free(game);
  438. return NULL;
  439.     }
  440.     if (!(game->clienttag = strdup(clienttag)))
  441.     {
  442. eventlog(eventlog_level_error,"game_create","could not allocate memory for game->clienttag");
  443. free((void *)game->info); /* avoid warning */
  444. free((void *)game->pass); /* avoid warning */
  445. free((void *)game->name); /* avoid warning */
  446. free(game);
  447. return NULL;
  448.     }
  450.     game->type          = type;
  451.     game->addr          = 0; /* will be set by first player */
  452.     game->port          = 0; /* will be set by first player */
  453.     game->version       = gameversion;
  454.     game->startver      = startver; /* start packet version */
  455.     game->status        = game_status_open;
  456.     game->realm         = 0;
  457.     game->realmname     = NULL;
  458.     game->id            = ++totalcount;
  459.     game->mapname       = NULL;
  460.     game->ref           = 0;
  461.     game->count         = 0;
  462.     game->owner         = NULL;
  463.     game->connections   = NULL;
  464.     game->players       = NULL;
  465.     game->results       = NULL;
  466.     game->report_heads  = NULL;
  467.     game->report_bodies = NULL;
  468.     game->create_time   = now;
  469.     game->start_time    = (time_t)0;
  470.     game->lastaccess_time = now;
  471.     game->option        = game_option_none;
  472.     game->maptype       = game_maptype_none;
  473.     game->tileset       = game_tileset_none;
  474.     game->speed         = game_speed_none;
  475.     game->mapsize_x     = 0;
  476.     game->mapsize_y     = 0;
  477.     game->maxplayers    = 0;
  478.     game->bad           = 0;
  479.     game->description   = NULL;
  480.     game->flag   = strcmp(pass,"") ? game_flag_private : game_flag_none;
  481.     game->difficulty    = game_difficulty_none;
  483.     game_parse_info(game,info);
  484.     
  485.     if (list_prepend_data(gamelist_head,game)<0)
  486.     {
  487. eventlog(eventlog_level_error,"game_create","could not insert game");
  488. free((void *)game->clienttag); /* avoid warning */
  489. free((void *)game->info); /* avoid warning */
  490. free((void *)game->pass); /* avoid warning */
  491. free((void *)game->name); /* avoid warning */
  492. free(game);
  493. return NULL;
  494.     }
  496.     eventlog(eventlog_level_info,"game_create","game "%s" (pass "%s") type %hu(%s) startver %d created",name,pass,(unsigned short)type,game_type_get_str(type),startver);
  497.     
  498.     return game;
  499. }
  502. static void game_destroy(t_game const * game)
  503. {
  504.     unsigned int i;
  505.     
  506.     if (!game)
  507.     {
  508. eventlog(eventlog_level_error,"game_destroy","got NULL game");
  509. return;
  510.     }
  511.     
  512.     if (list_remove_data(gamelist_head,game)<0)
  513.     {
  514. eventlog(eventlog_level_error,"game_destroy","could not find game "%s" in list",game_get_name(game));
  515.         return;
  516.     }
  517.     
  518.     if (game->realmname)
  519.     { 
  520.         realm_add_game_number(realmlist_find_realm(game->realmname),-1); 
  521.     } 
  523.     eventlog(eventlog_level_debug,"game_destroy","game "%s" (count=%u ref=%u) removed from list...",game_get_name(game),game->count,game->ref);
  524.     
  525.     for (i=0; i<game->count; i++)
  526.     {
  527. if (game->report_bodies && game->report_bodies[i])
  528.     free((void *)game->report_bodies[i]); /* avoid warning */
  529. if (game->report_heads && game->report_heads[i])
  530.     free((void *)game->report_heads[i]); /* avoid warning */
  531.     }
  532.     if (game->realmname)
  533. free((void *)game->realmname); /* avoid warining */
  534.     if (game->report_bodies)
  535. free((void *)game->report_bodies); /* avoid warning */
  536.     if (game->report_heads)
  537. free((void *)game->report_heads); /* avoid warning */
  538.     if (game->results)
  539. free((void *)game->results); /* avoid warning */
  540.     if (game->connections)
  541. free((void *)game->connections); /* avoid warning */
  542.     if (game->players)
  543. free((void *)game->players); /* avoid warning */
  544.     if (game->mapname)
  545. free((void *)game->mapname); /* avoid warning */
  546.     // [zap-zero] 20020731 - fixed small memory leak
  547.     if (game->clienttag)
  548. free((void *)game->clienttag); /* avoid warning */
  550.     if (game->description)
  551. free((void *)game->description); /* avoid warning */
  553.     free((void *)game->info); /* avoid warning */
  554.     free((void *)game->pass); /* avoid warning */
  555.     free((void *)game->name); /* avoid warning */
  556.     free((void *)game); /* avoid warning */
  557.     
  558.     eventlog(eventlog_level_info,"game_destroy","game deleted");
  559.     
  560.     return;
  561. }
  564. static int game_report(t_game * game)
  565. {
  566.     FILE *          fp;
  567.     char *          realname;
  568.     char *          tempname;
  569.     char const *    tname;
  570.     unsigned int    i;
  571.     unsigned int    realcount;
  572.     time_t          now=time(NULL);
  573.     t_ladder_info * ladder_info=NULL;
  574.     int             discisloss;
  575.     
  576.     if (!game)
  577.     {
  578. eventlog(eventlog_level_error,"game_report","got NULL game");
  579. return -1;
  580.     }
  581.     if (!game->clienttag || strlen(game->clienttag)!=4)
  582.     {
  583. eventlog(eventlog_level_error,"game_report","got bad clienttag");
  584. return -1;
  585.     }
  586.     if (!game->players)
  587.     {
  588. eventlog(eventlog_level_error,"game_report","player array is NULL");
  589. return -1;
  590.     }
  591.     if (!game->results)
  592.     {
  593. eventlog(eventlog_level_error,"game_report","results array is NULL");
  594. return -1;
  595.     }
  596.     
  597.     if (prefs_get_discisloss()==1 || game->option==game_option_ladder_countasloss)
  598. discisloss = 1;
  599.     else
  600. discisloss = 0;
  602.     if (strcmp(game->clienttag,CLIENTTAG_WARCRAFT3)==0 || strcmp(game->clienttag,CLIENTTAG_WAR3XP)==0)
  603.     // war3 game reporting is done elsewhere, so we can skip this function
  604.     return 0;
  605.     
  606.     if (strcmp(game->clienttag,CLIENTTAG_DIABLOSHR)==0 ||
  607.         strcmp(game->clienttag,CLIENTTAG_DIABLORTL)==0 ||
  608.         strcmp(game->clienttag,CLIENTTAG_DIABLO2ST)==0 ||
  609.         strcmp(game->clienttag,CLIENTTAG_DIABLO2DV)==0 ||
  610.         strcmp(game->clienttag,CLIENTTAG_DIABLO2XP)==0)
  611.     {
  612.       if (prefs_get_report_diablo_games() == 1)
  613. /* diablo games have transient players and no reported winners/losers */
  614. realcount = 0;
  615.       else
  616.       {
  617. eventlog(eventlog_level_info,"game_report","diablo gamereport disabled: ignoring game");
  618. return 0;
  619.       }
  620.     }
  621.     else
  622.     {
  623. /* "compact" the game; move all the real players to the top... */
  624. realcount = 0;
  625. for (i=0; i<game->count; i++)
  626. {
  627.     if (!game->players[i])
  628.     {
  629. eventlog(eventlog_level_error,"game_report","player slot %u has NULL account",i);
  630. continue;
  631.     }
  632.     
  633.     if (game->results[i]!=game_result_none)
  634.     {
  635. game->players[realcount]       = game->players[i];
  636. game->results[realcount]       = game->results[i];
  637. game->report_heads[realcount]  = game->report_heads[i];
  638. game->report_bodies[realcount] = game->report_bodies[i];
  639. realcount++;
  640.     }
  641. }
  643. /* then nuke duplicate players after the real players */
  644. for (i=realcount; i<game->count; i++)
  645. {
  646.     game->players[i]       = NULL;
  647.     game->results[i]       = game_result_none;
  648.     game->report_heads[i]  = NULL;
  649.     game->report_bodies[i] = NULL;
  650. }
  652. if (realcount<1)
  653. {
  654.     eventlog(eventlog_level_info,"game_report","ignoring game");
  655.     return -1;
  656. }
  657.     }
  658.     
  659.     eventlog(eventlog_level_debug,"game_report","realcount=%d count=%u",realcount,game->count);
  660.     
  661.     if (realcount>=1 && !game->bad)
  662.     {
  663. if (game_get_type(game)==game_type_ladder ||
  664.     game_get_type(game)==game_type_ironman)
  665. {
  666.     t_ladder_id id;
  667.     
  668.     if (game_get_type(game)==game_type_ladder)
  669. id = ladder_id_normal;
  670.     else
  671. id = ladder_id_ironman;
  672.     
  673.     for (i=0; i<realcount; i++)
  674.     {
  675. eventlog(eventlog_level_debug,"game_report","realplayer %u result=%u",i+1,(unsigned int)game->results[i]);
  677. ladder_init_account(game->players[i],game->clienttag,id);
  679. switch (game->results[i])
  680. {
  681. case game_result_win:
  682.     account_inc_ladder_wins(game->players[i],game->clienttag,id);
  683.     account_set_ladder_last_result(game->players[i],game->clienttag,id,game_result_get_str(game_result_win));
  684.     break;
  685. case game_result_loss:
  686.     account_inc_ladder_losses(game->players[i],game->clienttag,id);
  687.     account_set_ladder_last_result(game->players[i],game->clienttag,id,game_result_get_str(game_result_loss));
  688.     break;
  689. case game_result_draw:
  690.     account_inc_ladder_draws(game->players[i],game->clienttag,id);
  691.     account_set_ladder_last_result(game->players[i],game->clienttag,id,game_result_get_str(game_result_draw));
  692.     break;
  693. case game_result_disconnect:
  694.     if (discisloss)
  695.     {
  696. account_inc_ladder_losses(game->players[i],game->clienttag,id);
  697. account_set_ladder_last_result(game->players[i],game->clienttag,id,game_result_get_str(game_result_loss));
  698.     }
  699.     else
  700.     {
  701. /* FIXME: do the first disconnect only stuff like below */
  702. account_inc_ladder_disconnects(game->players[i],game->clienttag,id);
  703. account_set_ladder_last_result(game->players[i],game->clienttag,id,game_result_get_str(game_result_disconnect));
  704.     }
  705.     break;
  706. default:
  707.     eventlog(eventlog_level_error,"game_report","bad ladder game realplayer results[%u] = %u",i,game->results[i]);
  708.     account_inc_ladder_disconnects(game->players[i],game->clienttag,id);
  709.     account_set_ladder_last_result(game->players[i],game->clienttag,id,game_result_get_str(game_result_disconnect));
  710. }
  711. account_set_ladder_last_time(game->players[i],game->clienttag,id,bnettime());
  712.     }
  713.     
  714.     if (!(ladder_info = malloc(sizeof(t_ladder_info)*realcount)))
  715. eventlog(eventlog_level_error,"game_report","unable to allocate memory for ladder_info, ladder ratings will not be updated");
  716.     else
  717. if (ladder_update(game->clienttag,id,
  718.     realcount,game->players,game->results,ladder_info,
  719.     discisloss?ladder_option_disconnectisloss:ladder_option_none)<0)
  720. {
  721.     eventlog(eventlog_level_error,"game_report","unable to update ladder stats");
  722.     free(ladder_info);
  723.     ladder_info = NULL;
  724. }
  725. }
  726. else
  727. {
  728.     int disc_set=0;
  729.     
  730.     for (i=0; i<realcount; i++)
  731.     {
  732. switch (game->results[i])
  733. {
  734. case game_result_win:
  735.     account_inc_normal_wins(game->players[i],game->clienttag);
  736.     account_set_normal_last_result(game->players[i],game->clienttag,game_result_get_str(game_result_win));
  737.     break;
  738. case game_result_loss:
  739.     account_inc_normal_losses(game->players[i],game->clienttag);
  740.     account_set_normal_last_result(game->players[i],game->clienttag,game_result_get_str(game_result_loss));
  741.     break;
  742. case game_result_draw:
  743.     account_inc_normal_draws(game->players[i],game->clienttag);
  744.     account_set_normal_last_result(game->players[i],game->clienttag,game_result_get_str(game_result_draw));
  745.     break;
  746. case game_result_disconnect:
  747.     if (discisloss)
  748.     {
  749. account_inc_normal_losses(game->players[i],game->clienttag);
  750. account_set_normal_last_result(game->players[i],game->clienttag,game_result_get_str(game_result_loss));
  751.     }
  752.     else
  753.     {
  754. /* FIXME: Is the missing player always the first one in this array?  It seems like it should be
  755.    the person that created the game */
  756. if (!disc_set)
  757. {
  758.     account_inc_normal_disconnects(game->players[i],game->clienttag);
  759.     disc_set = 1;
  760. }
  761. account_set_normal_last_result(game->players[i],game->clienttag,game_result_get_str(game_result_disconnect));
  762.     }
  763.     break;
  764. default:
  765.     eventlog(eventlog_level_error,"game_report","bad normal game realplayer results[%u] = %u",i,game->results[i]);
  766. /* FIXME: Jung-woo fixed this here but we should find out what value results[i] has...
  767.    and why "discisloss" isn't set above in game_result_disconnect */
  768. #if 0
  769.     /* commented out for loose disconnect policy */
  770.     /* account_inc_normal_disconnects(game->players[i],game->clienttag); */
  771. #endif
  772.     account_inc_normal_disconnects(game->players[i],game->clienttag);
  773.     account_set_normal_last_result(game->players[i],game->clienttag,game_result_get_str(game_result_disconnect));
  774. }
  775. account_set_normal_last_time(game->players[i],game->clienttag,bnettime());
  776.     }
  777. }
  778.     }
  779.     
  780.     if (game_get_type(game)!=game_type_ladder && prefs_get_report_all_games()!=1)
  781.     {
  782. eventlog(eventlog_level_debug,"game_report","not reporting normal games");
  783. return 0;
  784.     }
  785.     
  786.     {
  787. struct tm * tmval;
  788. char        dstr[64];
  790. if (!(tmval = localtime(&now)))
  791.     dstr[0] = '';
  792. else
  793.     sprintf(dstr,"%04d%02d%02d%02d%02d%02d",
  794.     1900+tmval->tm_year,
  795.     tmval->tm_mon+1,
  796.     tmval->tm_mday,
  797.     tmval->tm_hour,
  798.     tmval->tm_min,
  799.     tmval->tm_sec);
  801. if (!(tempname = malloc(strlen(prefs_get_reportdir())+1+1+5+1+2+1+strlen(dstr)+1+6+1)))
  802. {
  803.     eventlog(eventlog_level_error,"game_report","could not allocate memory for tempname");
  804.     if (ladder_info)
  805. free(ladder_info);
  806.     return -1;
  807. }
  808. sprintf(tempname,"%s/_bnetd-gr_%s_%06u",prefs_get_reportdir(),dstr,game->id);
  809. if (!(realname = malloc(strlen(prefs_get_reportdir())+1+2+1+strlen(dstr)+1+6+1)))
  810. {
  811.     eventlog(eventlog_level_error,"game_report","could not allocate memory for realname");
  812.     free(tempname);
  813.     if (ladder_info)
  814. free(ladder_info);
  815.     return -1;
  816. }
  817. sprintf(realname,"%s/gr_%s_%06u",prefs_get_reportdir(),dstr,game->id);
  818.     }
  819.     
  820.     if (!(fp = fopen(tempname,"w")))
  821.     {
  822. eventlog(eventlog_level_error,"game_report","could not open report file "%s" for writing (fopen: %s)",tempname,strerror(errno));
  823. if (ladder_info)
  824.     free(ladder_info);
  825. free(realname);
  826. free(tempname);
  827. return -1;
  828.     }
  829.     
  830.     if (game->bad)
  831. fprintf(fp,"[ game results ignored due to inconsistencies ]nn");
  832.     fprintf(fp,"name="%s" id="GAMEID_FORMAT"n",
  833.     game->name,
  834.     game->id);
  835.     fprintf(fp,"clienttag=%4s type="%s" option="%s"n",
  836.     game->clienttag,
  837.     game_type_get_str(game->type),
  838.     game_option_get_str(game->option));
  839.     {
  840. struct tm * gametime;
  841. char        timetemp[GAME_TIME_MAXLEN];
  843. if (!(gametime = localtime(&game->create_time)))
  844.     strcpy(timetemp,"?");
  845. else
  846.     strftime(timetemp,sizeof(timetemp),GAME_TIME_FORMAT,gametime);
  847. fprintf(fp,"created="%s" ",timetemp);
  849. if (!(gametime = localtime(&game->start_time)))
  850.     strcpy(timetemp,"?");
  851. else
  852.     strftime(timetemp,sizeof(timetemp),GAME_TIME_FORMAT,gametime);
  853. fprintf(fp,"started="%s" ",timetemp);
  855. if (!(gametime = localtime(&now)))
  856.     strcpy(timetemp,"?");
  857. else
  858.     strftime(timetemp,sizeof(timetemp),GAME_TIME_FORMAT,gametime);
  859. fprintf(fp,"ended="%s"n",timetemp);
  860.     }
  861.     {
  862. char const * mapname;
  864. if (!(mapname = game_get_mapname(game)))
  865.     mapname = "?";
  867. fprintf(fp,"mapfile="%s" mapauth="%s" mapsize=%ux%u tileset="%s"n",
  868. mapname,
  869. game_maptype_get_str(game_get_maptype(game)),
  870. game_get_mapsize_x(game),game_get_mapsize_y(game),
  871. game_tileset_get_str(game_get_tileset(game)));
  872.     }
  873.     fprintf(fp,"joins=%u maxplayers=%un",
  874.     game_get_count(game),
  875.     game_get_maxplayers(game));
  876.     
  877.     if (!prefs_get_hide_addr())
  878. fprintf(fp,"host=%sn",addr_num_to_addr_str(game_get_addr(game),game_get_port(game)));
  879.     
  880.     fprintf(fp,"nn");
  881.     
  882.     if (strcmp(game->clienttag,CLIENTTAG_DIABLORTL)==0)
  883. for (i=0; i<game->count; i++)
  884. {
  885.     tname = account_get_name(game->players[i]);
  886.     fprintf(fp,"%-16s JOINEDn",tname);
  887.     account_unget_name(tname);
  888. }
  889.     else
  890. if (ladder_info)
  891.     for (i=0; i<realcount; i++)
  892.     {
  893. tname = account_get_name(game->players[i]);
  894. fprintf(fp,"%-16s %-8s rating=%u [#%05u]  prob=%4.1f%%  K=%2u  adj=%+dn",
  895. tname,
  896. game_result_get_str(game->results[i]),
  897. ladder_info[i].oldrating,
  898. ladder_info[i].oldrank,
  899. ladder_info[i].prob*100.0,
  900. ladder_info[i].k,
  901. ladder_info[i].adj);
  902. account_unget_name(tname);
  903.     }
  904. else
  905.     for (i=0; i<realcount; i++)
  906.     {
  907. tname = account_get_name(game->players[i]);
  908. fprintf(fp,"%-16s %-8sn",
  909. tname,
  910. game_result_get_str(game->results[i]));
  911. account_unget_name(tname);
  912.     }
  913.     fprintf(fp,"nn");
  914.     
  915.     if (ladder_info)
  916. free(ladder_info);
  917.     
  918.     for (i=0; i<realcount; i++)
  919.     {
  920. if (game->report_heads[i])
  921.     fprintf(fp,"%sn",game->report_heads[i]);
  922. else
  923. {
  924.     tname = account_get_name(game->players[i]);
  925.     fprintf(fp,"[ game report header not available for player %u ("%s") ]n",i+1,tname);
  926.     account_unget_name(tname);
  927. }
  928. if (game->report_bodies[i])
  929.     fprintf(fp,"%sn",game->report_bodies[i]);
  930. else
  931. {
  932.     tname = account_get_name(game->players[i]);
  933.     fprintf(fp,"[ game report body not available for player %u ("%s") ]nn",i+1,tname);
  934.     account_unget_name(tname);
  935. }
  936.     }
  937.     fprintf(fp,"nn");
  938.     
  939.     if (strcmp(game->clienttag,CLIENTTAG_STARCRAFT)==0 ||
  940. strcmp(game->clienttag,CLIENTTAG_SHAREWARE)==0 ||
  941.         strcmp(game->clienttag,CLIENTTAG_BROODWARS)==0 ||
  942.         strcmp(game->clienttag,CLIENTTAG_WARCIIBNE)==0)
  943.     {
  944. for (i=0; i<realcount; i++)
  945. {
  946.     tname = account_get_name(game->players[i]);
  947.     fprintf(fp,"%s's normal record is now %u/%u/%u (%u draws)n",
  948.     tname,
  949.     account_get_normal_wins(game->players[i],game->clienttag),
  950.     account_get_normal_losses(game->players[i],game->clienttag),
  951.     account_get_normal_disconnects(game->players[i],game->clienttag),
  952.     account_get_normal_draws(game->players[i],game->clienttag));
  953.     account_unget_name(tname);
  954. }
  955.     }
  956.     if (strcmp(game->clienttag,CLIENTTAG_STARCRAFT)==0 ||
  957.         strcmp(game->clienttag,CLIENTTAG_BROODWARS)==0 ||
  958.         strcmp(game->clienttag,CLIENTTAG_WARCIIBNE)==0)
  959.     {
  960. fprintf(fp,"n");
  961. for (i=0; i<realcount; i++)
  962. {
  963.     tname = account_get_name(game->players[i]);
  964.     fprintf(fp,"%s's standard ladder record is now %u/%u/%u (rating %u [#%05u]) (%u draws)n",
  965.     tname,
  966.     account_get_ladder_wins(game->players[i],game->clienttag,ladder_id_normal),
  967.     account_get_ladder_losses(game->players[i],game->clienttag,ladder_id_normal),
  968.     account_get_ladder_disconnects(game->players[i],game->clienttag,ladder_id_normal),
  969.     account_get_ladder_rating(game->players[i],game->clienttag,ladder_id_normal),
  970.     account_get_ladder_rank(game->players[i],game->clienttag,ladder_id_normal),
  971.     account_get_ladder_draws(game->players[i],game->clienttag,ladder_id_normal));
  972.     account_unget_name(tname);
  973. }
  974.     }
  975.     if (strcmp(game->clienttag,CLIENTTAG_WARCIIBNE)==0)
  976.     {
  977. fprintf(fp,"n");
  978. for (i=0; i<realcount; i++)
  979. {
  980.     tname = account_get_name(game->players[i]);
  981.     fprintf(fp,"%s's ironman ladder record is now %u/%u/%u (rating %u [#%05u]) (%u draws)n",
  982.     tname,
  983.     account_get_ladder_wins(game->players[i],game->clienttag,ladder_id_ironman),
  984.     account_get_ladder_losses(game->players[i],game->clienttag,ladder_id_ironman),
  985.     account_get_ladder_disconnects(game->players[i],game->clienttag,ladder_id_ironman),
  986.     account_get_ladder_rating(game->players[i],game->clienttag,ladder_id_ironman),
  987.     account_get_ladder_rank(game->players[i],game->clienttag,ladder_id_ironman),
  988.     account_get_ladder_draws(game->players[i],game->clienttag,ladder_id_ironman));
  989.     account_unget_name(tname);
  990. }
  991.     }
  992.     
  993.     fprintf(fp,"nThis game lasted %lu minutes (elapsed).n",((unsigned long int)difftime(now,game->start_time))/60);
  994.     
  995.     if (fclose(fp)<0)
  996.     {
  997. eventlog(eventlog_level_error,"game_report","could not close report file "%s" after writing (fclose: %s)",tempname,strerror(errno));
  998. free(realname);
  999. free(tempname);
  1000. return -1;
  1001.     }
  1002.     
  1003.     if (rename(tempname,realname)<0)
  1004.     {
  1005. eventlog(eventlog_level_error,"game_report","could not rename report file to "%s" (rename: %s)",realname,strerror(errno));
  1006. free(realname);
  1007. free(tempname);
  1008. return -1;
  1009.     }
  1010.     
  1011.     eventlog(eventlog_level_debug,"game_report","game report saved as "%s"",realname);
  1012.     free(realname);
  1013.     free(tempname);
  1014.     return 0;
  1015. }
  1018. extern unsigned int game_get_id(t_game const * game)
  1019. {
  1020.     if (!game)
  1021.     {
  1022. eventlog(eventlog_level_error,"game_get_id","got NULL game");
  1023.         return 0;
  1024.     }
  1025.     return game->id;
  1026. }
  1029. extern char const * game_get_name(t_game const * game)
  1030. {
  1031.     if (!game)
  1032.     {
  1033. eventlog(eventlog_level_error,"game_get_name","got NULL game");
  1034.         return NULL;
  1035.     }
  1036.     return game->name;
  1037. }
  1040. extern t_game_type game_get_type(t_game const * game)
  1041. {
  1042.     if (!game)
  1043.     {
  1044. eventlog(eventlog_level_error,"game_get_type","got NULL game");
  1045.         return 0;
  1046.     }
  1047.     return game->type;
  1048. }
  1051. extern t_game_maptype game_get_maptype(t_game const * game)
  1052. {
  1053.     if (!game)
  1054.     {
  1055. eventlog(eventlog_level_error,"game_get_maptype","got NULL game");
  1056.         return game_maptype_none;
  1057.     }
  1058.     return game->maptype;
  1059. }
  1062. extern int game_set_maptype(t_game * game, t_game_maptype maptype)
  1063. {
  1064.     if (!game)
  1065.     {
  1066. eventlog(eventlog_level_error,"game_set_maptype","got NULL game");
  1067.         return -1;
  1068.     }
  1069.     game->maptype = maptype;
  1070.     return 0;
  1071. }
  1074. extern t_game_tileset game_get_tileset(t_game const * game)
  1075. {
  1076.     if (!game)
  1077.     {
  1078. eventlog(eventlog_level_error,"game_get_tileset","got NULL game");
  1079.         return game_tileset_none;
  1080.     }
  1081.     return game->tileset;
  1082. }
  1085. extern int game_set_tileset(t_game * game, t_game_tileset tileset)
  1086. {
  1087.     if (!game)
  1088.     {
  1089. eventlog(eventlog_level_error,"game_set_tileset","got NULL game");
  1090.         return -1;
  1091.     }
  1092.     game->tileset = tileset;
  1093.     return 0;
  1094. }
  1097. extern t_game_speed game_get_speed(t_game const * game)
  1098. {
  1099.     if (!game)
  1100.     {
  1101. eventlog(eventlog_level_error,"game_get_speed","got NULL game");
  1102.         return game_speed_none;
  1103.     }
  1104.     return game->speed;
  1105. }
  1108. extern int game_set_speed(t_game * game, t_game_speed speed)
  1109. {
  1110.     if (!game)
  1111.     {
  1112. eventlog(eventlog_level_error,"game_set_speed","got NULL game");
  1113.         return -1;
  1114.     }
  1115.     game->speed = speed;
  1116.     return 0;
  1117. }
  1120. extern unsigned int game_get_mapsize_x(t_game const * game)
  1121. {
  1122.     if (!game)
  1123.     {
  1124. eventlog(eventlog_level_error,"game_get_mapsize_x","got NULL game");
  1125.         return 0;
  1126.     }
  1127.     return game->mapsize_x;
  1128. }
  1131. extern int game_set_mapsize_x(t_game * game, unsigned int x)
  1132. {
  1133.     if (!game)
  1134.     {
  1135. eventlog(eventlog_level_error,"game_set_mapsize_x","got NULL game");
  1136.         return -1;
  1137.     }
  1138.     game->mapsize_x = x;
  1139.     return 0;
  1140. }
  1143. extern unsigned int game_get_mapsize_y(t_game const * game)
  1144. {
  1145.     if (!game)
  1146.     {
  1147. eventlog(eventlog_level_error,"game_get_mapsize_y","got NULL game");
  1148.         return 0;
  1149.     }
  1150.     return game->mapsize_y;
  1151. }
  1154. extern int game_set_mapsize_y(t_game * game, unsigned int y)
  1155. {
  1156.     if (!game)
  1157.     {
  1158. eventlog(eventlog_level_error,"game_set_mapsize_y","got NULL game");
  1159.         return -1;
  1160.     }
  1161.     game->mapsize_y = y;
  1162.     return 0;
  1163. }
  1166. extern unsigned int game_get_maxplayers(t_game const * game)
  1167. {
  1168.     if (!game)
  1169.     {
  1170. eventlog(eventlog_level_error,"game_get_maxplayers","got NULL game");
  1171.         return 0;
  1172.     }
  1173.     return game->maxplayers;
  1174. }
  1177. extern int game_set_maxplayers(t_game * game, unsigned int maxplayers)
  1178. {
  1179.     if (!game)
  1180.     {
  1181. eventlog(eventlog_level_error,"game_set_maxplayers","got NULL game");
  1182.         return -1;
  1183.     }
  1184.     game->maxplayers = maxplayers;
  1185.     return 0;
  1186. }
  1189. extern unsigned int game_get_difficulty(t_game const * game)
  1190. {
  1191.     if (!game)
  1192.     {
  1193. eventlog(eventlog_level_error,"game_get_difficulty","got NULL game");
  1194.         return 0;
  1195.     }
  1196.     return game->difficulty;
  1197. }
  1200. extern int game_set_difficulty(t_game * game, unsigned int difficulty)
  1201. {
  1202.     if (!game)
  1203.     {
  1204. eventlog(eventlog_level_error,"game_set_maxplayers","got NULL game");
  1205.         return -1;
  1206.     }
  1207.     game->difficulty = difficulty;
  1208.     return 0;
  1209. }
  1212. extern char const * game_get_description(t_game const * game)
  1213. {
  1214.     if (!game)
  1215.     {
  1216. eventlog(eventlog_level_error,"game_get_description","got NULL game");
  1217.         return NULL;
  1218.     }
  1219.     return game->description;
  1220. }
  1223. extern int game_set_description(t_game * game, char const * description)
  1224. {
  1225.     if (!game)
  1226.     {
  1227. eventlog(eventlog_level_error,"game_set_description","got NULL game");
  1228.         return -1;
  1229.     }
  1230.     if (!description)
  1231.     {
  1232. eventlog(eventlog_level_error,"game_set_description","got NULL description");
  1233. return -1;
  1234.     }
  1235.     
  1236.     if (game->description != NULL) free((void *)game->description);
  1237.     if (!(game->description = strdup(description)))
  1238.     {
  1239. eventlog(eventlog_level_error,"game_set_description","could not allocate memory for description");
  1240. return -1;
  1241.     }
  1242.     
  1243.     return 0;
  1244. }
  1247. extern char const * game_get_pass(t_game const * game)
  1248. {
  1249.     if (!game)
  1250.     {
  1251. eventlog(eventlog_level_error,"game_get_pass","got NULL game");
  1252.         return NULL;
  1253.     }
  1254.     return game->pass;
  1255. }
  1258. extern char const * game_get_info(t_game const * game)
  1259. {
  1260.     if (!game)
  1261.     {
  1262. eventlog(eventlog_level_error,"game_get_info","got NULL game");
  1263.         return NULL;
  1264.     }
  1265.     return game->info;
  1266. }
  1269. extern int game_get_startver(t_game const * game)
  1270. {
  1271.     if (!game)
  1272.     {
  1273. eventlog(eventlog_level_error,"game_get_startver","got NULL game");
  1274.         return 0;
  1275.     }
  1276.     return game->startver;
  1277. }
  1280. extern unsigned long game_get_version(t_game const * game)
  1281. {
  1282.     if (!game)
  1283.     {
  1284. eventlog(eventlog_level_error,"game_get_version","got NULL game");
  1285.         return 0;
  1286.     }
  1287.     return game->version;
  1288. }
  1291. extern unsigned int game_get_ref(t_game const * game)
  1292. {
  1293.     if (!game)
  1294.     {
  1295. eventlog(eventlog_level_error,"game_get_ref","got NULL game");
  1296.         return 0;
  1297.     }
  1298.     return game->ref;
  1299. }
  1302. extern unsigned int game_get_count(t_game const * game)
  1303. {
  1304.     if (!game)
  1305.     {
  1306. eventlog(eventlog_level_error,"game_get_count","got NULL game");
  1307.         return 0;
  1308.     }
  1309.     return game->count;
  1310. }
  1313. extern void game_set_status(t_game * game, t_game_status status)
  1314. {
  1315. if (!game) {
  1316. eventlog(eventlog_level_error,"game_set_status","got NULL game");
  1317. return;
  1318.     }
  1319. // [quetzal] 20020829 - this should prevent invalid status changes
  1320. // its like started game cant become open and so on
  1321. if (game->status == game_status_started && 
  1322. (status == game_status_open || status == game_status_full)) {
  1323. eventlog(eventlog_level_error, "game_set_status", 
  1324. "attempting to set status '%s' (%d) to started game", game_status_get_str(status), status);
  1325. return;
  1326. }
  1328. if (game->status == game_status_done && status != game_status_done) {
  1329. eventlog(eventlog_level_error, "game_set_status", 
  1330. "attempting to set status '%s' (%d) to done game", game_status_get_str(status), status);
  1331. return;
  1332. }
  1334.     if (status==game_status_started && game->start_time==(time_t)0)
  1335. game->start_time = time(NULL);
  1336.     game->status = status;
  1337. }
  1340. extern t_game_status game_get_status(t_game const * game)
  1341. {
  1342.     if (!game)
  1343.     {
  1344. eventlog(eventlog_level_error,"game_get_status","got NULL game");
  1345.         return 0;
  1346.     }
  1347.     return game->status;
  1348. }
  1351. extern unsigned int game_get_addr(t_game const * game)
  1352. {
  1353.     if (!game)
  1354.     {
  1355. eventlog(eventlog_level_error,"game_get_addr","got NULL game");
  1356.         return 0;
  1357.     }
  1358.     
  1359.     return game->addr; /* host byte order */
  1360. }
  1363. extern unsigned short game_get_port(t_game const * game)
  1364. {
  1365.     if (!game)
  1366.     {
  1367. eventlog(eventlog_level_error,"game_get_port","got NULL game");
  1368.         return 0;
  1369.     }
  1370.     
  1371.     return game->port; /* host byte order */
  1372. }
  1375. extern unsigned int game_get_latency(t_game const * game)
  1376. {
  1377.     if (!game)
  1378.     {
  1379. eventlog(eventlog_level_error,"game_get_latency","got NULL game");
  1380.         return 0;
  1381.     }
  1382.     if (game->ref<1)
  1383.     {
  1384. eventlog(eventlog_level_error,"game_get_latency","game "%s" has no players",game->name);
  1385. return 0;
  1386.     }
  1387.     if (!game->players)
  1388.     {
  1389. eventlog(eventlog_level_error,"game_get_latency","game "%s" has NULL players array (ref=%u)",game->name,game->ref);
  1390. return 0;
  1391.     }
  1392.     if (!game->players[0])
  1393.     {
  1394. eventlog(eventlog_level_error,"game_get_latency","game "%s" has NULL players[0] entry (ref=%u)",game->name,game->ref);
  1395. return 0;
  1396.     }
  1397.     
  1398.     return 0; /* conn_get_latency(game->players[0]); */
  1399. }
  1401. extern t_connection * game_get_player_conn(t_game const * game, unsigned int i)
  1402. {
  1403.   if (!game)
  1404.   {
  1405.     eventlog(eventlog_level_error,"game_get_player_conn","got NULL game");
  1406.     return NULL;
  1407.   }
  1408.   if (game->ref<1)
  1409.   {
  1410.     eventlog(eventlog_level_error,"game_get_player_conn","game "%s" has no players",game->name);
  1411.     return NULL;
  1412.   }
  1413.   if (!game->players)
  1414.   {
  1415.     eventlog(eventlog_level_error,"game_get_player_conn","game "%s" has NULL player array (ref=%u)",game->name,game->ref);
  1416.     return NULL;
  1417.   }
  1418.   if (!game->players[i])
  1419.   {
  1420.     eventlog(eventlog_level_error,"game_get_player_conn","game "%s" has NULL players[i] entry (ref=%u)",game->name,game->ref);
  1421.     return NULL;
  1422.   }
  1423.   return game->connections[i];
  1424. }
  1426. extern char const * game_get_clienttag(t_game const * game)
  1427. {
  1428.     if (!game)
  1429.     {
  1430. eventlog(eventlog_level_error,"game_get_clienttag","got NULL game");
  1431.         return NULL;
  1432.     }
  1433.     return game->clienttag;
  1434. }
  1437. extern int game_add_player(t_game * game, char const * pass, int startver, t_connection * c)
  1438. {
  1439.     t_connection * * tempc;
  1440.     t_account * *    tempp;
  1441.     t_game_result *  tempr;
  1442.     char const * *   temprh;
  1443.     char const * *   temprb;
  1444.     
  1445.     if (!game)
  1446.     {
  1447. eventlog(eventlog_level_error,"game_add_player","got NULL game");
  1448.         return -1;
  1449.     }
  1450.     if (!pass)
  1451.     {
  1452. eventlog(eventlog_level_error,"game_add_player","got NULL password");
  1453. return -1;
  1454.     }
  1455.     if (startver!=STARTVER_UNKNOWN && startver!=STARTVER_GW1 && startver!=STARTVER_GW3 && startver!=STARTVER_GW4 && startver!=STARTVER_REALM1)
  1456.     {
  1457. eventlog(eventlog_level_error,"game_add_player","got bad game startver %d",startver);
  1458. return -1;
  1459.     }
  1460.     if (!c)
  1461.     {
  1462. eventlog(eventlog_level_error,"game_add_player","got NULL connection");
  1463.         return -1;
  1464.     }
  1465.     if (game->type==game_type_ladder && account_get_normal_wins(conn_get_account(c),conn_get_clienttag(c))<10)
  1466.     /* if () ... */
  1467.     {
  1468. eventlog(eventlog_level_error,"game_add_player","can not join ladder game without 10 normal wins");
  1469. return -1;
  1470.     }
  1471.     
  1472.     {
  1473. char const * gt;
  1475. if (!(gt = game_get_clienttag(game)))
  1476. {
  1477.     eventlog(eventlog_level_error,"game_add_player","could not get clienttag for game");
  1478.     return -1;
  1479. }
  1480. /* FIXME: What's wrong with this?  *** I dunno, when does it print this message? */
  1481. /*
  1482. if (strcmp(conn_get_clienttag(c),gt)!=0)
  1483. {
  1484.     eventlog(eventlog_level_error,"game_add_player","player clienttag ("%s") does not match game clienttag ("%s")",conn_get_clienttag(c),gt);
  1485.     return -1;
  1486. }
  1487. */
  1488.     }
  1489.     
  1490.     if (game->pass[0]!='' && strcasecmp(game->pass,pass)!=0)
  1491.     {
  1492.         eventlog(eventlog_level_debug,"game_add_player","game "%s" password mismatch "%s"!="%s"",game->name,game->pass,pass); 
  1493. return -1;
  1494.     }
  1496.     if (!game->connections) /* some realloc()s are broken */
  1497.     {
  1498. if (!(tempc = malloc((game->count+1)*sizeof(t_connection *))))
  1499. {
  1500.     eventlog(eventlog_level_error,"game_add_player","unable to allocate memory for game connections");
  1501.     return -1;
  1502. }
  1503.     }
  1504.     else
  1505.     {
  1506. if (!(tempc = realloc(game->connections,(game->count+1)*sizeof(t_connection *))))
  1507. {
  1508.     eventlog(eventlog_level_error,"game_add_player","unable to allocate memory for game connections");
  1509.     return -1;
  1510. }
  1511.     }
  1512.     game->connections = tempc;
  1513.     if (!game->players) /* some realloc()s are broken */
  1514.     {
  1515. if (!(tempp = malloc((game->count+1)*sizeof(t_account *))))
  1516. {
  1517.     eventlog(eventlog_level_error,"game_add_player","unable to allocate memory for game players");
  1518.     return -1;
  1519. }
  1520.     }
  1521.     else
  1522.     {
  1523. if (!(tempp = realloc(game->players,(game->count+1)*sizeof(t_account *))))
  1524. {
  1525.     eventlog(eventlog_level_error,"game_add_player","unable to allocate memory for game players");
  1526.     return -1;
  1527. }
  1528.     }
  1529.     game->players = tempp;
  1530.     
  1531.     if (!game->results) /* some realloc()s are broken */
  1532.     {
  1533. if (!(tempr = malloc((game->count+1)*sizeof(t_game_result))))
  1534. {
  1535.     eventlog(eventlog_level_error,"game_add_player","unable to allocate memory for game results");
  1536.     return -1;
  1537. }
  1538.     }
  1539.     else
  1540.     {
  1541. if (!(tempr = realloc(game->results,(game->count+1)*sizeof(t_game_result))))
  1542. {
  1543.     eventlog(eventlog_level_error,"game_add_player","unable to allocate memory for game results");
  1544.     return -1;
  1545. }
  1546.     }
  1547.     game->results = tempr;
  1548.     
  1549.     if (!game->report_heads) /* some realloc()s are broken */
  1550.     {
  1551. if (!(temprh = malloc((game->count+1)*sizeof(char const *))))
  1552. {
  1553.     eventlog(eventlog_level_error,"game_add_player","unable to allocate memory for game report headers");
  1554.     return -1;
  1555. }
  1556.     }
  1557.     else
  1558.     {
  1559. if (!(temprh = realloc((void *)game->report_heads,(game->count+1)*sizeof(char const *)))) /* avoid compiler warning */
  1560. {
  1561.     eventlog(eventlog_level_error,"game_add_player","unable to allocate memory for game report headers");
  1562.     return -1;
  1563. }
  1564.     }
  1565.     game->report_heads = temprh;
  1566.     
  1567.     if (!game->report_bodies) /* some realloc()s are broken */
  1568.     {
  1569. if (!(temprb = malloc((game->count+1)*sizeof(char const *))))
  1570. {
  1571.     eventlog(eventlog_level_error,"game_add_player","unable to allocate memory for game report bodies");
  1572.     return -1;
  1573. }
  1574.     }
  1575.     else
  1576.     {
  1577. if (!(temprb = realloc((void *)game->report_bodies,(game->count+1)*sizeof(char const *)))) /* avoid compiler warning */
  1578. {
  1579.     eventlog(eventlog_level_error,"game_add_player","unable to allocate memory for game report bodies");
  1580.     return -1;
  1581. }
  1582.     }
  1583.     game->report_bodies = temprb;
  1584.     
  1585.     game->connections[game->count]   = c;
  1586.     game->players[game->count]       = conn_get_account(c);
  1587.     game->results[game->count]       = game_result_none;
  1588.     game->report_heads[game->count]  = NULL;
  1589.     game->report_bodies[game->count] = NULL;
  1590.     
  1591.     game->count++;
  1592.     game->ref++;
  1593.     game->lastaccess_time = time(NULL);
  1594.     
  1595.     if (game->startver!=startver && startver!=STARTVER_UNKNOWN) /* with join startver ALWAYS unknown [KWS] */
  1596.     {
  1597. char const * tname;
  1599. eventlog(eventlog_level_error,"game_add_player","player "%s" client "%s" startver %u joining game startver %u (count=%u ref=%u)",(tname = account_get_name(conn_get_account(c))),conn_get_clienttag(c),startver,game->startver,game->count,game->ref);
  1600. account_unget_name(tname);
  1601.     }
  1602.     
  1603.     game_choose_host(game);
  1604.     
  1605.     return 0;
  1606. }
  1608. extern int game_del_player(t_game * game, t_connection * c)
  1609. {
  1610.     char const * tname;
  1611.     unsigned int i;
  1612.     t_account *  account;
  1613.     
  1614.     if (!game)
  1615.     {
  1616. eventlog(eventlog_level_error,"game_del_player","got NULL game");
  1617.         return -1;
  1618.     }
  1619.     if (!c)
  1620.     {
  1621. eventlog(eventlog_level_error,"game_del_player","got NULL connection");
  1622. return -1;
  1623.     }
  1624.     if (!game->players)
  1625.     {
  1626. eventlog(eventlog_level_error,"game_del_player","player array is NULL");
  1627. return -1;
  1628.     }
  1629.     if (!game->results)
  1630.     {
  1631. eventlog(eventlog_level_error,"game_del_player","results array is NULL");
  1632. return -1;
  1633.     }
  1634.     
  1635.     account = conn_get_account(c);
  1637.    if(conn_get_leavegamewhisper_ack(c)==0)
  1638.      {
  1639.        watchlist_notify_event(conn_get_account(c),NULL,conn_get_clienttag(c),watch_event_leavegame);
  1640.        conn_set_leavegamewhisper_ack(c,1); //1 = already whispered. We reset this each time user joins a channel
  1641.      }
  1642.     
  1643.     eventlog(eventlog_level_debug,"game_del_player","game "%s" has ref=%u, count=%u; trying to remove player "%s"",game_get_name(game),game->ref,game->count,(tname = account_get_name(account)));
  1644.     account_unget_name(tname);
  1645.     
  1646.     for (i=0; i<game->count; i++)
  1647. if (game->players[i]==account && game->connections[i])
  1648. {
  1649.     eventlog(eventlog_level_debug,"game_del_player","removing player #%u "%s" from "%s", %u players left",i,(tname = account_get_name(account)),game_get_name(game),game->ref-1);
  1650.     game->connections[i] = NULL;
  1651.     if (game->results[i]!=game_result_win &&
  1652. game->results[i]!=game_result_loss &&
  1653. game->results[i]!=game_result_draw &&
  1654. game->results[i]!=game_result_disconnect &&
  1655. game->results[i]!=game_result_observer &&
  1656.         game->results[i]!=game_result_none)
  1657. eventlog(eventlog_level_error,"game_del_player","player "%s" leaving with bad result %u",tname,game->results[i]);
  1658.     account_unget_name(tname);
  1659.     
  1660.     eventlog(eventlog_level_debug,"game_del_player","player deleted... (ref=%u)",game->ref);
  1661.     
  1662.     if (game->ref<2)
  1663.     {
  1664.         eventlog(eventlog_level_debug,"game_del_player","no more players, reporting game");
  1665. game_report(game);
  1666.         eventlog(eventlog_level_debug,"game_del_player","no more players, destroying game");
  1667. game_destroy(game);
  1668. list_purge(gamelist_head);
  1669.         return 0;
  1670.     }
  1671.     
  1672.     game->ref--;
  1673.             game->lastaccess_time = time(NULL);
  1674.     
  1675.     game_choose_host(game);
  1676.     
  1677.     return 0;
  1678. }
  1679.     
  1680.     eventlog(eventlog_level_error,"game_del_player","player "%s" was not in the game",(tname = account_get_name(account)));
  1681.     account_unget_name(tname);
  1682.     return -1;
  1683. }
  1686. extern int game_check_result(t_game * game, t_account * account, t_game_result result)
  1687. {
  1688.     unsigned int pos;
  1689.     char const * tname;
  1690.     
  1691.     if (!game)
  1692.     {
  1693. eventlog(eventlog_level_error,"game_check_result","got NULL game");
  1694. return -1;
  1695.     }
  1696.     if (!account)
  1697.     {
  1698. eventlog(eventlog_level_error,"game_check_result","got NULL account");
  1699. return -1;
  1700.     }
  1701.     if (!game->players)
  1702.     {
  1703. eventlog(eventlog_level_error,"game_check_result","player array is NULL");
  1704. return -1;
  1705.     }
  1706.     if (!game->results)
  1707.     {
  1708. eventlog(eventlog_level_error,"game_check_result","results array is NULL");
  1709. return -1;
  1710.     }
  1711.     if (result!=game_result_win &&
  1712. result!=game_result_loss &&
  1713. result!=game_result_draw &&
  1714. result!=game_result_disconnect &&
  1715. result!=game_result_observer &&
  1716. result!=game_result_playing)
  1717.     {
  1718. eventlog(eventlog_level_error,"game_check_result","got bad result %u for player "%s"",(unsigned int)result,(tname = account_get_name(account)));
  1719. account_unget_name(tname);
  1720. return -1;
  1721.     }
  1722.     
  1723.     {
  1724. unsigned int i;
  1726. pos = game->count;
  1727. for (i=0; i<game->count; i++)
  1728.     if (game->players[i]==account)
  1729. pos = i;
  1730.     }
  1731.     if (pos==game->count)
  1732.     {
  1733. eventlog(eventlog_level_error,"game_check_result","could not find player "%s" to check result",(tname = account_get_name(account)));
  1734. account_unget_name(tname);
  1735. game->bad = 1;
  1736. return 0; /* return success even though it didn't check */
  1737.     }
  1738.     
  1739.     if (game->results[pos]==result)
  1740.     {
  1741. eventlog(eventlog_level_debug,"game_check_result","result %u agrees with previous for player in slot %u",(unsigned int)result,pos);
  1742. return 0;
  1743.     }
  1744.     if (game->results[pos]==game_result_none ||
  1745. game->results[pos]==game_result_playing)
  1746.     {
  1747. if (result==game_result_playing)
  1748.     eventlog(eventlog_level_debug,"game_check_result","player in slot %u reported as "still playing", assuming that is right",pos);
  1749. game->results[pos] = result;
  1750. eventlog(eventlog_level_debug,"game_check_result","result %u initially obtained for player in slot %u",(unsigned int)result,pos);
  1751. return 0;
  1752.     }
  1753.     
  1754.     eventlog(eventlog_level_error,"game_check_result","got inconsistent results for player in slot %u ("%s") previous=%u current=%u",pos,(tname = account_get_name(account)),(unsigned int)game->results[pos],(unsigned int)result);
  1755.     account_unget_name(tname);
  1756.     game->bad = 1;
  1757.     return 0; /* return success even though it didn't check */
  1758. }
  1761. extern int game_set_result(t_game * game, t_account * account, t_game_result result, char const * rephead, char const * repbody)
  1762. {
  1763.     unsigned int pos;
  1764.     char const * tname;
  1765.     
  1766.     if (!game)
  1767.     {
  1768. eventlog(eventlog_level_error,"game_set_result","got NULL game");
  1769. return -1;
  1770.     }
  1771.     if (!account)
  1772.     {
  1773. eventlog(eventlog_level_error,"game_set_result","got NULL account");
  1774. return -1;
  1775.     }
  1776.     if (!game->players)
  1777.     {
  1778. eventlog(eventlog_level_error,"game_set_result","player array is NULL");
  1779. return -1;
  1780.     }
  1781.     if (!game->results)
  1782.     {
  1783. eventlog(eventlog_level_error,"game_set_result","results array is NULL");
  1784. return -1;
  1785.     }
  1786.     if (!game->report_heads)
  1787.     {
  1788. eventlog(eventlog_level_error,"game_set_result","report_heads array is NULL");
  1789. return -1;
  1790.     }
  1791.     if (!game->report_bodies)
  1792.     {
  1793. eventlog(eventlog_level_error,"game_set_result","report_bodies array is NULL");
  1794. return -1;
  1795.     }
  1796.     if (result!=game_result_win &&
  1797. result!=game_result_loss &&
  1798. result!=game_result_draw &&
  1799. result!=game_result_observer &&
  1800. result!=game_result_disconnect)
  1801.     {
  1802. eventlog(eventlog_level_error,"game_set_result","got bad result %u for player "%s"",(unsigned int)result,(tname = account_get_name(account)));
  1803. account_unget_name(tname);
  1804. return -1;
  1805.     }
  1806.     if (!rephead)
  1807.     {
  1808. eventlog(eventlog_level_error,"game_set_result","report head is NULL");
  1809. return -1;
  1810.     }
  1811.     if (!repbody)
  1812.     {
  1813. eventlog(eventlog_level_error,"game_set_result","report body is NULL");
  1814. return -1;
  1815.     }
  1816.     
  1817.     {
  1818. unsigned int i;
  1820. pos = game->count;
  1821. for (i=0; i<game->count; i++)
  1822.     if (game->players[i]==account)
  1823. pos = i;
  1824.     }
  1825.     if (pos==game->count)
  1826.     {
  1827. eventlog(eventlog_level_error,"game_set_result","could not find player "%s" to set result",(tname = account_get_name(account)));
  1828. account_unget_name(tname);
  1829. return -1;
  1830.     }
  1831.     
  1832.     if (!(game->report_heads[pos] = strdup(rephead)))
  1833.     {
  1834. eventlog(eventlog_level_error,"game_set_result","could not allocate memory for report_heads in slot %u",pos);
  1835. return -1;
  1836.     }
  1837.     if (!(game->report_bodies[pos] = strdup(repbody)))
  1838.     {
  1839. eventlog(eventlog_level_error,"game_set_result","could not allocate memory for report_bodies in slot %u",pos);
  1840. return -1;
  1841.     }
  1843.     if (game_check_result(game,account,result)<0)
  1844.     {
  1845. eventlog(eventlog_level_error,"game_set_result","self-reported result did not check out with previous for player in slot %u",pos);
  1846. return -1;
  1847.     }
  1848.     
  1849.     return 0;
  1850. }
  1853. extern t_game_result game_get_result(t_game * game, t_account * account)
  1854. {
  1855.     unsigned int pos;
  1856.     
  1857.     if (!game)
  1858.     {
  1859. eventlog(eventlog_level_error,"game_get_result","got NULL game");
  1860. return game_result_none;
  1861.     }
  1862.     if (!account)
  1863.     {
  1864. eventlog(eventlog_level_error,"game_get_result","got NULL account");
  1865. return game_result_none;
  1866.     }
  1867.     if (!game->players)
  1868.     {
  1869. eventlog(eventlog_level_error,"game_get_result","player array is NULL");
  1870. return game_result_none;
  1871.     }
  1872.     if (!game->results)
  1873.     {
  1874. eventlog(eventlog_level_error,"game_get_result","results array is NULL");
  1875. return game_result_none;
  1876.     }
  1877.     
  1878.     {
  1879. unsigned int i;
  1881. pos = game->count;
  1882. for (i=0; i<game->count; i++)
  1883.     if (game->players[i]==account)
  1884. pos = i;
  1885.     }
  1886.     if (pos==game->count)
  1887.     {
  1888. char const * tname;
  1890. eventlog(eventlog_level_error,"game_get_result","could not find player "%s" to return result",(tname = account_get_name(account)));
  1891. account_unget_name(tname);
  1893. return game_result_none;
  1894.     }
  1895.     
  1896.     return game->results[pos];
  1897. }
  1900. extern char const * game_get_mapname(t_game const * game)
  1901. {
  1902.     if (!game)
  1903.     {
  1904. eventlog(eventlog_level_error,"game_get_mapname","got NULL game");
  1905. return NULL;
  1906.     }
  1907.     
  1908.     return game->mapname;
  1909. }
  1912. extern int game_set_mapname(t_game * game, char const * mapname)
  1913. {
  1914.     if (!game)
  1915.     {
  1916. eventlog(eventlog_level_error,"game_set_mapname","got NULL game");
  1917. return -1;
  1918.     }
  1919.     if (!mapname)
  1920.     {
  1921. eventlog(eventlog_level_error,"game_set_mapname","got NULL mapname");
  1922. return -1;
  1923.     }
  1924.     
  1925.     if (game->mapname != NULL) free((void *)game->mapname);
  1926.     
  1927.     if (!(game->mapname = strdup(mapname)))
  1928.     {
  1929. eventlog(eventlog_level_error,"game_set_mapname","could not allocate memory for mapname");
  1930. return -1;
  1931.     }
  1932.     
  1933.     return 0;
  1934. }
  1937. extern t_connection * game_get_owner(t_game const * game)
  1938. {
  1939.     if (!game)
  1940.     {
  1941. eventlog(eventlog_level_error,"game_get_owner","got NULL game");
  1942. return NULL;
  1943.     }
  1944.     return game->owner;
  1945. }
  1948. extern time_t game_get_create_time(t_game const * game)
  1949. {
  1950.     if (!game)
  1951.     {
  1952. eventlog(eventlog_level_error,"game_get_create_time","got NULL game");
  1953. return (time_t)0;
  1954.     }
  1955.     
  1956.     return game->create_time;
  1957. }
  1960. extern time_t game_get_start_time(t_game const * game)
  1961. {
  1962.     if (!game)
  1963.     {
  1964. eventlog(eventlog_level_error,"game_get_start_time","got NULL game");
  1965. return (time_t)0;
  1966.     }
  1967.     
  1968.     return game->start_time;
  1969. }
  1972. extern int game_set_option(t_game * game, t_game_option option)
  1973. {
  1974.     if (!game)
  1975.     {
  1976. eventlog(eventlog_level_error,"game_set_option","got NULL game");
  1977. return -1;
  1978.     }
  1979.     
  1980.     game->option = option;
  1981.     return 0;
  1982. }
  1985. extern t_game_option game_get_option(t_game const * game)
  1986. {
  1987.     if (!game)
  1988.     {
  1989. eventlog(eventlog_level_error,"game_get_option","got NULL game");
  1990. return game_option_none;
  1991.     }
  1992.     
  1993.     return game->option;
  1994. }
  1997. extern int gamelist_create(void)
  1998. {
  1999.     if (!(gamelist_head = list_create()))
  2000. return -1;
  2001.     return 0;
  2002. }
  2005. extern int gamelist_destroy(void)
  2006. {
  2007.     /* FIXME: if called with active games, games are not freed */
  2008.     if (gamelist_head)
  2009.     {
  2010. if (list_destroy(gamelist_head)<0)
  2011.     return -1;
  2012. gamelist_head = NULL;
  2013.     }
  2014.     
  2015.     return 0;
  2016. }
  2019. extern int gamelist_get_length(void)
  2020. {
  2021.     return list_get_length(gamelist_head);
  2022. }
  2025. extern t_game * gamelist_find_game(char const * name, t_game_type type)
  2026. {
  2027.     t_elem const * curr;
  2028.     t_game *       game;
  2029.     
  2030.     if (gamelist_head)
  2031. LIST_TRAVERSE_CONST(gamelist_head,curr)
  2032. {
  2033.     game = elem_get_data(curr);
  2034.     if ((type==game_type_all || game->type==type) && strcasecmp(name,game->name)==0)
  2035. return game;
  2036. }
  2037.     
  2038.     return NULL;
  2039. }
  2042. extern t_game * gamelist_find_game_byid(unsigned int id)
  2043. {
  2044.     t_elem const * curr;
  2045.     t_game *       game;
  2046.     
  2047.     if (gamelist_head)
  2048. LIST_TRAVERSE_CONST(gamelist_head,curr)
  2049. {
  2050.     game = elem_get_data(curr);
  2051.     if (game->id==id)
  2052. return game;
  2053. }
  2054.     
  2055.     return NULL;
  2056. }
  2059. extern t_list * gamelist(void)
  2060. {
  2061.     return gamelist_head;
  2062. }
  2065. extern int gamelist_total_games(void)
  2066. {
  2067.     return totalcount;
  2068. }
  2070. extern int game_set_realm(t_game * game, unsigned int realm) 
  2071. { 
  2072.     if (!game)
  2073.     { 
  2074.           eventlog(eventlog_level_error,"game_set_realm","got NULL game"); 
  2075.           return -1; 
  2076.     } 
  2077.     game->realm = realm; 
  2078.     return 0;
  2079. } 
  2080.     
  2081. extern unsigned int game_get_realm(t_game const * game) 
  2082. { 
  2083.     if (!game)
  2084.     { 
  2085.           eventlog(eventlog_level_error,"game_get_realm","got NULL game"); 
  2086.           return 0; 
  2087.     } 
  2088.     return game->realm; 
  2089. } 
  2090.     
  2091. extern int game_set_realmname(t_game * game, char const * realmname) 
  2092. { 
  2093.     char const * temp; 
  2094.     
  2095.     if (!game)
  2096.     { 
  2097.            eventlog(eventlog_level_error,"game_set_realmname","got NULL game"); 
  2098.            return -1; 
  2099.     } 
  2101.     if (realmname)
  2102.       {
  2103. if (!(temp=strdup(realmname)))
  2104.   {
  2105.     eventlog(eventlog_level_error,"game_set_realmname","could not allocate memory for new realmname");
  2106.     return -1;
  2107.   }
  2108.       }
  2109.     else
  2110.       temp=NULL; 
  2112.     if (game->realmname)
  2113.       free((void *)game->realmname); /* avoid warning */
  2114.     game->realmname = temp; 
  2115.     return 0; 
  2116. } 
  2117.     
  2118. extern  char const * game_get_realmname(t_game const * game) 
  2119. { 
  2120.     if (!game)
  2121.     { 
  2122.            eventlog(eventlog_level_error,"game_get_realmname","got NULL game"); 
  2123.            return NULL; 
  2124.     } 
  2125.     return game->realmname; 
  2126. } 
  2129. extern void gamelist_check_voidgame(void) 
  2130. { 
  2131.     t_elem const    * curr; 
  2132.     t_game          * game; 
  2133.     time_t          now; 
  2134.     
  2135.     now = time(NULL); 
  2136.     LIST_TRAVERSE_CONST(gamelist_head, curr) 
  2137.     { 
  2138.      game = elem_get_data(curr); 
  2139.         if (!game)
  2140.             continue; 
  2141.         if (!game->realm)
  2142.             continue;
  2143.         if (game->ref >= 1)
  2144.             continue;
  2145.         if ((now - game->lastaccess_time) > MAX_GAME_EMPTY_TIME)
  2146.             game_destroy(game); 
  2147.     }
  2148. }
  2150. extern void game_set_flag(t_game * game, t_game_flag flag)
  2151. {
  2152.     if (!game)
  2153.     {
  2154. eventlog(eventlog_level_error, __FUNCTION__, "got NULL game");
  2155.         return;
  2156.     }
  2157.     game->flag = flag;
  2158. }
  2161. extern t_game_flag game_get_flag(t_game const * game)
  2162. {
  2163.     if (!game)
  2164.     {
  2165. eventlog(eventlog_level_error, __FUNCTION__, "got NULL game");
  2166.         return 0;
  2167.     }
  2168.     return game->flag;
  2169. }
  2171. extern int game_get_count_by_clienttag(char const * ct)
  2172. {
  2173.    t_game * game;
  2174.    t_elem const * curr;
  2175.    int clienttaggames = 0;
  2176.    
  2177.    if (ct == NULL) {
  2178.       eventlog(eventlog_level_error, __FUNCTION__, "got NULL clienttag");
  2179.       return 0;
  2180.    }
  2182.    /* Get number of games for client tag specific */
  2183.    LIST_TRAVERSE_CONST(gamelist(),curr)
  2184.      {
  2185. game = elem_get_data(curr);
  2186. if(strcmp(game_get_clienttag(game),ct)==0)
  2187.   clienttaggames++;
  2188.      }
  2189.    
  2190.    return clienttaggames;
  2191. }