src/bnetd/anongame_gameresult.c

/*
 * 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.
 */
#include "common/setup_before.h"
#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/strrchr.h"
#include <errno.h>
#include "compat/strerror.h"
#include "common/list.h"
#include "common/eventlog.h"
#include "common/util.h"
#include "common/packet.h"
#include "common/tag.h"
#include "common/bn_type.h"
#include "common/packet.h"
#ifdef HAVE_ASSERT_H
# include <assert.h>
#endif
#include "common/xalloc.h"
#define ANONGAME_GAMERESULT_INTERNAL_ACCESS
#include "anongame_gameresult.h"
#include "common/setup_after.h"

extern int gameresult_destroy(t_anongame_gameresult * gameresult)
{
  if (!(gameresult))
  {
    eventlog(eventlog_level_error,__FUNCTION__,"got NULL gameresult");
    return -1;
  }

  if ((gameresult->players)) xfree((void *)gameresult->players);
  if ((gameresult->heroes)) xfree((void *)gameresult->heroes);
  xfree((void *)gameresult);

  return 0;
}

extern t_anongame_gameresult * anongame_gameresult_parse(t_packet const * const packet)
{
  t_anongame_gameresult                         * gameresult;
  t_client_w3route_gameresult_player            * player;
  t_client_w3route_gameresult_part2             * part2;
  t_client_w3route_gameresult_hero              * hero;
  t_client_w3route_gameresult_part3             * part3;

  int counter, heroes_count;
  int expectedsize;  //still without hero infos 
  unsigned int offset = 0;

  int result_count = bn_byte_get(packet->u.client_w3route_gameresult.number_of_results);
  expectedsize =  sizeof(t_client_w3route_gameresult) + 
                  sizeof(t_client_w3route_gameresult_player) * result_count +
                  sizeof(t_client_w3route_gameresult_part2) +
                  sizeof(t_client_w3route_gameresult_part3);

  if (packet_get_size(packet) < expectedsize)
  {
        eventlog(eventlog_level_error,__FUNCTION__,"gameresult packet is smaller than expected");
        return NULL;
  }

  gameresult = xmalloc(sizeof(t_anongame_gameresult));

  gameresult->players = xmalloc(sizeof(t_anongame_player)*result_count);

  gameresult->number_of_results = result_count;

  offset+= sizeof(t_client_w3route_gameresult);

  for (counter=0; counter<result_count;counter++)
  {
    player = (t_client_w3route_gameresult_player *)packet_get_raw_data_const(packet,offset);

    gameresult->players[counter].number = bn_byte_get(player->number);
    gameresult->players[counter].result = bn_int_get(player->result);
    gameresult->players[counter].race   = bn_int_get(player->race);

    offset+= sizeof(t_client_w3route_gameresult_player);
  }

  part2 = (t_client_w3route_gameresult_part2 *)packet_get_raw_data_const(packet,offset);

  gameresult->unit_score                = bn_int_get(part2->unit_score);
  gameresult->heroes_score              = bn_int_get(part2->heroes_score);
  gameresult->resource_score            = bn_int_get(part2->resource_score);
  gameresult->units_produced            = bn_int_get(part2->units_produced);
  gameresult->units_killed              = bn_int_get(part2->units_killed);
  gameresult->buildings_produced        = bn_int_get(part2->buildings_produced);
  gameresult->buildings_razed           = bn_int_get(part2->buildings_razed);
  gameresult->largest_army              = bn_int_get(part2->largest_army);
  heroes_count                          = bn_int_get(part2->heroes_used_count);
  gameresult->heroes_used_count         = heroes_count;

  offset+= sizeof(t_client_w3route_gameresult_part2);

  if ((heroes_count))
  {
    gameresult->heroes = xmalloc(sizeof(t_anongame_hero)*heroes_count);

    if (packet_get_size(packet) < expectedsize + sizeof(t_client_w3route_gameresult_hero)*heroes_count)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"gameresult packet is smaller than expected");
        return NULL;
    }

    for (counter=0; counter < heroes_count; counter++)
    {
      hero = (t_client_w3route_gameresult_hero *)packet_get_raw_data_const(packet,offset);

      gameresult->heroes[counter].level = bn_int_get(hero->level);
      gameresult->heroes[counter].race_and_name = bn_int_get(hero->race_and_name);
      gameresult->heroes[counter].hero_xp = bn_int_get(hero->hero_xp);

      offset+= sizeof(t_client_w3route_gameresult_hero);
    }
  }
  else
    gameresult->heroes = NULL;
    
  part3 = (t_client_w3route_gameresult_part3 *)packet_get_raw_data_const(packet,offset);

  gameresult->heroes_killed = bn_int_get(part3->heroes_killed);
  gameresult->items_obtained = bn_int_get(part3->items_obtained);
  gameresult->mercenaries_hired = bn_int_get(part3->mercenaries_hired);
  gameresult->total_hero_xp = bn_int_get(part3->total_hero_xp);
  gameresult->gold_mined = bn_int_get(part3->gold_mined);
  gameresult->lumber_harvested = bn_int_get(part3->lumber_harvested);
  gameresult->resources_traded_given = bn_int_get(part3->resources_traded_given);
  gameresult->resources_traded_taken = bn_int_get(part3->resources_traded_taken);
  gameresult->tech_percentage = bn_int_get(part3->tech_percentage);
  gameresult->gold_lost_to_upkeep = bn_int_get(part3->gold_lost_to_upkeep);
  
  return gameresult;
}

extern char gameresult_get_number_of_results(t_anongame_gameresult * gameresult)
{
  assert(gameresult);

  return gameresult->number_of_results;
}

extern int gameresult_get_player_result(t_anongame_gameresult * gameresult, int player)
{
  if (!(gameresult))
    return -1;

  if (player >= gameresult->number_of_results)
  {
    eventlog(eventlog_level_error,__FUNCTION__,"request for invalid player number");
    return -1;
  }

  return gameresult->players[player].result;
}

extern int gameresult_get_player_number(t_anongame_gameresult * gameresult, int player)
{
  if (!(gameresult))
    return -1;

  if (player >= gameresult->number_of_results)
  {
    eventlog(eventlog_level_error,__FUNCTION__,"request for invalid player number");
    return -1;
  }

  return gameresult->players[player].number;
}
1	sysadm	1.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"
17			#ifdef STDC_HEADERS
18			# include <stdlib.h>
19			#else
20			# ifdef HAVE_MALLOC_H
21			# include <malloc.h>
22			# endif
23			#endif
24			#ifdef HAVE_STRING_H
25			# include <string.h>
26			#else
27			# ifdef HAVE_STRINGS_H
28			# include <strings.h>
29			# endif
30			#endif
31			#include "compat/strrchr.h"
32			#include <errno.h>
33			#include "compat/strerror.h"
34			#include "common/list.h"
35			#include "common/eventlog.h"
36			#include "common/util.h"
37			#include "common/packet.h"
38			#include "common/tag.h"
39			#include "common/bn_type.h"
40			#include "common/packet.h"
41			#ifdef HAVE_ASSERT_H
42			# include <assert.h>
43			#endif
44			#include "common/xalloc.h"
45			#define ANONGAME_GAMERESULT_INTERNAL_ACCESS
46			#include "anongame_gameresult.h"
47			#include "common/setup_after.h"
48
49			extern int gameresult_destroy(t_anongame_gameresult * gameresult)
50			{
51			if (!(gameresult))
52			{
53			eventlog(eventlog_level_error,__FUNCTION__,"got NULL gameresult");
54			return -1;
55			}
56
57			if ((gameresult->players)) xfree((void *)gameresult->players);
58			if ((gameresult->heroes)) xfree((void *)gameresult->heroes);
59			xfree((void *)gameresult);
60
61			return 0;
62			}
63
64			extern t_anongame_gameresult * anongame_gameresult_parse(t_packet const * const packet)
65			{
66			t_anongame_gameresult * gameresult;
67			t_client_w3route_gameresult_player * player;
68			t_client_w3route_gameresult_part2 * part2;
69			t_client_w3route_gameresult_hero * hero;
70			t_client_w3route_gameresult_part3 * part3;
71
72			int counter, heroes_count;
73			int expectedsize; //still without hero infos
74			unsigned int offset = 0;
75
76			int result_count = bn_byte_get(packet->u.client_w3route_gameresult.number_of_results);
77			expectedsize = sizeof(t_client_w3route_gameresult) +
78			sizeof(t_client_w3route_gameresult_player) * result_count +
79			sizeof(t_client_w3route_gameresult_part2) +
80			sizeof(t_client_w3route_gameresult_part3);
81
82			if (packet_get_size(packet) < expectedsize)
83			{
84			eventlog(eventlog_level_error,__FUNCTION__,"gameresult packet is smaller than expected");
85			return NULL;
86			}
87
88			gameresult = xmalloc(sizeof(t_anongame_gameresult));
89
90			gameresult->players = xmalloc(sizeof(t_anongame_player)*result_count);
91
92			gameresult->number_of_results = result_count;
93
94			offset+= sizeof(t_client_w3route_gameresult);
95
96			for (counter=0; counter<result_count;counter++)
97			{
98			player = (t_client_w3route_gameresult_player *)packet_get_raw_data_const(packet,offset);
99
100			gameresult->players[counter].number = bn_byte_get(player->number);
101			gameresult->players[counter].result = bn_int_get(player->result);
102			gameresult->players[counter].race = bn_int_get(player->race);
103
104			offset+= sizeof(t_client_w3route_gameresult_player);
105			}
106
107			part2 = (t_client_w3route_gameresult_part2 *)packet_get_raw_data_const(packet,offset);
108
109			gameresult->unit_score = bn_int_get(part2->unit_score);
110			gameresult->heroes_score = bn_int_get(part2->heroes_score);
111			gameresult->resource_score = bn_int_get(part2->resource_score);
112			gameresult->units_produced = bn_int_get(part2->units_produced);
113			gameresult->units_killed = bn_int_get(part2->units_killed);
114			gameresult->buildings_produced = bn_int_get(part2->buildings_produced);
115			gameresult->buildings_razed = bn_int_get(part2->buildings_razed);
116			gameresult->largest_army = bn_int_get(part2->largest_army);
117			heroes_count = bn_int_get(part2->heroes_used_count);
118			gameresult->heroes_used_count = heroes_count;
119
120			offset+= sizeof(t_client_w3route_gameresult_part2);
121
122			if ((heroes_count))
123			{
124			gameresult->heroes = xmalloc(sizeof(t_anongame_hero)*heroes_count);
125
126			if (packet_get_size(packet) < expectedsize + sizeof(t_client_w3route_gameresult_hero)*heroes_count)
127			{
128			eventlog(eventlog_level_error,__FUNCTION__,"gameresult packet is smaller than expected");
129			return NULL;
130			}
131
132			for (counter=0; counter < heroes_count; counter++)
133			{
134			hero = (t_client_w3route_gameresult_hero *)packet_get_raw_data_const(packet,offset);
135
136			gameresult->heroes[counter].level = bn_int_get(hero->level);
137			gameresult->heroes[counter].race_and_name = bn_int_get(hero->race_and_name);
138			gameresult->heroes[counter].hero_xp = bn_int_get(hero->hero_xp);
139
140			offset+= sizeof(t_client_w3route_gameresult_hero);
141			}
142			}
143			else
144			gameresult->heroes = NULL;
145
146			part3 = (t_client_w3route_gameresult_part3 *)packet_get_raw_data_const(packet,offset);
147
148			gameresult->heroes_killed = bn_int_get(part3->heroes_killed);
149			gameresult->items_obtained = bn_int_get(part3->items_obtained);
150			gameresult->mercenaries_hired = bn_int_get(part3->mercenaries_hired);
151			gameresult->total_hero_xp = bn_int_get(part3->total_hero_xp);
152			gameresult->gold_mined = bn_int_get(part3->gold_mined);
153			gameresult->lumber_harvested = bn_int_get(part3->lumber_harvested);
154			gameresult->resources_traded_given = bn_int_get(part3->resources_traded_given);
155			gameresult->resources_traded_taken = bn_int_get(part3->resources_traded_taken);
156			gameresult->tech_percentage = bn_int_get(part3->tech_percentage);
157			gameresult->gold_lost_to_upkeep = bn_int_get(part3->gold_lost_to_upkeep);
158
159			return gameresult;
160			}
161
162			extern char gameresult_get_number_of_results(t_anongame_gameresult * gameresult)
163			{
164			assert(gameresult);
165
166			return gameresult->number_of_results;
167			}
168
169			extern int gameresult_get_player_result(t_anongame_gameresult * gameresult, int player)
170			{
171			if (!(gameresult))
172			return -1;
173
174			if (player >= gameresult->number_of_results)
175			{
176			eventlog(eventlog_level_error,__FUNCTION__,"request for invalid player number");
177			return -1;
178			}
179
180			return gameresult->players[player].result;
181			}
182
183			extern int gameresult_get_player_number(t_anongame_gameresult * gameresult, int player)
184			{
185			if (!(gameresult))
186			return -1;
187
188			if (player >= gameresult->number_of_results)
189			{
190			eventlog(eventlog_level_error,__FUNCTION__,"request for invalid player number");
191			return -1;
192			}
193
194			return gameresult->players[player].number;
195			}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1