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

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

MySQL数据库

开发平台：

Visual C++

tournament.c：源码内容
  1. /*
  2.  * This program is free software; you can redistribute it and/or
  3.  * modify it under the terms of the GNU General Public License
  4.  * as published by the Free Software Foundation; either version 2
  5.  * of the License, or (at your option) any later version.
  6.  *
  7.  * This program is distributed in the hope that it will be useful,
  8.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  9.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10.  * GNU General Public License for more details.
  11.  *
  12.  * You should have received a copy of the GNU General Public License
  13.  * along with this program; if not, write to the Free Software
  14.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  15.  */
  16. #include "common/setup_before.h"
  18. #ifdef HAVE_STRING_H
  19. # include <string.h>
  20. #else
  21. # ifdef HAVE_STRINGS_H
  22. #  include <strings.h>
  23. # endif
  24. #endif
  26. #ifdef TIME_WITH_SYS_TIME
  27. # include <sys/time.h>
  28. # include <time.h>
  29. #else
  30. # if HAVE_SYS_TIME_H
  31. #  include <sys/time.h>
  32. # else
  33. #  include <time.h>
  34. # endif
  35. #endif
  37. #include <errno.h>
  38. #ifdef STDC_HEADERS
  39. # include <stdlib.h>
  40. #else
  41. # ifdef HAVE_MALLOC_H
  42. #  include <malloc.h>
  43. # endif
  44. #endif
  46. #ifdef WIN32_GUI
  47. # include <win32/winmain.h>
  48. #endif
  50. #include "common/eventlog.h"
  51. #include "common/packet.h"
  52. #include "common/tag.h"
  53. #include "common/list.h"
  54. #include "common/util.h"
  55. #include "account.h"
  56. #include "anongame_maplists.h"
  57. #include "tournament.h"
  58. #include "common/setup_after.h"
  60. static t_tournament_info * tournament_info = NULL;
  61. static t_list * tournament_head=NULL;
  63. static int tournamentlist_create(void);
  64. static int gamelist_destroy(void);
  65. static t_tournament_user * tournament_get_user(t_account * account);
  66. //static int tournament_get_in_game_status(t_account * account);
  68. /*****/
  69. static int tournamentlist_create(void)
  70. {
  71.     if (!(tournament_head = list_create()))
  72. return -1;
  73.     return 0;
  74. }
  76. static int gamelist_destroy(void)
  77. {
  78.     t_elem * curr;
  79.     t_tournament_user * user;
  80.     
  81.     if (tournament_head) {
  82. LIST_TRAVERSE(tournament_head,curr)
  83. {
  84.     if (!(user = elem_get_data(curr))) {
  85. eventlog(eventlog_level_error,__FUNCTION__,"tournament list contains NULL item");
  86. continue;
  87.     }
  88.     
  89.     if (list_remove_elem(tournament_head,curr)<0)
  90. eventlog(eventlog_level_error,__FUNCTION__,"could not remove item from list");
  91.     
  92.     if (user->name)
  93. free((void *)user->name); /* avoid warning */
  94.     
  95.     free(user);
  96.     
  97. }
  99. if (list_destroy(tournament_head)<0)
  100.     return -1;
  101. tournament_head = NULL;
  102.     }
  103.     return 0;
  104. }
  106. /*****/
  107. extern int tournament_check_client(char const * clienttag)
  108. {
  109.     if ((strcmp(clienttag,CLIENTTAG_WAR3XP) == 0) && (tournament_info->game_client == 2))
  110. return 1;
  111.     if ((strcmp(clienttag,CLIENTTAG_WARCRAFT3) == 0) && (tournament_info->game_client == 1))
  112. return 1;
  114.     return -1;
  115. }
  117. extern int tournament_signup_user(t_account * account)
  118. {
  119.     t_tournament_user * user;
  121.     if (!(account))
  122. return -1;
  123.     
  124.     if ((user = tournament_get_user(account))) {
  125. eventlog(eventlog_level_info,__FUNCTION__,"user "%s" already signed up in tournament",account_get_name(account));
  126. return 0;
  127.     }
  128.     
  129.     if (!(user = malloc(sizeof(t_tournament_user)))) {
  130. eventlog(eventlog_level_error,__FUNCTION__,"could not allocate memory for tournament user");
  131. return -1;
  132.     }
  133.     
  134.     user->name = strdup(account_get_name(account));
  135.     user->wins = 0;
  136.     user->losses = 0;
  137.     user->ties = 0;
  138.     user->in_game = 0;
  139.     user->in_finals = 0;
  140.         
  141.     if (list_prepend_data(tournament_head,user)<0) {
  142. eventlog(eventlog_level_error,__FUNCTION__,"could not insert user");
  143. free((void *)user->name); /* avoid warning */
  144. free(user);
  145. return -1;
  146.     }
  147.     
  148.     eventlog(eventlog_level_info,__FUNCTION__,"added user "%s" to tournament",account_get_name(account));
  149.     return 0;
  150. }
  152. static t_tournament_user * tournament_get_user(t_account * account)
  153. {
  154.     t_elem const * curr;
  155.     t_tournament_user * user;
  156.     
  157.     if (tournament_head)
  158. LIST_TRAVERSE(tournament_head,curr)
  159. {
  160.     user = elem_get_data(curr);
  161.     if (strcmp(user->name, account_get_name(account)) == 0)
  162. return user;
  163. }
  164.     
  165.     return NULL;
  166. }
  168. extern int tournament_user_signed_up(t_account * account)
  169. {
  170.     if (!(tournament_get_user(account)))
  171. return -1;
  172.         
  173.     return 0;
  174. }
  177. extern int tournament_add_stat(t_account * account, int stat)
  178. {
  179.     t_tournament_user * user;
  180.     
  181.     if (!(user = tournament_get_user(account)))
  182. return -1;
  183.     
  184.     if (stat == 1)
  185. user->wins++;
  186.     if (stat == 2)
  187. user->losses++;
  188.     if (stat == 3)
  189. user->ties++;
  190.     
  191.     return 0;
  192. }
  194. extern int tournament_get_stat(t_account * account, int stat)
  195. {
  196.     t_tournament_user * user;
  197.     
  198.     if (!(user = tournament_get_user(account)))
  199. return 0;
  200.     
  201.     if (stat == 1)
  202. return user->wins;
  203.     if (stat == 2)
  204. return user->losses;
  205.     if (stat == 3)
  206. return user->ties;
  208.     return 0;
  209. }
  211. extern int tournament_get_player_score(t_account * account)
  212. {
  213.     t_tournament_user * user;
  214.     int score;
  215.     
  216.     if (!(user = tournament_get_user(account)))
  217. return 0;
  218.     
  219.     score = user->wins * 3 + user->ties - user->losses;
  220.     
  221.     if (score < 0)
  222. return 0;
  224.     return score;
  225. }
  226.     
  227. extern int tournament_set_in_game_status(t_account * account, int status)
  228. {
  229.     t_tournament_user * user;
  230.     
  231.     if (!(user = tournament_get_user(account)))
  232. return -1;
  233.     
  234.     user->in_game = status;
  235.     
  236.     return 0;
  237. }
  238. /*
  239. static int tournament_get_in_game_status(t_account * account)
  240. {
  241.     t_tournament_user * user;
  242.     
  243.     if (!(user = tournament_get_user(account)))
  244. return 0;
  245.     
  246.     return user->in_game;
  247. }
  248. */
  249. extern int tournament_get_in_finals_status(t_account * account)
  250. {
  251.     t_tournament_user * user;
  252.     
  253.     if (!(user = tournament_get_user(account)))
  254. return 0;
  255.     
  256.     return user->in_finals;
  257. }
  259. extern int tournament_get_game_in_progress(void)
  260. {
  261.     t_elem const * curr;
  262.     t_tournament_user * user;
  263.     
  264.     if (tournament_head)
  265. LIST_TRAVERSE_CONST(tournament_head,curr)
  266. {
  267.     user = elem_get_data(curr);
  268.     if (user->in_game == 1)
  269. return 1;
  270. }
  271.     
  272.     return 0;
  273. }
  275. extern int tournament_is_arranged(void)
  276. {
  277.     if (tournament_info->game_selection == 2)
  278. return 1;
  279.     else
  280. return 0;
  281. }
  283. extern int tournament_get_totalplayers(void)
  284. {
  285.     return tournament_info->game_type * 2;
  286. }
  288. void tournament_check_date(unsigned int *mon, unsigned int *mday, unsigned int *year, unsigned int *hour, unsigned int *min, unsigned int *sec, char const * caller)
  289. {
  290.   if (*mon>12)
  291.   {
  292.     eventlog(eventlog_level_error,__FUNCTION__,"got invalid month (%u) in %s",*mon,caller);
  293.     *mon = 12;
  294.   }
  295.   if (*mday>31)
  296.   {
  297.     eventlog(eventlog_level_error,__FUNCTION__,"got invalid mday (%u) in %s",*mday,caller);
  298.     *mday = 31;
  299.   }
  300.   if (*hour>23)
  301.   {
  302.     eventlog(eventlog_level_error,__FUNCTION__,"got invalid hour (%u) from %s",*hour,caller);
  303.     *hour = 23;
  304.   }
  305.   if (*min >59)
  306.   {
  307.     eventlog(eventlog_level_error,__FUNCTION__,"got invalid min (%u) from %s",*min,caller);
  308.     *min = 59;
  309.   }
  310.   if (*sec >59)
  311.   {
  312.     eventlog(eventlog_level_error,__FUNCTION__,"got invalid sec (%u) from %s",*sec,caller);
  313.     *sec = 59;
  314.   }
  315.   return;
  316. }
  318. /*****/
  319. extern int tournament_init(char const * filename)
  320. {
  321.     FILE * fp;
  322.     unsigned int line,pos,mon,day,year,hour,min,sec;
  323.     char *buff,*temp,*pointer,*value;
  324.     char format[30];
  325.     char *variable;
  326.     char *sponsor = NULL;
  327.     char *have_sponsor = NULL;
  328.     char *have_icon = NULL;
  329.     struct tm * timestamp = malloc(sizeof(struct tm));
  330.     
  331.     sprintf(format,"%%02u/%%02u/%%04u %%02u:%%02u:%%02u");
  333.     tournament_info = malloc(sizeof(t_tournament_info));
  334.     tournament_info->start_preliminary = 0;
  335.     tournament_info->end_signup = 0;
  336.     tournament_info->end_preliminary = 0;
  337.     tournament_info->start_round_1 = 0;
  338.     tournament_info->start_round_2 = 0;
  339.     tournament_info->start_round_3 = 0;
  340.     tournament_info->start_round_4 = 0;
  341.     tournament_info->tournament_end = 0;
  342.     tournament_info->game_selection = 1; /* Default to PG */
  343.     tournament_info->game_type = 1; /* Default to 1v1 */
  344.     tournament_info->game_client = 2; /* Default to FT */
  345.     tournament_info->races = 0x3F; /* Default to all races */
  346.     tournament_info->format = strdup("");
  347.     tournament_info->sponsor = strdup("");
  348.     tournament_info->thumbs_down = 0;
  349.     
  350.     anongame_tournament_maplists_destroy();
  351.     
  352.     if (!filename) {
  353. eventlog(eventlog_level_error,__FUNCTION__,"got NULL filename");
  354.         free((void *)timestamp);
  355. return -1;
  356.     }
  357.     
  358.     if (!(fp = fopen(filename,"r"))) {
  359. eventlog(eventlog_level_error,__FUNCTION__,"could not open file "%s" for reading (fopen: %s)",filename,strerror(errno));
  360. free((void *)timestamp);
  361. return -1;
  362.     }
  363.     
  364.     for (line=1; (buff = file_get_line(fp)); line++) {
  365. for (pos=0; buff[pos]=='t' || buff[pos]==' '; pos++);
  366. if (buff[pos]=='' || buff[pos]=='#') {
  367.     free(buff);
  368.     continue;
  369. }
  370. if ((temp = strrchr(buff,'#'))) {
  371.     unsigned int len;
  372.     unsigned int endpos;
  373.     
  374.     *temp = '';
  375.     len = strlen(buff)+1;
  376.     for (endpos=len-1; buff[endpos]=='t' || buff[endpos]==' '; endpos--);
  377.     buff[endpos+1] = '';
  378. }
  380. if (strcmp(buff,"[MAPS]") == 0) {
  381.     char *clienttag, *ctag, *mapname, *mname;
  382.     
  383.     free(buff);
  384.     for (; (buff = file_get_line(fp));) {
  385. for (pos=0; buff[pos]=='t' || buff[pos]==' '; pos++);
  386. if (buff[pos]=='' || buff[pos]=='#') {
  387.     free(buff);
  388.     continue;
  389. }
  390. if ((temp = strrchr(buff,'#'))) {
  391.     unsigned int len;
  392.     unsigned int endpos;
  393.     
  394.     *temp = '';
  395.     len = strlen(buff)+1;
  396.     for (endpos=len-1; buff[endpos]=='t' || buff[endpos]==' '; endpos--);
  397.     buff[endpos+1] = '';
  398. }
  400. if (!(clienttag = strtok(buff, " t"))) { /* strtok modifies the string it is passed */
  401.     free(buff);
  402.     continue;
  403. }
  404. if (strcmp(buff,"[ENDMAPS]") == 0) {
  405.     free(buff);
  406.     break;
  407. }
  408. if (!(mapname = strtok(NULL," t"))) {
  409.     free(buff);
  410.     continue;
  411. }
  412. ctag = strdup(clienttag);
  413. mname = strdup(mapname);
  415. anongame_add_tournament_map(ctag, mname);
  416. eventlog(eventlog_level_trace,__FUNCTION__,"added tournament map "%s" for %s",mname,ctag);
  417. free(ctag);
  418. free(mname);
  419. free(buff);
  420.     }
  421. } else {
  422.     variable = buff;
  423.     pointer = strchr(variable,'=');
  424.     for(pointer--;pointer[0]==' ' || pointer[0]=='t';pointer--);
  425.     pointer[1]='';
  426.     pointer++;
  427.     pointer++;
  428.     pointer = strchr(pointer,'=');
  429.     pointer++;
  430.     
  431.     if (strcmp(variable,"start_preliminary") == 0) {
  432.         pointer = strchr(pointer,'"');
  433.         pointer++;
  434.         value = pointer;
  435.         pointer = strchr(pointer,'"');
  436.         pointer[0]='';
  437.         
  438.         sscanf(value,format,&mon,&day,&year,&hour,&min,&sec);
  440. tournament_check_date(&mon,&day,&year,&hour,&min,&sec,variable);
  441.         
  442.         timestamp->tm_mon = mon-1;
  443.         timestamp->tm_mday = day;
  444.         timestamp->tm_year = year-1900;
  445.         timestamp->tm_hour = hour;
  446.         timestamp->tm_min = min;
  447.         timestamp->tm_sec = sec;
  448.         timestamp->tm_isdst = -1;
  449.         
  450.         tournament_info->start_preliminary = mktime(timestamp);
  451.     }
  452.     else if (strcmp(variable,"end_signup") == 0) {
  453.         pointer = strchr(pointer,'"');
  454.         pointer++;
  455.         value = pointer;
  456.         pointer = strchr(pointer,'"');
  457.         pointer[0]='';
  458.         
  459.         sscanf(value,format,&mon,&day,&year,&hour,&min,&sec);
  460.         
  461. tournament_check_date(&mon,&day,&year,&hour,&min,&sec,variable);
  463.         timestamp->tm_mon = mon-1;
  464.         timestamp->tm_mday = day;
  465.         timestamp->tm_year = year-1900;
  466.         timestamp->tm_hour = hour;
  467.         timestamp->tm_min = min;
  468.         timestamp->tm_sec = sec;
  469.         timestamp->tm_isdst = -1;
  471. tournament_info->end_signup = mktime(timestamp);
  472.     }
  473.     else if (strcmp(variable,"end_preliminary") == 0) {
  474.         pointer = strchr(pointer,'"');
  475.         pointer++;
  476.         value = pointer;
  477.         pointer = strchr(pointer,'"');
  478.         pointer[0]='';
  479.         
  480.         sscanf(value,format,&mon,&day,&year,&hour,&min,&sec);
  481.         
  482. tournament_check_date(&mon,&day,&year,&hour,&min,&sec,variable);
  484.         timestamp->tm_mon = mon-1;
  485.         timestamp->tm_mday = day;
  486.         timestamp->tm_year = year-1900;
  487.         timestamp->tm_hour = hour;
  488.         timestamp->tm_min = min;
  489.         timestamp->tm_sec = sec;
  490.         timestamp->tm_isdst = -1;
  491.     
  492.         tournament_info->end_preliminary = mktime(timestamp);
  493.     }
  494.     else if (strcmp(variable,"start_round_1") == 0) {
  495. pointer = strchr(pointer,'"');
  496.         pointer++;
  497.         value = pointer;
  498.         pointer = strchr(pointer,'"');
  499.         pointer[0]='';
  500.         
  501.         sscanf(value,format,&mon,&day,&year,&hour,&min,&sec);
  502.         
  503. tournament_check_date(&mon,&day,&year,&hour,&min,&sec,variable);
  505.         timestamp->tm_mon = mon-1;
  506.         timestamp->tm_mday = day;
  507.         timestamp->tm_year = year-1900;
  508.         timestamp->tm_hour = hour;
  509.         timestamp->tm_min = min;
  510.         timestamp->tm_sec = sec;
  511.         timestamp->tm_isdst = -1;
  512.     
  513.         tournament_info->start_round_1 = mktime(timestamp);
  514.     }
  515.     else if (strcmp(variable,"start_round_2") == 0) {
  516.         pointer = strchr(pointer,'"');
  517.         pointer++;
  518.         value = pointer;
  519.         pointer = strchr(pointer,'"');
  520.         pointer[0]='';
  521.         
  522.         sscanf(value,format,&mon,&day,&year,&hour,&min,&sec);
  523.         
  524. tournament_check_date(&mon,&day,&year,&hour,&min,&sec,variable);
  526.         timestamp->tm_mon = mon-1;
  527.         timestamp->tm_mday = day;
  528.         timestamp->tm_year = year-1900;
  529.         timestamp->tm_hour = hour;
  530.         timestamp->tm_min = min;
  531.         timestamp->tm_sec = sec;
  532.         timestamp->tm_isdst = -1;
  534.         tournament_info->start_round_2 = mktime(timestamp);
  535.     }
  536.     else if (strcmp(variable,"start_round_3") == 0) {
  537. pointer = strchr(pointer,'"');
  538.         pointer++;
  539.         value = pointer;
  540.         pointer = strchr(pointer,'"');
  541.         pointer[0]='';
  542.         
  543.         sscanf(value,format,&mon,&day,&year,&hour,&min,&sec);
  544.         
  545. tournament_check_date(&mon,&day,&year,&hour,&min,&sec,variable);
  547.         timestamp->tm_mon = mon-1;
  548.         timestamp->tm_mday = day;
  549.         timestamp->tm_year = year-1900;
  550.         timestamp->tm_hour = hour;
  551.         timestamp->tm_min = min;
  552.         timestamp->tm_sec = sec;
  553.         timestamp->tm_isdst = -1;
  555.         tournament_info->start_round_3 = mktime(timestamp);
  556.     }
  557.     else if (strcmp(variable,"start_round_4") == 0) {
  558.         pointer = strchr(pointer,'"');
  559.         pointer++;
  560.         value = pointer;
  561.         pointer = strchr(pointer,'"');
  562.         pointer[0]='';
  563.         
  564.         sscanf(value,format,&mon,&day,&year,&hour,&min,&sec);
  565.         
  566. tournament_check_date(&mon,&day,&year,&hour,&min,&sec,variable);
  568.         timestamp->tm_mon = mon-1;
  569.         timestamp->tm_mday = day;
  570.         timestamp->tm_year = year-1900;
  571.         timestamp->tm_hour = hour;
  572.         timestamp->tm_min = min;
  573.         timestamp->tm_sec = sec;
  574.         timestamp->tm_isdst = -1;
  576.         tournament_info->start_round_4 = mktime(timestamp);
  577.     }
  578.     else if (strcmp(variable,"tournament_end") == 0) {
  579. pointer = strchr(pointer,'"');
  580.         pointer++;
  581.         value = pointer;
  582.         pointer = strchr(pointer,'"');
  583.         pointer[0]='';
  584.         
  585.         sscanf(value,format,&mon,&day,&year,&hour,&min,&sec);
  586.         
  587. tournament_check_date(&mon,&day,&year,&hour,&min,&sec,variable);
  589.         timestamp->tm_mon = mon-1;
  590.         timestamp->tm_mday = day;
  591.         timestamp->tm_year = year-1900;
  592.         timestamp->tm_hour = hour;
  593.         timestamp->tm_min = min;
  594.         timestamp->tm_sec = sec;
  595.         timestamp->tm_isdst = -1;
  597.         tournament_info->tournament_end = mktime(timestamp);
  598.     }
  599.     else if (strcmp(variable,"game_selection") == 0) {
  600. if (atoi(pointer) >= 1 && atoi(pointer) <= 2)
  601.     tournament_info->game_selection = atoi(pointer);
  602.     }
  603.     else if (strcmp(variable,"game_type") == 0) {
  604. if (atoi(pointer) >= 1 && atoi(pointer) <= 4)
  605.     tournament_info->game_type = atoi(pointer);
  606.     }
  607.     else if (strcmp(variable,"game_client") == 0) {
  608. if (atoi(pointer) >= 1 && atoi(pointer) <= 2)
  609.     tournament_info->game_client = atoi(pointer);
  610.     }
  611.     else if (strcmp(variable,"format") == 0) {
  612.         pointer = strchr(pointer,'"');
  613.         pointer++;
  614.         value = pointer;
  615.         pointer = strchr(pointer,'"');
  616.         pointer[0]='';
  617.         
  618.         if (tournament_info->format) free((void *)tournament_info->format);
  619.         tournament_info->format = strdup(value);
  620.     }
  621.     else if (strcmp(variable,"races") == 0) {
  622.         unsigned int intvalue = 0;
  623.         unsigned int i;
  624.         
  625.         pointer = strchr(pointer,'"');
  626.         pointer++;
  627.         value = pointer;
  628.         pointer = strchr(pointer,'"');
  629.         pointer[0]='';
  630.         
  631.         for(i=0;i<strlen(value);i++) {
  632.     if (value[i] == 'H') intvalue = intvalue | 0x01;
  633.     if (value[i] == 'O') intvalue = intvalue | 0x02;
  634.     if (value[i] == 'N') intvalue = intvalue | 0x04;
  635.     if (value[i] == 'U') intvalue = intvalue | 0x08;
  636.     if (value[i] == 'R') intvalue = intvalue | 0x20;
  637. }
  639. if (intvalue == 0 || intvalue == 0x2F)
  640.     intvalue = 0x3F; /* hack to make all races availiable */
  642.         tournament_info->races = intvalue;
  643.     }
  644.     else if (strcmp(variable,"sponsor") == 0) {
  645. pointer = strchr(pointer,'"');
  646. pointer++;
  647.         value = pointer;
  648.         pointer = strchr(pointer,'"');
  649.         pointer[0]='';
  651.         have_sponsor = strdup(value);
  652.     }
  653.     else if (strcmp(variable,"icon") == 0) {
  654.         pointer = strchr(pointer,'"');
  655.         pointer++;
  656.         value = pointer;
  657.         pointer = strchr(pointer,'"');
  658.         pointer[0]='';
  660.         have_icon = strdup(value);
  661.     }
  662.     else if (strcmp(variable,"thumbs_down") == 0) {
  663.         tournament_info->thumbs_down = atoi(pointer);
  664.     }
  665.     else
  666.         eventlog(eventlog_level_error,__FUNCTION__,"bad option "%s" in "%s"",variable,filename);
  667.     
  668.     if (have_sponsor && have_icon) {
  669.         sponsor = malloc(strlen(have_sponsor)+6);
  671. if (strlen(have_icon) == 4)
  672.     sprintf(sponsor, "%c%c%c%c,%s",have_icon[3],have_icon[2],have_icon[1],have_icon[0],have_sponsor);
  673. else if (strlen(have_icon) == 2)
  674.     sprintf(sponsor, "%c%c3W,%s",have_icon[1],have_icon[0],have_sponsor);
  675. else {
  676.     sprintf(sponsor, "PX3W,%s",have_sponsor); /* default to standard FT icon */
  677.     eventlog(eventlog_level_warn,__FUNCTION__,"bad icon length, using W3XP");
  678. }
  680. if (tournament_info->sponsor)
  681.     free((void *)tournament_info->sponsor);
  682.         
  683. tournament_info->sponsor = strdup(sponsor);
  684.         free((void *)have_sponsor);
  685. free((void *)have_icon);
  686.         free((void *)sponsor);
  687. have_sponsor = NULL;
  688.         have_icon = NULL;
  689.     }
  690.     free(buff);
  691. }
  692.     }
  693.     if (have_sponsor) free((void *)have_sponsor);
  694.     if (have_icon) free((void *)have_icon);
  695.     free((void *)timestamp);
  696.     fclose(fp);
  697.     
  698.     /* check if we have timestamps for all the times */ 
  699.     /* if not disable tournament by setting "start_preliminary" to 0 */
  700.     if (tournament_info->end_signup == 0 || tournament_info->end_preliminary == 0 ||
  701.     tournament_info->start_round_1 == 0 || tournament_info->start_round_2 == 0 ||
  702.     tournament_info->start_round_3 == 0 || tournament_info->start_round_4 == 0 ||
  703.     tournament_info->tournament_end == 0) {
  704. tournament_info->start_preliminary = 0;
  705. eventlog(eventlog_level_warn,__FUNCTION__,"one or more timestamps for tournaments is not valid, tournament has been disabled");
  706.     } else {
  707.      if (tournamentlist_create()<0) {
  708.     tournament_info->start_preliminary = 0;
  709.     eventlog(eventlog_level_warn,__FUNCTION__,"unable to create tournament list, tournament has been disabled");
  710. }
  711.     }
  712.     
  713.     return 0;
  714. }
  716. extern int tournament_destroy(void)
  717. {
  718.     if (tournament_info->format) free((void *)tournament_info->format);
  719.     if (tournament_info->sponsor) free((void *)tournament_info->sponsor);
  720.     if (tournament_info) free((void *)tournament_info);
  721.     tournament_info = NULL;
  722.     gamelist_destroy();
  723.     return 0;
  724. }
  726. extern int tournament_reload(char const * filename)
  727. {
  728. time_t tm;
  729. time(&tm);
  730. if((tm >= tournament_info->start_preliminary) && (tm <= tournament_info->tournament_end))
  731. {
  732. eventlog(eventlog_level_info,__FUNCTION__,"unable to reload tournament, tournament is in process");
  733. return -1;
  734. }
  735. tournament_destroy();
  736. return tournament_init(filename);
  737. }
  738. /*****/
  739. extern unsigned int tournament_get_start_preliminary(void)
  740. {
  741.     return tournament_info->start_preliminary;
  742. }
  744. extern unsigned int tournament_get_end_signup(void)
  745. {
  746.     return tournament_info->end_signup;
  747. }
  749. extern unsigned int tournament_get_end_preliminary(void)
  750. {
  751.     return tournament_info->end_preliminary;
  752. }
  754. extern unsigned int tournament_get_start_round_1(void)
  755. {
  756.     return tournament_info->start_round_1;
  757. }
  759. extern unsigned int tournament_get_start_round_2(void)
  760. {
  761.     return tournament_info->start_round_2;
  762. }
  764. extern unsigned int tournament_get_start_round_3(void)
  765. {
  766.     return tournament_info->start_round_3;
  767. }
  769. extern unsigned int tournament_get_start_round_4(void)
  770. {
  771.     return tournament_info->start_round_4;
  772. }
  774. extern unsigned int tournament_get_tournament_end(void)
  775. {
  776.     return tournament_info->tournament_end;
  777. }
  779. extern unsigned int tournament_get_game_selection(void)
  780. {
  781.     return tournament_info->game_selection;
  782. }
  784. extern unsigned int tournament_get_game_type(void)
  785. {
  786.     return tournament_info->game_type;
  787. }
  789. extern unsigned int tournament_get_races(void)
  790. {
  791.     return tournament_info->races;
  792. }
  794. extern char * tournament_get_format(void)
  795. {
  796.     return tournament_info->format;
  797. }
  799. extern char * tournament_get_sponsor(void)
  800. {
  801.     return tournament_info->sponsor;
  802. }
  804. extern unsigned int tournament_get_thumbs_down(void)
  805. {
  806.     return tournament_info->thumbs_down;
  807. }
  808. /****/