1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246
|
/* Pioneers - Implementation of the excellent Settlers of Catan board game.
* Go buy a copy.
*
* Copyright (C) 1999 Dave Cole
* Copyright (C) 2003 Bas Wijnen <shevek@fmf.nl>
* Copyright (C) 2006 Roland Clobus <rclobus@bigfoot.com>
*
* 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef __game_h
#define __game_h
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <stdio.h>
#include "map.h"
#include "driver.h"
typedef enum {
DEVEL_ROAD_BUILDING,
DEVEL_MONOPOLY,
DEVEL_YEAR_OF_PLENTY,
DEVEL_CHAPEL,
DEVEL_UNIVERSITY,
DEVEL_GOVERNORS_HOUSE,
DEVEL_LIBRARY,
DEVEL_MARKET,
DEVEL_SOLDIER
} DevelType;
#define NUM_DEVEL_TYPES (DEVEL_SOLDIER + 1)
#define MAX_PLAYERS 8 /* maximum number of players supported */
#define MAX_CHAT 496 /* maximum chat message size
* (512 - strlen("player 0 chat \n") - 1) */
#define MAX_NAME_LENGTH 30 /* maximum length for the name of a player */
/* Supported versions. These are ordered, so that it is possible to see
* if versions are greater or smaller than each other. The actual values do
* not matter and will change when older versions stop being supported. No
* part of the program may depend on their exact value, all comparisons must
* always be done with the symbols. */
/* Names for the versions are defined in common/game.c, and must be
* changed when the enum changes. */
typedef enum {
UNKNOWN_VERSION, /** Unknown version */
V0_10, /**< Lowest supported version */
V0_11, /**< City walls, player style, robber undo */
V0_12, /**< Trade protocol simplified */
V14, /**< More rules */
V15, /**< Dice deck */
FIRST_VERSION = V0_10,
LATEST_VERSION = V15
} ClientVersionType;
/** Convert to a ClientVersionType.
* @param cvt The text to analyze
* @return The version.
*/
ClientVersionType client_version_type_from_string(const gchar * cvt);
/** Convert from a ClientVersionType.
* @param cvt The version
* @return The string.
*/
const gchar *client_version_type_to_string(ClientVersionType cvt);
/** Will it be possible for a client to connect to a server?
* @param client_version The version of the client
* @param server_version The version of the server
* @return TRUE when the client can connect to the server
*/
gboolean can_client_connect_to_server(ClientVersionType client_version,
ClientVersionType server_version);
typedef struct {
gchar *title; /* title of the game */
gboolean random_terrain; /* shuffle terrain location? */
gboolean strict_trade; /* trade only before build/buy? */
gboolean domestic_trade; /* player trading allowed? */
guint num_players; /* number of players in the game */
gint sevens_rule; /* what to do when a seven is rolled */
/* 0 = normal, 1 = no 7s on first 2 turns (official rule variant),
* 2 = all 7s rerolled */
gboolean use_dice_deck; /* use dice deck instead of dice */
guint num_dice_decks; /* amount of dice decks to use */
guint num_removed_dice_cards; /* minimum amount of dice cards before reshuffling */
guint victory_points; /* target number of victory points */
gboolean check_victory_at_end_of_turn; /* check victory only at end of turn */
gint num_build_type[NUM_BUILD_TYPES]; /* number of each build type */
gint resource_count; /* number of each resource */
guint num_develop_type[NUM_DEVEL_TYPES]; /* number of each development */
Map *map; /* the game map */
gboolean parsing_map; /* currently parsing map? *//* Not in game_params[] */
guint tournament_time; /* time to start tournament time in minutes *//* Not in game_params[] */
gboolean quit_when_done; /* server quits after someone wins *//* Not in game_params[] */
gboolean use_pirate; /* is there a pirate in this game? */
GArray *island_discovery_bonus; /* list of VPs for discovering an island */
gchar *comments; /* information regarding the map */
gchar *description; /* description of the map */
} GameParams;
typedef struct {
gint id; /* identification for client-server communication */
gchar *name; /* name of the item */
gint points; /* number of points */
} Points;
typedef enum {
PARAMS_WINNABLE, /* the game can be won */
PARAMS_WIN_BUILD_ALL, /* the game can be won by building all */
PARAMS_WIN_PERHAPS, /* the game could be won */
PARAMS_NO_WIN /* the game cannot be won */
} WinnableState;
typedef enum {
PLAYER_HUMAN, /* the player is a human */
PLAYER_COMPUTER, /* the player is a computer player */
PLAYER_UNKNOWN /* it is unknown who is controlling the player */
} PlayerType;
#define NUM_PLAYER_TYPES (PLAYER_UNKNOWN + 1)
typedef void (*WriteLineFunc) (gpointer user_data, const gchar *);
/** Default style for a player. */
const gchar *default_player_style;
GameParams *params_new(void);
GameParams *params_copy(const GameParams * params);
GameParams *params_load_file(const gchar * fname);
gboolean params_is_equal(const GameParams * params1,
const GameParams * params2);
void params_free(GameParams * params);
void params_write_lines(const GameParams * params,
ClientVersionType version, gboolean write_secrets,
WriteLineFunc func, gpointer user_data);
gboolean params_write_file(const GameParams * params, const gchar * fname);
gboolean params_load_line(GameParams * params, const gchar * line);
gboolean params_load_finish(GameParams * params);
gboolean read_line_from_file(gchar ** line, FILE * f);
/** Check whether, in theory, the game could be won by a player.
* @param params The game parameters
* @retval win_message A message describing how/when the game can be won
* @retval point_specification A message describing how the points are distributed
* @return Whether the game can be won
*/
WinnableState params_check_winnable_state(const GameParams * params,
gchar ** win_message,
gchar ** point_specification);
/** Check whether the game cannot be started.
* @param params The game parameters
* @return TRUE if the game cannot be started
*/
gboolean params_game_is_unstartable(const GameParams * params);
/** Determine the type of the player, by analysing the style. */
PlayerType determine_player_type(const gchar * style);
Points *points_new(gint id, const gchar * name, gint points);
void points_free(Points * points);
/* Communication format
*
* The commands sent to and from the server use the following
* format specifiers:
* %S - string from current position to end of line
* this takes a gchar ** argument, in which an allocated buffer
* is returned. It must be freed by the caller.
* %d - integer
* %B - build type:
* 'road' = BUILD_ROAD
* 'ship' = BUILD_SHIP
* 'bridge' = BUILD_BRIDGE
* 'settlement' = BUILD_SETTLEMENT
* 'city' = BUILD_CITY
* %R - list of 5 integer resource counts:
* brick, grain, ore, wool, lumber
* %D - development card type:
* 0 = DEVEL_ROAD_BUILDING
* 1 = DEVEL_MONOPOLY
* 2 = DEVEL_YEAR_OF_PLENTY
* 3 = DEVEL_CHAPEL
* 4 = DEVEL_UNIVERSITY
* 5 = DEVEL_GOVERNORS_HOUSE
* 6 = DEVEL_LIBRARY
* 7 = DEVEL_MARKET
* 8 = DEVEL_SOLDIER
* %r - resource type:
* 'brick' = BRICK_RESOURCE
* 'grain' = GRAIN_RESOURCE
* 'ore' = ORE_RESOURCE
* 'wool' = WOOL_RESOURCE
* 'lumber' = LUMBER_RESOURCE
*/
/** Parse a line.
* @param line Line to parse
* @param fmt Format of the line, see communication format
* @retval ap Result of the parse
* @return -1 if the line could not be parsed, otherwise the offset in the line
*/
ssize_t game_vscanf(const gchar * line, const gchar * fmt, va_list ap);
/** Parse a line.
* @param line Line to parse
* @param fmt Format of the line, see communication format
* @return -1 if the line could not be parsed, otherwise the offset in the line
*/
ssize_t game_scanf(const gchar * line, const gchar * fmt, ...);
/** Print a line.
* @param fmt Format of the line, see communication format
* @param ap Arguments to the format
* @return A string (you must use g_free to free the string)
*/
gchar *game_vprintf(const gchar * fmt, va_list ap);
/** Print a line.
* @param fmt Format of the line, see communication format
* @return A string (you must use g_free to free the string)
*/
gchar *game_printf(const gchar * fmt, ...);
/** Convert a string to an array of integers.
* @param str A comma separated list of integers
* @return An array of integers. If the array has length zero, NULL is returned. (you must use g_array_free to free the array)
*/
GArray *build_int_list(const gchar * str);
/** Convert an array of integers to a string.
* @param name Prefix before the list of integers
* @param array Array of integers
* @return A string with a comma separated list of integers and name prefixed. (you must use g_free to free the string)
*/
gchar *format_int_list(const gchar * name, GArray * array);
#endif
|