src/bnetd/game.c

/*
 * Copyright (C) 1998  Mark Baysinger (mbaysing@ucsd.edu)
 * Copyright (C) 1998,1999,2000 Ross Combs (rocombs@cs.nmsu.edu)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
#define GAME_INTERNAL_ACCESS
#include "common/setup_before.h"
#include <stdio.h>
#ifdef HAVE_STDDEF_H
# include <stddef.h>
#else
# ifndef NULL
#  define NULL ((void *)0)
# endif
#endif
#ifdef STDC_HEADERS
# include <stdlib.h>
#else
# ifdef HAVE_MALLOC_H
#  include <malloc.h>
# endif
#endif
#ifdef HAVE_STRING_H
# include <string.h>
#else
# ifdef HAVE_STRINGS_H
#  include <strings.h>
# endif
#endif
#include "compat/strdup.h"
#include "compat/strcasecmp.h"
#include <errno.h>
#include "compat/strerror.h"
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#ifdef TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# ifdef HAVE_SYS_TIME_H
#  include <sys/time.h>
# else
#  include <time.h>
# endif
#endif
#include "compat/difftime.h"
#ifdef HAVE_SYS_TYPES_H
# include <sys/types.h>
#endif
#ifdef HAVE_ASSERT_H
# include <assert.h>
#endif
#include "common/eventlog.h"
#include "prefs.h"
#include "connection.h"
#include "account.h"
#include "account_wrap.h"
#include "ladder.h"
#include "ladder_calc.h"
#include "common/bnettime.h"
#include "common/util.h"
#include "common/elist.h"
#include "common/tag.h"
#include "common/addr.h"
#include "common/xalloc.h"
#include "realm.h"
#include "watch.h"
#include "game_conv.h"
#include "game.h"
#include "server.h"
#include "compat/uint.h"
#include "compat/rename.h"
#include "common/setup_after.h"

DECLARE_ELIST_INIT(gamelist_head);
static int glist_length=0;
static int totalcount=0;


static void game_choose_host(t_game * game);
static void game_destroy(t_game * game);
static int game_report(t_game * game);


static void game_choose_host(t_game * game)
{
    unsigned int i;
    
    if (game->count<1)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"game has had no connections?!");
        return;
    }
    if (!game->connections)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"game has NULL connections array");
        return;
    }
    
    for (i=0; i<game->count; i++)
        if (game->connections[i])
        {
            game->owner = game->connections[i];
            game->addr  = conn_get_game_addr(game->connections[i]);
            game->port  = conn_get_game_port(game->connections[i]);
            return;
        }
    eventlog(eventlog_level_warn,__FUNCTION__,"no valid connections found");
}


extern char const * game_type_get_str(t_game_type type)
{
    switch (type)
    {
    case game_type_none:
        return "NONE";
        
    case game_type_melee:
        return "melee";
        
    case game_type_topvbot:
        return "top vs bottom";
        
    case game_type_ffa:
        return "free for all";
        
    case game_type_oneonone:
        return "one on one";
        
    case game_type_ctf:
        return "capture the flag";
        
    case game_type_greed:
        return "greed";
        
    case game_type_slaughter:
        return "slaughter";
        
    case game_type_sdeath:
        return "sudden death";
        
    case game_type_ladder:
        return "ladder";
        
    case game_type_ironman:
        return "ironman";
        
    case game_type_mapset:
        return "mapset";
        
    case game_type_teammelee:
        return "team melee";
        
    case game_type_teamffa:
        return "team free for all";
        
    case game_type_teamctf:
        return "team capture the flag";
        
    case game_type_pgl:
        return "PGL";
        
    case game_type_diablo:
        return "Diablo";
        
    case game_type_diablo2open:
        return "Diablo II (open)";
        
    case game_type_diablo2closed:
        return "Diablo II (closed)";
        
    case game_type_all:
    default:
        return "UNKNOWN";
    }
}


extern char const * game_status_get_str(t_game_status status)
{
    switch (status)
    {
    case game_status_started:
        return "started";
        
    case game_status_full:
        return "full";
        
    case game_status_open:
        return "open";
        
    case game_status_done:
        return "done";
        
    default:
        return "UNKNOWN";
    }
}


extern char const * game_result_get_str(t_game_result result)
{
    switch (result)
    {
    case game_result_none:
        return "NONE";
        
    case game_result_win:
        return "WIN";
        
    case game_result_loss:
        return "LOSS";
        
    case game_result_draw:
        return "DRAW";
        
    case game_result_disconnect:
        return "DISCONNECT";
        
    case game_result_observer:
        return "OBSERVER";
        
    default:
        return "UNKNOWN";
    }
}


extern char const * game_option_get_str(t_game_option option)
{
    switch (option)
    {
    case game_option_melee_normal:
        return "normal";
    case game_option_ffa_normal:
        return "normal";
    case game_option_oneonone_normal:
        return "normal";
    case game_option_ctf_normal:
        return "normal";
    case game_option_greed_10000:
        return "10000 minerals";
    case game_option_greed_7500:
        return "7500 minerals";
    case game_option_greed_5000:
        return "5000 minerals";
    case game_option_greed_2500:
        return "2500 minerals";
    case game_option_slaughter_60:
        return "60 minutes";
    case game_option_slaughter_45:
        return "45 minutes";
    case game_option_slaughter_30:
        return "30 minutes";
    case game_option_slaughter_15:
        return "15 minutes";
    case game_option_sdeath_normal:
        return "normal";
    case game_option_ladder_countasloss:
        return "count as loss";
    case game_option_ladder_nopenalty:
        return "no penalty";
    case game_option_mapset_normal:
        return "normal";
    case game_option_teammelee_4:
        return "4 teams";
    case game_option_teammelee_3:
        return "3 teams";
    case game_option_teammelee_2:
        return "2 teams";
    case game_option_teamffa_4:
        return "4 teams";
    case game_option_teamffa_3:
        return "3 teams";
    case game_option_teamffa_2:
        return "2 teams";
    case game_option_teamctf_4:
        return "4 teams";
    case game_option_teamctf_3:
        return "3 teams";
    case game_option_teamctf_2:
        return "2 teams";
    case game_option_topvbot_7:
        return "7 vs all";
    case game_option_topvbot_6:
        return "6 vs all";
    case game_option_topvbot_5:
        return "5 vs all";
    case game_option_topvbot_4:
        return "4 vs all";
    case game_option_topvbot_3:
        return "3 vs all";
    case game_option_topvbot_2:
        return "2 vs all";
    case game_option_topvbot_1:
        return "1 vs all";

    case game_option_none:
        return "none";
    default:
        return "UNKNOWN";
    }
}


extern char const * game_maptype_get_str(t_game_maptype maptype)
{
    switch (maptype)
    {
    case game_maptype_selfmade:
        return "Self-Made";
    case game_maptype_blizzard:
        return "Blizzard";
    case game_maptype_ladder:
        return "Ladder";
    case game_maptype_pgl:
        return "PGL";
    default:
        return "Unknown";
    }
}


extern char const * game_tileset_get_str(t_game_tileset tileset)
{
    switch (tileset)
    {
    case game_tileset_badlands:
        return "Badlands";
    case game_tileset_space:
        return "Space";
    case game_tileset_installation:
        return "Installation";
    case game_tileset_ashworld:
        return "Ash World";
    case game_tileset_jungle:
        return "Jungle";
    case game_tileset_desert:
        return "Desert";
    case game_tileset_ice:
        return "Ice";
    case game_tileset_twilight:
        return "Twilight";
    default:
        return "Unknown";
    }
}


extern char const * game_speed_get_str(t_game_speed speed)
{
    switch (speed)
    {
    case game_speed_slowest:
        return "slowest";
    case game_speed_slower:
        return "slower";
    case game_speed_slow:
        return "slow";
    case game_speed_normal:
        return "normal";
    case game_speed_fast:
        return "fast";
    case game_speed_faster:
        return "faster";
    case game_speed_fastest:
        return "fastest";
    default:
        return "unknown";
    }
}


extern char const * game_difficulty_get_str(t_game_difficulty difficulty)
{
    switch (difficulty)
    {
    case game_difficulty_normal:
        return "normal";
    case game_difficulty_nightmare:
        return "nightmare";
    case game_difficulty_hell:
        return "hell";
    case game_difficulty_hardcore_normal:
        return "hardcore normal";
    case game_difficulty_hardcore_nightmare:
        return "hardcore nightmare";
    case game_difficulty_hardcore_hell:
        return "hardcore hell";
    default:
        return "unknown";
    }
}


extern t_game * game_create(char const * name, char const * pass, char const * info, t_game_type type, int startver, t_clienttag clienttag, unsigned long gameversion)
{
    t_game * game;
    
    if (!name)
    {
        eventlog(eventlog_level_info,__FUNCTION__,"got NULL game name");
        return NULL;
    }
    if (!pass)
    {
        eventlog(eventlog_level_info,__FUNCTION__,"got NULL game pass");
        return NULL;
    }
    if (!info)
    {
        eventlog(eventlog_level_info,__FUNCTION__,"got NULL game info");
        return NULL;
    }
    
    if (gamelist_find_game(name,game_type_all))
    {
        eventlog(eventlog_level_info,__FUNCTION__,"game \"%s\" not created because it already exists",name);
        return NULL; /* already have a game by that name */
    }
    
    game = xmalloc(sizeof(t_game));
    game->name = xstrdup(name);
    game->pass = xstrdup(pass);
    game->info = xstrdup(info);
    if (!(game->clienttag = clienttag))
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got UNKNOWN clienttag");
        xfree((void *)game->info); /* avoid warning */
        xfree((void *)game->pass); /* avoid warning */
        xfree((void *)game->name); /* avoid warning */
        xfree(game);
        return NULL;
    }

    game->type          = type;
    game->addr          = 0; /* will be set by first player */
    game->port          = 0; /* will be set by first player */
    game->version       = gameversion;
    game->startver      = startver; /* start packet version */
    game->status        = game_status_open;
    game->realm         = 0;
    game->realmname     = NULL;
    game->id            = ++totalcount;
    game->mapname       = NULL;
    game->ref           = 0;
    game->count         = 0;
    game->owner         = NULL;
    game->connections   = NULL;
    game->players       = NULL;
    game->results       = NULL;
    game->reported_results = NULL;
    game->report_heads  = NULL;
    game->report_bodies = NULL;
    game->create_time   = now;
    game->start_time    = (time_t)0;
    game->lastaccess_time = now;
    game->option        = game_option_none;
    game->maptype       = game_maptype_none;
    game->tileset       = game_tileset_none;
    game->speed         = game_speed_none;
    game->mapsize_x     = 0;
    game->mapsize_y     = 0;
    game->maxplayers    = 0;
    game->bad           = 0;
    game->description   = NULL;
    game->flag          = strcmp(pass,"") ? game_flag_private : game_flag_none;
    game->difficulty    = game_difficulty_none;

    game_parse_info(game,info);

    elist_add(&gamelist_head,&game->glist_link);
    glist_length++;

    eventlog(eventlog_level_info,__FUNCTION__,"game \"%s\" (pass \"%s\") type %hu(%s) startver %d created",name,pass,(unsigned short)type,game_type_get_str(game->type),startver);
    
    return game;
}


static void game_destroy(t_game * game)
{
    unsigned int i;

    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return;
    }

    elist_del(&game->glist_link);
    glist_length--;

    if (game->realmname)
    { 
        realm_add_game_number(realmlist_find_realm(game->realmname),-1); 
    } 

    eventlog(eventlog_level_debug,__FUNCTION__,"game \"%s\" (count=%u ref=%u) removed from list...",game_get_name(game),game->count,game->ref);

    for (i=0; i<game->count; i++)
    {
        if (game->report_bodies && game->report_bodies[i])
            xfree((void *)game->report_bodies[i]); /* avoid warning */
        if (game->report_heads && game->report_heads[i])
            xfree((void *)game->report_heads[i]); /* avoid warning */
        if (game->reported_results && game->reported_results[i])
            xfree((void *)game->reported_results[i]);
    }
    if (game->realmname)
        xfree((void *)game->realmname); /* avoid warining */
    if (game->report_bodies)
        xfree((void *)game->report_bodies); /* avoid warning */
    if (game->report_heads)
        xfree((void *)game->report_heads); /* avoid warning */
    if (game->results)
        xfree((void *)game->results); /* avoid warning */
    if (game->reported_results)
        xfree((void *)game->reported_results);
    if (game->connections)
        xfree((void *)game->connections); /* avoid warning */
    if (game->players)
        xfree((void *)game->players); /* avoid warning */
    if (game->mapname)
        xfree((void *)game->mapname); /* avoid warning */
    if (game->description)
        xfree((void *)game->description); /* avoid warning */

    xfree((void *)game->info); /* avoid warning */
    xfree((void *)game->pass); /* avoid warning */
    if (game->name) xfree((void *)game->name); /* avoid warning */
    xfree((void *)game); /* avoid warning */

    eventlog(eventlog_level_info,__FUNCTION__,"game deleted");

    return;
}

static int game_evaluate_results(t_game * game)
{
  unsigned int i,j;
  unsigned int wins, losses, draws, disconnects, reports;

  if (!game)
  {
      eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
      return -1;
  }
  if (!game->results)
  {
      eventlog(eventlog_level_error,__FUNCTION__,"results array is NULL");
      return -1;
  }

  if (!game->reported_results)
  {
      eventlog(eventlog_level_error,__FUNCTION__,"reported_results array is NULL");
      return -1;
  }

  for (i=0;i<game->count;i++)
  {
    wins = losses = draws = disconnects = reports = 0;

    for (j=0;j<game->count;j++)
    {
      if (game->reported_results[j])
      {
        switch (game->reported_results[j][i])
        {
          case game_result_win:
            wins++;
            reports++;
            break;
          case game_result_loss:
            losses++;
            reports++;
            break;
          case game_result_draw:
            draws++;
            reports++;
            break;
          case game_result_disconnect:
            disconnects++;
            reports++;
            break;
          default:
            break;
        }
      }
    }
    eventlog(eventlog_level_debug,__FUNCTION__,"wins: %u losses: %u draws: %u disconnects: %u",wins,losses,draws,disconnects);
    
    //now decide what result we give
    if (!(reports)) // no results at all - game canceled before starting
    {
      game->results[i] = game_result_none;
      eventlog(eventlog_level_debug,__FUNCTION__,"deciding to give \"none\" to player %d",i);
    }
    else if ((disconnects>=draws) && (disconnects>=losses) && (disconnects>=wins))
    {
      game->results[i] = game_result_disconnect; //consider disconnects the worst case...
      eventlog(eventlog_level_debug,__FUNCTION__,"deciding to give \"disconnect\" to player %d",i);
    }
    else if ((losses>=wins) && (losses>=draws))
    {
      game->results[i]=game_result_loss;         //losses are also bad...
      eventlog(eventlog_level_debug,__FUNCTION__,"deciding to give \"loss\" to player %d",i);
    }
    else if ((draws>=wins))
    {
      game->results[i]=game_result_draw;
      eventlog(eventlog_level_debug,__FUNCTION__,"deciding to give \"draw\" to player %d",i);
    }
    else if (wins)
    {
      game->results[i]=game_result_win;
      eventlog(eventlog_level_debug,__FUNCTION__,"deciding to give \"win\" to player %d",i);
    }
  }
  return 0;
}

static int game_match_type(t_game_type type,const char *gametypes)
{
    char *p, *q;
    int res;

    if (!gametypes || !gametypes[0]) return 0;

    gametypes = p = xstrdup(gametypes);
    res = 0;
    do {
        q = strchr(gametypes,',');
        if (q) *q = '\0';
        if (!strcasecmp(p,"topvbot")) {
            if (type == game_type_topvbot) { res = 1; break; }
        } else if (!strcasecmp(p,"melee")) {
            if (type == game_type_melee) { res = 1; break; }
        } else if (!strcasecmp(p,"ffa")) {
            if (type == game_type_ffa) { res = 1; break; }
        } else if (!strcasecmp(p,"oneonone")) {
            if (type == game_type_oneonone) { res = 1; break; }
        }
        if (q) p = q + 1;
    } while(q);

    free((void*)gametypes);
    return res;
}

static int game_report(t_game * game)
{
    FILE *          fp;
    char *          realname;
    char *          tempname;
    unsigned int    i;
    unsigned int    realcount;
    t_ladder_info * ladder_info=NULL;
    int             discisloss;
    char            clienttag_str[5];
    
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return -1;
    }
    if (!game->clienttag)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got UNKNOWN clienttag");
        return -1;
    }
    if (!game->players)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"player array is NULL");
        return -1;
    }
    if (!game->reported_results)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"reported_results array is NULL");
        return -1;
    }
    if (!game->results)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"results array is NULL");
        return -1;
    }
    
    if (prefs_get_discisloss()==1 || game->option==game_option_ladder_countasloss)
        discisloss = 1;
    else
        discisloss = 0;

    if (game->clienttag==CLIENTTAG_WARCRAFT3_UINT || game->clienttag==CLIENTTAG_WAR3XP_UINT)
    // war3 game reporting is done elsewhere, so we can skip this function
            return 0;
    
    if (game->clienttag==CLIENTTAG_DIABLOSHR_UINT ||
        game->clienttag==CLIENTTAG_DIABLORTL_UINT ||
        game->clienttag==CLIENTTAG_DIABLO2ST_UINT ||
        game->clienttag==CLIENTTAG_DIABLO2DV_UINT ||
        game->clienttag==CLIENTTAG_DIABLO2XP_UINT)
    {
      if (prefs_get_report_diablo_games() == 1)
        /* diablo games have transient players and no reported winners/losers */
        realcount = 0;
      else
      {
        eventlog(eventlog_level_info,__FUNCTION__,"diablo gamereport disabled: ignoring game");
        return 0;
      }
    }
    else
    {
        game_evaluate_results(game); // evaluate results from the reported results
        /* "compact" the game; move all the real players to the top... */
        realcount = 0;
        for (i=0; i<game->count; i++)
        {
            if (!game->players[i])
            {
                eventlog(eventlog_level_error,__FUNCTION__,"player slot %u has NULL account",i);
                continue;
            }
            
            if (game->results[i]!=game_result_none)
            {
                game->players[realcount]       = game->players[i];
                game->results[realcount]       = game->results[i];
                game->report_heads[realcount]  = game->report_heads[i];
                game->report_bodies[realcount] = game->report_bodies[i];
                realcount++;
            }
        }
        
        /* then nuke duplicate players after the real players */
        for (i=realcount; i<game->count; i++)
        {
            game->players[i]          = NULL;
            game->results[i]          = game_result_none;
            game->report_heads[i]     = NULL;
            game->report_bodies[i]    = NULL;
        }
        
        if (realcount<1)
        {
            eventlog(eventlog_level_info,__FUNCTION__,"ignoring game");
            return -1;
        }
    }

    eventlog(eventlog_level_debug,__FUNCTION__,"realcount=%d count=%u",realcount,game->count);

    if (realcount>=1 && !game->bad)
    {
        if (game_is_ladder(game)
            )
        {
            t_ladder_id id;

            if (game_get_type(game)==game_type_ironman)
                id = ladder_id_ironman;
            else
                id = ladder_id_normal;

            for (i=0; i<realcount; i++)
            {
                eventlog(eventlog_level_debug,__FUNCTION__,"realplayer %u result=%u",i+1,(unsigned int)game->results[i]);
                
                ladder_init_account(game->players[i],game->clienttag,id);
                
                switch (game->results[i])
                {
                case game_result_win:
                    account_inc_ladder_wins(game->players[i],game->clienttag,id);
                    account_set_ladder_last_result(game->players[i],game->clienttag,id,game_result_get_str(game_result_win));
                    break;
                case game_result_loss:
                    account_inc_ladder_losses(game->players[i],game->clienttag,id);
                    account_set_ladder_last_result(game->players[i],game->clienttag,id,game_result_get_str(game_result_loss));
                    break;
                case game_result_draw:
                    account_inc_ladder_draws(game->players[i],game->clienttag,id);
                    account_set_ladder_last_result(game->players[i],game->clienttag,id,game_result_get_str(game_result_draw));
                    break;
                case game_result_disconnect:
                    if (discisloss)
                    {
                        account_inc_ladder_losses(game->players[i],game->clienttag,id);
                        account_set_ladder_last_result(game->players[i],game->clienttag,id,game_result_get_str(game_result_loss));
                    }
                    else
                    {
/* FIXME: do the first disconnect only stuff like below */
                        account_inc_ladder_disconnects(game->players[i],game->clienttag,id);
                        account_set_ladder_last_result(game->players[i],game->clienttag,id,game_result_get_str(game_result_disconnect));
                    }
                    break;
                default:
                    eventlog(eventlog_level_error,__FUNCTION__,"bad ladder game realplayer results[%u] = %u",i,game->results[i]);
                    account_inc_ladder_disconnects(game->players[i],game->clienttag,id);
                    account_set_ladder_last_result(game->players[i],game->clienttag,id,game_result_get_str(game_result_disconnect));
                }
                account_set_ladder_last_time(game->players[i],game->clienttag,id,bnettime());
            }

            ladder_info = xmalloc(sizeof(t_ladder_info)*realcount);
            if (ladder_update(game->clienttag,id,
                realcount,game->players,game->results,ladder_info,
                discisloss?ladder_option_disconnectisloss:ladder_option_none)<0)
            {
                eventlog(eventlog_level_error,__FUNCTION__,"unable to update ladder stats");
                xfree(ladder_info);
                ladder_info = NULL;
            }
        }
        else
        {
            int disc_set=0;
            
            for (i=0; i<realcount; i++)
            {
                switch (game->results[i])
                {
                case game_result_win:
                    account_inc_normal_wins(game->players[i],game->clienttag);
                    account_set_normal_last_result(game->players[i],game->clienttag,game_result_get_str(game_result_win));
                    break;
                case game_result_loss:
                    account_inc_normal_losses(game->players[i],game->clienttag);
                    account_set_normal_last_result(game->players[i],game->clienttag,game_result_get_str(game_result_loss));
                    break;
                case game_result_draw:
                    account_inc_normal_draws(game->players[i],game->clienttag);
                    account_set_normal_last_result(game->players[i],game->clienttag,game_result_get_str(game_result_draw));
                    break;
                case game_result_disconnect:
                    if (discisloss)
                    {
                        account_inc_normal_losses(game->players[i],game->clienttag);
                        account_set_normal_last_result(game->players[i],game->clienttag,game_result_get_str(game_result_loss));
                    }
                    else
                    {
/* FIXME: Is the missing player always the first one in this array?  It seems like it should be
   the person that created the game */
                        if (!disc_set)
                        {
                            account_inc_normal_disconnects(game->players[i],game->clienttag);
                            disc_set = 1;
                        }
                        account_set_normal_last_result(game->players[i],game->clienttag,game_result_get_str(game_result_disconnect));
                    }
                    break;
                default:
                    eventlog(eventlog_level_error,__FUNCTION__,"bad normal game realplayer results[%u] = %u",i,game->results[i]);
/* FIXME: Jung-woo fixed this here but we should find out what value results[i] has...
   and why "discisloss" isn't set above in game_result_disconnect */
#if 0
                    /* commented out for loose disconnect policy */
                    /* account_inc_normal_disconnects(game->players[i],game->clienttag); */
#endif
                    account_inc_normal_disconnects(game->players[i],game->clienttag);
                    account_set_normal_last_result(game->players[i],game->clienttag,game_result_get_str(game_result_disconnect));
                }
                account_set_normal_last_time(game->players[i],game->clienttag,bnettime());
            }
        }
    }
    
    if (game_get_type(game)!=game_type_ladder && prefs_get_report_all_games()!=1)
    {
        eventlog(eventlog_level_debug,__FUNCTION__,"not reporting normal games");
        return 0;
    }
    
    {
        struct tm * tmval;
        char        dstr[64];
        
        if (!(tmval = localtime(&now)))
            dstr[0] = '\0';
        else
            sprintf(dstr,"%04d%02d%02d%02d%02d%02d",
                    1900+tmval->tm_year,
                    tmval->tm_mon+1,
                    tmval->tm_mday,
                    tmval->tm_hour,
                    tmval->tm_min,
                    tmval->tm_sec);

        tempname = xmalloc(strlen(prefs_get_reportdir())+1+1+5+1+2+1+strlen(dstr)+1+6+1);
        sprintf(tempname,"%s/_bnetd-gr_%s_%06u",prefs_get_reportdir(),dstr,game->id);
        realname = xmalloc(strlen(prefs_get_reportdir())+1+2+1+strlen(dstr)+1+6+1);
        sprintf(realname,"%s/gr_%s_%06u",prefs_get_reportdir(),dstr,game->id);
    }
    
    if (!(fp = fopen(tempname,"w")))
    {
        eventlog(eventlog_level_error,__FUNCTION__,"could not open report file \"%s\" for writing (fopen: %s)",tempname,pstrerror(errno));
        if (ladder_info)
            xfree(ladder_info);
        xfree(realname);
        xfree(tempname);
        return -1;
    }
    
    if (game->bad)
        fprintf(fp,"[ game results ignored due to inconsistencies ]\n\n");
    fprintf(fp,"name=\"%s\" id="GAMEID_FORMAT"\n",
            game_get_name(game),
            game->id);
    fprintf(fp,"clienttag=%4s type=\"%s\" option=\"%s\"\n",
            tag_uint_to_str(clienttag_str,game->clienttag),
            game_type_get_str(game->type),
            game_option_get_str(game->option));
    {
        struct tm * gametime;
        char        timetemp[GAME_TIME_MAXLEN];
        
        if (!(gametime = localtime(&game->create_time)))
            strcpy(timetemp,"?");
        else
            strftime(timetemp,sizeof(timetemp),GAME_TIME_FORMAT,gametime);
        fprintf(fp,"created=\"%s\" ",timetemp);
        
        if (!(gametime = localtime(&game->start_time)))
            strcpy(timetemp,"?");
        else
            strftime(timetemp,sizeof(timetemp),GAME_TIME_FORMAT,gametime);
        fprintf(fp,"started=\"%s\" ",timetemp);
        
        if (!(gametime = localtime(&now)))
            strcpy(timetemp,"?");
        else
            strftime(timetemp,sizeof(timetemp),GAME_TIME_FORMAT,gametime);
        fprintf(fp,"ended=\"%s\"\n",timetemp);
    }
    {
        char const * mapname;
        
        if (!(mapname = game_get_mapname(game)))
            mapname = "?";
        
        fprintf(fp,"mapfile=\"%s\" mapauth=\"%s\" mapsize=%ux%u tileset=\"%s\"\n",
                mapname,
                game_maptype_get_str(game_get_maptype(game)),
                game_get_mapsize_x(game),game_get_mapsize_y(game),
                game_tileset_get_str(game_get_tileset(game)));
    }
    fprintf(fp,"joins=%u maxplayers=%u\n",
            game_get_count(game),
            game_get_maxplayers(game));
    
    if (!prefs_get_hide_addr())
        fprintf(fp,"host=%s\n",addr_num_to_addr_str(game_get_addr(game),game_get_port(game)));
    
    fprintf(fp,"\n\n");
    
    if (game->clienttag==CLIENTTAG_DIABLORTL_UINT)
        for (i=0; i<game->count; i++)
            fprintf(fp,"%-16s JOINED\n",account_get_name(game->players[i]));
    else
        if (ladder_info)
            for (i=0; i<realcount; i++)
                fprintf(fp,"%-16s %-8s rating=%u [#%05u]  prob=%4.1f%%  K=%2u  adj=%+d\n",
                        account_get_name(game->players[i]),
                        game_result_get_str(game->results[i]),
                        ladder_info[i].oldrating,
                        ladder_info[i].oldrank,
                        ladder_info[i].prob*100.0,
                        ladder_info[i].k,
                        ladder_info[i].adj);
        else
            for (i=0; i<realcount; i++)
                fprintf(fp,"%-16s %-8s\n",
                        account_get_name(game->players[i]),
                        game_result_get_str(game->results[i]));
    fprintf(fp,"\n\n");
    
    if (ladder_info)
        xfree(ladder_info);
    
    for (i=0; i<realcount; i++)
    {
        if (game->report_heads[i])
            fprintf(fp,"%s\n",game->report_heads[i]);
        else
            fprintf(fp,"[ game report header not available for player %u (\"%s\") ]\n",i+1,account_get_name(game->players[i]));
        if (game->report_bodies[i])
            fprintf(fp,"%s\n",game->report_bodies[i]);
        else
            fprintf(fp,"[ game report body not available for player %u (\"%s\") ]\n\n",i+1,account_get_name(game->players[i]));
    }
    fprintf(fp,"\n\n");
    
    if (game->clienttag==CLIENTTAG_STARCRAFT_UINT ||
        game->clienttag==CLIENTTAG_SHAREWARE_UINT ||
        game->clienttag==CLIENTTAG_BROODWARS_UINT ||
        game->clienttag==CLIENTTAG_WARCIIBNE_UINT)
    {
        for (i=0; i<realcount; i++)
            fprintf(fp,"%s's normal record is now %u/%u/%u (%u draws)\n",
                    account_get_name(game->players[i]),
                    account_get_normal_wins(game->players[i],game->clienttag),
                    account_get_normal_losses(game->players[i],game->clienttag),
                    account_get_normal_disconnects(game->players[i],game->clienttag),
                    account_get_normal_draws(game->players[i],game->clienttag));
    }
    if (game->clienttag==CLIENTTAG_STARCRAFT_UINT ||
        game->clienttag==CLIENTTAG_BROODWARS_UINT ||
        game->clienttag==CLIENTTAG_WARCIIBNE_UINT)
    {
        fprintf(fp,"\n");
        for (i=0; i<realcount; i++)
            fprintf(fp,"%s's standard ladder record is now %u/%u/%u (rating %u [#%05u]) (%u draws)\n",
                    account_get_name(game->players[i]),
                    account_get_ladder_wins(game->players[i],game->clienttag,ladder_id_normal),
                    account_get_ladder_losses(game->players[i],game->clienttag,ladder_id_normal),
                    account_get_ladder_disconnects(game->players[i],game->clienttag,ladder_id_normal),
                    account_get_ladder_rating(game->players[i],game->clienttag,ladder_id_normal),
                    account_get_ladder_rank(game->players[i],game->clienttag,ladder_id_normal),
                    account_get_ladder_draws(game->players[i],game->clienttag,ladder_id_normal));
    }
    if (game->clienttag==CLIENTTAG_WARCIIBNE_UINT)
    {
        fprintf(fp,"\n");
        for (i=0; i<realcount; i++)
            fprintf(fp,"%s's ironman ladder record is now %u/%u/%u (rating %u [#%05u]) (%u draws)\n",
                    account_get_name(game->players[i]),
                    account_get_ladder_wins(game->players[i],game->clienttag,ladder_id_ironman),
                    account_get_ladder_losses(game->players[i],game->clienttag,ladder_id_ironman),
                    account_get_ladder_disconnects(game->players[i],game->clienttag,ladder_id_ironman),
                    account_get_ladder_rating(game->players[i],game->clienttag,ladder_id_ironman),
                    account_get_ladder_rank(game->players[i],game->clienttag,ladder_id_ironman),
                    account_get_ladder_draws(game->players[i],game->clienttag,ladder_id_ironman));
    }
    
    fprintf(fp,"\nThis game lasted %lu minutes (elapsed).\n",((unsigned long int)difftime(now,game->start_time))/60);
    
    if (fclose(fp)<0)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"could not close report file \"%s\" after writing (fclose: %s)",tempname,pstrerror(errno));
        xfree(realname);
        xfree(tempname);
        return -1;
    }
    
    if (p_rename(tempname,realname)<0)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"could not rename report file to \"%s\" (rename: %s)",realname,pstrerror(errno));
        xfree(realname);
        xfree(tempname);
        return -1;
    }
    
    eventlog(eventlog_level_debug,__FUNCTION__,"game report saved as \"%s\"",realname);
    xfree(realname);
    xfree(tempname);
    return 0;
}


extern unsigned int game_get_id(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return 0;
    }
    return game->id;
}


extern char const * game_get_name(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return NULL;
    }
    return game->name ? game->name : "BNet";
}


extern t_game_type game_get_type(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return 0;
    }
    return game->type;
}


extern t_game_maptype game_get_maptype(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return game_maptype_none;
    }
    return game->maptype;
}


extern int game_set_maptype(t_game * game, t_game_maptype maptype)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return -1;
    }
    game->maptype = maptype;
    return 0;
}


extern t_game_tileset game_get_tileset(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return game_tileset_none;
    }
    return game->tileset;
}


extern int game_set_tileset(t_game * game, t_game_tileset tileset)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return -1;
    }
    game->tileset = tileset;
    return 0;
}


extern t_game_speed game_get_speed(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return game_speed_none;
    }
    return game->speed;
}


extern int game_set_speed(t_game * game, t_game_speed speed)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return -1;
    }
    game->speed = speed;
    return 0;
}


extern unsigned int game_get_mapsize_x(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return 0;
    }
    return game->mapsize_x;
}


extern int game_set_mapsize_x(t_game * game, unsigned int x)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return -1;
    }
    game->mapsize_x = x;
    return 0;
}


extern unsigned int game_get_mapsize_y(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return 0;
    }
    return game->mapsize_y;
}


extern int game_set_mapsize_y(t_game * game, unsigned int y)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return -1;
    }
    game->mapsize_y = y;
    return 0;
}


extern unsigned int game_get_maxplayers(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return 0;
    }
    return game->maxplayers;
}


extern int game_set_maxplayers(t_game * game, unsigned int maxplayers)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return -1;
    }
    game->maxplayers = maxplayers;
    return 0;
}


extern unsigned int game_get_difficulty(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return 0;
    }
    return game->difficulty;
}


extern int game_set_difficulty(t_game * game, unsigned int difficulty)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return -1;
    }
    game->difficulty = difficulty;
    return 0;
}


extern char const * game_get_description(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return NULL;
    }
    return game->description;
}


extern int game_set_description(t_game * game, char const * description)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return -1;
    }
    if (!description)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL description");
        return -1;
    }
    
    if (game->description != NULL) xfree((void *)game->description);
    game->description = xstrdup(description);
    
    return 0;
}


extern char const * game_get_pass(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return NULL;
    }
    return game->pass;
}


extern char const * game_get_info(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return NULL;
    }
    return game->info;
}


extern int game_get_startver(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return 0;
    }
    return game->startver;
}


extern unsigned long game_get_version(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return 0;
    }
    return game->version;
}


extern unsigned int game_get_ref(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return 0;
    }
    return game->ref;
}


extern unsigned int game_get_count(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return 0;
    }
    return game->count;
}


extern void game_set_status(t_game * game, t_game_status status)
{
        if (!game) {
                eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
                return;
        }
        // [quetzal] 20020829 - this should prevent invalid status changes
        // its like started game cant become open and so on
        if (game->status == game_status_started && 
                (status == game_status_open || status == game_status_full)) {
                eventlog(eventlog_level_error, "game_set_status", 
                "attempting to set status '%s' (%d) to started game", game_status_get_str(status), status);
                return;
        }

        if (game->status == game_status_done && status != game_status_done) {
                eventlog(eventlog_level_error, "game_set_status", 
                "attempting to set status '%s' (%d) to done game", game_status_get_str(status), status);
                return;
        }

    if (status==game_status_started && game->start_time==(time_t)0)
        game->start_time = now;
    game->status = status;
}


extern t_game_status game_get_status(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return 0;
    }
    return game->status;
}


extern unsigned int game_get_addr(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return 0;
    }
    
    return game->addr; /* host byte order */
}


extern unsigned short game_get_port(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return 0;
    }
    
    return game->port; /* host byte order */
}


extern unsigned int game_get_latency(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return 0;
    }
    if (game->ref<1)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"game \"%s\" has no players",game_get_name(game));
        return 0;
    }
    if (!game->players)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"game \"%s\" has NULL players array (ref=%u)",game_get_name(game),game->ref);
        return 0;
    }
    if (!game->players[0])
    {
        eventlog(eventlog_level_error,__FUNCTION__,"game \"%s\" has NULL players[0] entry (ref=%u)",game_get_name(game),game->ref);
        return 0;
    }
    
    return 0; /* conn_get_latency(game->players[0]); */
}

extern t_connection * game_get_player_conn(t_game const * game, unsigned int i)
{
  if (!game)
  {
    eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
    return NULL;
  }
  if (game->ref<1)
  {
    eventlog(eventlog_level_error,__FUNCTION__,"game \"%s\" has no players",game_get_name(game));
    return NULL;
  }
  if (!game->players)
  {
    eventlog(eventlog_level_error,__FUNCTION__,"game \"%s\" has NULL player array (ref=%u)",game_get_name(game),game->ref);
    return NULL;
  }
  if (!game->players[i])
  {
    eventlog(eventlog_level_error,__FUNCTION__,"game \"%s\" has NULL players[i] entry (ref=%u)",game_get_name(game),game->ref);
    return NULL;
  }
  return game->connections[i];
}

extern t_clienttag game_get_clienttag(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return 0;
    }
    return game->clienttag;
}


extern int game_add_player(t_game * game, char const * pass, int startver, t_connection * c)
{
    t_connection * * tempc;
    t_account * *    tempp;
    t_game_result *  tempr;
    t_game_result ** temprr;
    char const * *   temprh;
    char const * *   temprb;
    unsigned int i = 0;
    
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return -1;
    }
    if (!pass)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL password");
        return -1;
    }
    if (startver!=STARTVER_UNKNOWN && startver!=STARTVER_GW1 && startver!=STARTVER_GW3 && startver!=STARTVER_GW4 && startver!=STARTVER_REALM1)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got bad game startver %d",startver);
        return -1;
    }
    if (!c)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
        return -1;
    }
    if (game->type==game_type_ladder && account_get_normal_wins(conn_get_account(c),conn_get_clienttag(c))<10)
    /* if () ... */
    {
        eventlog(eventlog_level_error,__FUNCTION__,"can not join ladder game without 10 normal wins");
        return -1;
    }
    
    {
        t_clienttag gt;
        
        if (!(gt = game_get_clienttag(game)))
        {
            eventlog(eventlog_level_error,__FUNCTION__,"could not get clienttag for game");
            return -1;
        }
    }
    
    if (game->pass[0]!='\0' && strcasecmp(game->pass,pass)!=0)
    {
        eventlog(eventlog_level_debug,__FUNCTION__,"game \"%s\" password mismatch \"%s\"!=\"%s\"",game_get_name(game),game->pass,pass); 
        return -1;
    }

    if (game->connections && (game->count > 0))
    {
        for (i=0; i<game->count; i++)
        {
            if (game->connections[i] == NULL)
            {
                game->connections[i]   = c;
                game->players[i]       = conn_get_account(c);
                game->results[i]       = game_result_none;
                game->reported_results[i] = NULL;
                game->report_heads[i]  = NULL;
                game->report_bodies[i] = NULL;
    
                game->ref++;
                game->lastaccess_time = now;
                break;
            }
        }
        
    }
    
    if ((i == game->count) || (game->count == 0))
    {

        if (!game->connections) /* some realloc()s are broken */
            tempc = xmalloc((game->count+1)*sizeof(t_connection *));
        else
            tempc = xrealloc(game->connections,(game->count+1)*sizeof(t_connection *));
        game->connections = tempc;
        if (!game->players) /* some realloc()s are broken */
            tempp = xmalloc((game->count+1)*sizeof(t_account *));
        else
            tempp = xrealloc(game->players,(game->count+1)*sizeof(t_account *));
        game->players = tempp;

        if (!game->results) /* some realloc()s are broken */
            tempr = xmalloc((game->count+1)*sizeof(t_game_result));
        else
            tempr = xrealloc(game->results,(game->count+1)*sizeof(t_game_result));
        game->results = tempr;

        if (!game->reported_results)
            temprr = xmalloc((game->count+1)*sizeof(t_game_result *));
        else
            temprr = xrealloc(game->reported_results,(game->count+1)*sizeof(t_game_result *));
        game->reported_results = temprr;
    
        if (!game->report_heads) /* some xrealloc()s are broken */
            temprh = xmalloc((game->count+1)*sizeof(char const *));
        else
            temprh = xrealloc((void *)game->report_heads,(game->count+1)*sizeof(char const *)); /* avoid compiler warning */
        game->report_heads = temprh;
    
        if (!game->report_bodies) /* some xrealloc()s are broken */
            temprb = xmalloc((game->count+1)*sizeof(char const *));
        else
            temprb = xrealloc((void *)game->report_bodies,(game->count+1)*sizeof(char const *)); /* avoid compiler warning */
        game->report_bodies = temprb;

        game->connections[game->count]   = c;
        game->players[game->count]       = conn_get_account(c);
        game->results[game->count]       = game_result_none;
        game->reported_results[game->count] = NULL;
        game->report_heads[game->count]  = NULL;
        game->report_bodies[game->count] = NULL;
    
        game->count++;
        game->ref++;
        game->lastaccess_time = now;
    
    } // end of "if ((i == game->count) || (game->count == 0))"

    if (game->startver!=startver && startver!=STARTVER_UNKNOWN) /* with join startver ALWAYS unknown [KWS] */
        eventlog(eventlog_level_error,__FUNCTION__,"player \"%s\" client \"%s\" startver %u joining game startver %u (count=%u ref=%u)",account_get_name(conn_get_account(c)),clienttag_uint_to_str(conn_get_clienttag(c)),startver,game->startver,game->count,game->ref);
    
    game_choose_host(game);
    
    return 0;
}

extern int game_del_player(t_game * game, t_connection * c)
{
    char const * tname;
    unsigned int i;
    t_account *  account;
    
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return -1;
    }
    if (!c)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
        return -1;
    }
    if (!game->players)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"player array is NULL");
        return -1;
    }
    if (!game->reported_results)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"reported results array is NULL");
        return -1;
    }
    account = conn_get_account(c);

   if(conn_get_leavegamewhisper_ack(c)==0)
     {
       watchlist_notify_event(conn_get_account(c),NULL,conn_get_clienttag(c),watch_event_leavegame);
       conn_set_leavegamewhisper_ack(c,1); //1 = already whispered. We reset this each time user joins a channel
     }

    eventlog(eventlog_level_debug,__FUNCTION__,"game \"%s\" has ref=%u, count=%u; trying to remove player \"%s\"",game_get_name(game),game->ref,game->count,account_get_name(account));

    for (i=0; i<game->count; i++)
        if (game->players[i]==account && game->connections[i])
        {
            eventlog(eventlog_level_debug,__FUNCTION__,"removing player #%u \"%s\" from \"%s\", %u players left",i,(tname = account_get_name(account)),game_get_name(game),game->ref-1);
            game->connections[i] = NULL;
            if (!(game->reported_results[i]))
                eventlog(eventlog_level_debug,__FUNCTION__,"player \"%s\" left without reporting (valid) results",tname);
            
            eventlog(eventlog_level_debug,__FUNCTION__,"player deleted... (ref=%u)",game->ref);
            
            if (game->ref<2)
            {
                eventlog(eventlog_level_debug,__FUNCTION__,"no more players, reporting game");
                game_report(game);
                eventlog(eventlog_level_debug,__FUNCTION__,"no more players, destroying game");
                game_destroy(game);
                return 0;
            }
            
            game->ref--;
            game->lastaccess_time = now;
            
            game_choose_host(game);
            
            return 0;
        }
    
    eventlog(eventlog_level_error,__FUNCTION__,"player \"%s\" was not in the game",account_get_name(account));
    return -1;
}


extern int game_set_report(t_game * game, t_account * account, char const * rephead, char const * repbody)
{
    unsigned int pos;

    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return -1;
    }
    if (!account)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL account");
        return -1;
    }
    if (!game->players)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"player array is NULL");
        return -1;
    }
    if (!game->report_heads)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"report_heads array is NULL");
        return -1;
    }
    if (!game->report_bodies)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"report_bodies array is NULL");
        return -1;
    }
    if (!rephead)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"report head is NULL");
        return -1;
    }
    if (!repbody)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"report body is NULL");
        return -1;
    }
    
    {
        unsigned int i;
        
        pos = game->count;
        for (i=0; i<game->count; i++)
            if (game->players[i]==account)
                pos = i;
    }
    if (pos==game->count)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"could not find player \"%s\" to set result",account_get_name(account));
        return -1;
    }
    
    game->report_heads[pos] = xstrdup(rephead);
    game->report_bodies[pos] = xstrdup(repbody);
        
    return 0;
}

extern int game_set_reported_results(t_game * game, t_account * account, t_game_result * results)
{
    unsigned int i,j;
    t_game_result result;

    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return -1;
    }
    
    if (!account)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL account");
        return -1;
    }
    
    if (!results)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL results");
        return -1;
    }

    if (!game->players)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"player array is NULL");
        return -1;
    }

    if (!game->reported_results)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"reported_results array is NULL");
        return -1;
    }

    for (i=0;i<game->count;i++)
    {
        if ((game->players[i]==account)) break;
    }

    if (i==game->count)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"could not find player \"%s\" to set reported results",account_get_name(account));
        return -1;
    }
    
    if (game->reported_results[i])
    {
        eventlog(eventlog_level_error,__FUNCTION__,"player \"%s\" allready reported results - skipping this report",account_get_name(account));
        return -1;
    }

    for (j=0;j<game->count;j++)
    {
      result = results[j];
      switch(result)
      {
          case game_result_win:
          case game_result_loss:
          case game_result_draw:
          case game_result_observer:
          case game_result_disconnect:
            break;
          case game_result_none:
          case game_result_playing:
            if (i != j) break; /* accept none/playing only from "others" */
          default: /* result is invalid */
            if (i!=j)
            {
                eventlog(eventlog_level_error,__FUNCTION__,"ignoring bad reported result %u for player \"%s\"",(unsigned int)result,account_get_name(game->players[j]));
                results[i]=game_result_none;
            } else {
                eventlog(eventlog_level_error,__FUNCTION__,"got bad reported result %u for self - skipping results",(unsigned int)result);
                return -1;
            }
      }
    }

    game->reported_results[i] = results;
    
    return 0;
}


extern int game_set_self_report(t_game * game, t_account * account, t_game_result result)
{
    unsigned int i;
    t_game_result * results;
    
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return -1;
    }
    
    if (!account)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL account");
        return -1;
    }
    
    if (!game->players)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"player array is NULL");
        return -1;
    }

    if (!game->reported_results)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"reported_results array is NULL");
        return -1;
    }
    
    results = xmalloc(sizeof(t_game_result)*game->count);

    for (i=0;i<game->count;i++) 
    {
        if ((game->players[i]==account))
          results[i]= result;
        else
          results[i]= game_result_none;
    }

  game_set_reported_results(game,account,results);

  return 0;
}

extern t_game_result * game_get_reported_results(t_game * game, t_account * account)
{
    unsigned int i;

    if (!(game))
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return NULL;
    }

    if (!(account))
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL account");
        return NULL;
    }

    if (!(game->players))
    {
        eventlog(eventlog_level_error,__FUNCTION__,"player array is NULL");
        return NULL;
    }

    if (!(game->reported_results))
    {
        eventlog(eventlog_level_error,__FUNCTION__,"reported_results array is NULL");
        return NULL;
    }

    for (i=0;i<game->count;i++)
    {
        if ((game->players[i]==account)) break;
    }

    if (i==game->count)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"could not find player \"%s\" to set reported results",account_get_name(account));
        return NULL;
    }

    if (!(game->reported_results[i]))
    {
        eventlog(eventlog_level_error,__FUNCTION__,"player \"%s\" has not reported any results",account_get_name(account));
        return NULL;
    }

    return game->reported_results[i];
}


extern char const * game_get_mapname(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return NULL;
    }
    
    return game->mapname;
}


extern int game_set_mapname(t_game * game, char const * mapname)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return -1;
    }
    if (!mapname)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL mapname");
        return -1;
    }
    
    if (game->mapname != NULL) xfree((void *)game->mapname);
    
    game->mapname = xstrdup(mapname);
    
    return 0;
}


extern t_connection * game_get_owner(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return NULL;
    }
    return game->owner;
}


extern time_t game_get_create_time(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return (time_t)0;
    }
    
    return game->create_time;
}


extern time_t game_get_start_time(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return (time_t)0;
    }
    
    return game->start_time;
}


extern int game_set_option(t_game * game, t_game_option option)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return -1;
    }
    
    game->option = option;
    return 0;
}


extern t_game_option game_get_option(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL game");
        return game_option_none;
    }
    
    return game->option;
}


extern int gamelist_create(void)
{
    elist_init(&gamelist_head);
    glist_length = 0;
    return 0;
}


extern int gamelist_destroy(void)
{
    /* FIXME: if called with active games, games are not freed */
    elist_init(&gamelist_head);
    glist_length = 0;

    return 0;
}


extern int gamelist_get_length(void)
{
    return glist_length;
}


extern t_game * gamelist_find_game(char const * name, t_game_type type)
{
    t_elist *curr;
    t_game *game;

    elist_for_each(curr,&gamelist_head)
    {
        game = elist_entry(curr,t_game,glist_link);
        if ((type==game_type_all || game->type==type) && game->name && strcasecmp(name,game->name)==0)
            return game;
    }

    return NULL;
}


extern t_game * gamelist_find_game_byid(unsigned int id)
{
    t_elist *curr;
    t_game *game;

    elist_for_each(curr,&gamelist_head)
    {
        game = elist_entry(curr,t_game,glist_link);
        if (game->id==id)
            return game;
    }

    return NULL;
}


extern void gamelist_traverse(t_glist_func cb, void *data)
{
    t_elist *curr;

    elist_for_each(curr,&gamelist_head)
    {
        if (cb(elist_entry(curr,t_game,glist_link),data)<0) return;
    }
}


extern int gamelist_total_games(void)
{
    return totalcount;
}

extern int game_set_realm(t_game * game, unsigned int realm) 
{ 
    if (!game)
    { 
          eventlog(eventlog_level_error,__FUNCTION__,"got NULL game"); 
          return -1; 
    } 
    game->realm = realm; 
    return 0;
} 
    
extern unsigned int game_get_realm(t_game const * game) 
{ 
    if (!game)
    { 
          eventlog(eventlog_level_error,__FUNCTION__,"got NULL game"); 
          return 0; 
    } 
    return game->realm; 
} 
    
extern int game_set_realmname(t_game * game, char const * realmname) 
{ 
    char const * temp; 
    
    if (!game)
    { 
           eventlog(eventlog_level_error,__FUNCTION__,"got NULL game"); 
           return -1; 
    } 

    if (realmname)
        temp=xstrdup(realmname);
    else
      temp=NULL; 

    if (game->realmname)
      xfree((void *)game->realmname); /* avoid warning */
    game->realmname = temp; 
    return 0; 
} 
    
extern  char const * game_get_realmname(t_game const * game) 
{ 
    if (!game)
    { 
           eventlog(eventlog_level_error,__FUNCTION__,"got NULL game"); 
           return NULL; 
    } 
    return game->realmname; 
} 


extern void gamelist_check_voidgame(void) 
{ 
    t_elist *curr, *save;
    t_game *game;

    elist_for_each_safe(curr,&gamelist_head,save)
    { 
        game = elist_entry(curr,t_game,glist_link);
        if (!game->realm)
            continue;
        if (game->ref >= 1)
            continue;
        if ((now - game->lastaccess_time) > MAX_GAME_EMPTY_TIME)
            game_destroy(game); 
    }
}

extern void game_set_flag(t_game * game, t_game_flag flag)
{
    if (!game)
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL game");
        return;
    }
    game->flag = flag;
}


extern t_game_flag game_get_flag(t_game const * game)
{
    if (!game)
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL game");
        return 0;
    }
    return game->flag;
}

extern int game_get_count_by_clienttag(t_clienttag ct)
{
   t_game *game;
   t_elist *curr;
   int clienttaggames = 0;

   if (!ct) {
      eventlog(eventlog_level_error, __FUNCTION__, "got UNKNOWN clienttag");
      return 0;
   }

    /* Get number of games for client tag specific */
    elist_for_each(curr,&gamelist_head)
    {
        game = elist_entry(curr,t_game,glist_link);
        if(game_get_clienttag(game)==ct)
            clienttaggames++;
    }
   
   return clienttaggames;
}

static int game_match_name(const char *name, const char *prefix)
{
    /* the easy cases */
    if (!name || !*name) return 1;
    if (!prefix || !*prefix) return 1;

    if (!strncmp(name,prefix,strlen(prefix))) return 1;

    return 0;
}

extern int game_is_ladder(t_game *game)
{
    assert(game);

    /* all normal ladder games are still counted as ladder games */
    if (game->type == game_type_ladder ||
        game->type == game_type_ironman) return 1;

    /* addition game types are also checked against gamename prefix if set */
    if (game_match_type(game_get_type(game),prefs_get_ladder_games()) && 
        game_match_name(game_get_name(game),prefs_get_ladder_prefix())) return 1;

    return 0;
}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1