Freeciv

/***********************************************************************

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, or (at your option)

fc_snprintf(msg, MAX_LEN_MSG,

_("The password must have at least %d capital letters, %d "

"numbers, and be at minimum %d [printable] characters long. "

MIN_PASSWORD_CAPS, MIN_PASSWORD_NUMS, MIN_PASSWORD_LEN);

for (i = 0; i < strlen(password); i++) {

TRUE, FALSE, FALSE)) {

/* Move */

(void) unit_move_pay(punit2, dir_tiles[rdir]);

TILE_XY(ptile), TILE_XY(dir_tiles[rdir]));

dest_found = TRUE;

}

/* This function corresponds to city_can_buy() in the client. */

fc_assert_ret(pcity && player_owns_city(pplayer, pcity));

if (pcity->turn_founded == game.info.turn) {

notify_player(pplayer, pcity->tile, E_BAD_COMMAND, ftc_server,

_("Cannot buy in city created this turn."));

return; /* sanity */

}

if (cost > pplayer->economic.gold) {

* tried to cheat! */

/* Split into two to allow localization of two pluralisations. */

char buf[MAX_LEN_MSG];

NULL, NULL,

CMD_ECHO_ADMINS, VCF_NONE, 50

},

/* TRANS: translate text between <> only */

N_("See \"/help timeoutincrease\"."),

N_("Every <turn> turns, add <value> to timeout timer, then add <turninc> "

"to <turn> and multiply <value> by <valuemult>. Use this command in "

{

static char buf[MAX_LEN_CONSOLE_LINE];

va_list args;

va_start(args, message);

fc_vsnprintf(buf, sizeof(buf), message, args);

va_end(args);

#define TURNS_LEFT 16

/**********************************************************************//**

**************************************************************************/

static void call_treaty_evaluate(struct player *pplayer, struct player *aplayer,

struct treaty *ptreaty)

if (pgiver != pplayer && pgiver != pother) {

return;

}

ptreaty = find_treaty(pplayer, pother);

if (ptreaty && remove_clause(ptreaty, pgiver, type, value)) {

player_number(pplayer),

player_number(pplayer));

notify_player(pother, NULL, E_DIPLOMACY, ftc_server,

player_name(pplayer));

/* Need to send to pplayer too, for multi-connects: */

dlsend_packet_diplomacy_cancel_meeting(pplayer->connections,

player_number(pother),

player_number(pplayer));

notify_player(pplayer, NULL, E_DIPLOMACY, ftc_server,

player_name(pother));

treaty_remove(ptreaty);

}

dsend_packet_diplomacy_init_meeting(dest, player_number(other),

player_number(pplayer));

clause_list_iterate(ptreaty->clauses, pclause) {

player_number(other),

player_number(pclause->from),

pclause->type,

/************************************************************************//**

Bribe an enemy unit.

- Can't bribe a unit if:

- Player doesn't have enough gold.

- Otherwise, the unit will be bribed.

/************************************************************************//**

This determines if a diplomat/spy survives and escapes.

if veteran):

- Diplomats always die.

- Escapes to home city.

notify_conn(pc->self, ptile, E_BAD_COMMAND, ftc_editor,

/* TRANS: ..." at <tile-coordinates> because"... */

_("Cannot create a city at %s because the "

tile_link(ptile), owner);

return;

changed = TRUE;

}

} improvement_iterate_end;

/* Handle food stock change. */

if (packet->food_stock != pcity->food_stock) {

int max = city_granary_size(city_size_get(pcity));

city_refresh_queue_processing();

/* FIXME: city_refresh_queue_processing only sends to city owner? */

conn_list_do_unbuffer(game.est_connections);

}

/************************************************************************//**

Handle editing of any or all player properties.

****************************************************************************/

const struct packet_edit_player *packet)

{

struct player *pplayer;

#include <fc_config.h>

#endif

/* utility */

#include "capability.h"

return L_START_ATTACK_FAST;

case 'A':

return L_START_ATTACK_STRONG;

return 0;

}

}

utype_has_flag(utype, UTYF_FLAGLESS)),

NULL);

* other cases, huts are avoided as start positions). Remove any such hut,

* and make sure to tell the client, since we may have already sent this

* tile (with the hut) earlier: */

Send game_info packet; some server options and various stuff...

dest == NULL means game.est_connections

as it contains the number of players. To avoid inconsistency, it

SHOULD be sent after rulesets and any other server settings.

****************************************************************************/

/***********************************************************************

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, or (at your option)

/**********************************************************************//**

Send all tiles known to specified clients.

If dest is NULL means game.est_connections.

Note for multiple connections this may change "sent" multiple times

for single player. This is ok, because "sent" data is just optimised

calculations, so it will be correct before this, for each connection

struct vision_site *psite = map_get_player_site(ptile, pplayer);

fc_assert_ret_val(psite == NULL || psite->location == ptile, NULL);

return psite;

}

buffer_shared_vision(pplayer);

players_iterate(pplayer2) {

if (!really_gives_vision(pplayer, pplayer2)

player_index(pplayer2))) {

log_debug("really removing shared vision from %s to %s",

player_name(pplayer), player_name(pplayer2));

const struct terrain *newter)

{

bool old_is_ocean, new_is_ocean;

if (!oldter || !newter) {

return FALSE;

}

const struct tile *ptile,

enum event_type event,

const struct ft_color color,

{

struct conn_list *dest = pplayer ? pplayer->connections : NULL;

struct packet_chat_msg genmsg;

const struct tile *ptile,

enum event_type event,

const struct ft_color color,

{

struct packet_chat_msg genmsg;

struct event_cache_players *players = NULL;

}

} extra_type_by_cause_iterate_end;

&& terrain_index(pterrain) < terrain_count());

} whole_map_iterate_end;

}

/* Check diplomatic status of stacked units. */

unit_list_iterate(ptile->units, punit2) {

unit_owner(punit2)));

} unit_list_iterate_end;

if (pcity) {

city_owner(pcity)));

}

} unit_list_iterate_end;

/*************************************************************************//**

Simplify a loop by wrapping get_packet_from_connection.

*****************************************************************************/

struct packet_to_handle *ppacket)

{

ppacket->data = get_packet_from_connection(pconn, &ppacket->type);

connection_do_unbuffer(pconn);

#if PROCESSING_TIME_STATISTICS

timer_read_seconds(request_time) * 1000.0);

#endif /* PROCESSING_TIME_STATISTICS */

conn_list_append(game.all_connections, pconn);

pconn->username, pconn->addr, pconn->server.ipaddr);

/* Give a ping timeout to send the PACKET_SERVER_JOIN_REQ, or close

* the mute connection. This timer will be canceled into

#ifndef FREECIV_HAVE_WINSOCK

/* SO_REUSEADDR considered harmful on Win, necessary otherwise */

(char *)&on, sizeof(on)) == -1) {

log_error("setsockopt SO_REUSEADDR failed: %s",

fc_strerror(fc_get_errno()));

}

#endif /* FREECIV_HAVE_WINSOCK */

(const char*)&setting, sizeof(setting))) {

log_error("Lan response setsockopt failed: %s", fc_strerror(fc_get_errno()));

return;

fc_assert_ret(ship->structurals <= NUM_SS_STRUCTURALS);

fc_assert_ret(ship->components <= NUM_SS_COMPONENTS);

fc_assert_ret(ship->modules <= NUM_SS_MODULES);

ship->mass = 0;

ship->support_rate = ship->energy_rate =

ship->success_rate = ship->travel_time = 0.0;

if (!src || pplayer == src) {

struct packet_spaceship_info info;

struct player_spaceship *ship = &pplayer->spaceship;

info.player_num = player_number(pplayer);

info.sship_state = ship->state;

info.structurals = ship->structurals;

info.success_rate = ship->success_rate;

info.travel_time = ship->travel_time;

info.structure = ship->structure;

lsend_packet_spaceship_info(dest, &info);

}

} players_iterate_end;

enum spaceship_place_type type, int num)

{

struct player_spaceship *ship = &pplayer->spaceship;

if (ship->state == SSHIP_NONE) {

if (from == ACT_REQ_PLAYER) {

notify_player(pplayer, NULL, E_SPACESHIP, ftc_server,

shuffled_players_iterate(pplayer) {

struct player_spaceship *ship = &pplayer->spaceship;

if (ship->state == SSHIP_LAUNCHED) {

result[n++] = pplayer;

}

&& is_great_wonder(pimprove)

&& (pcity = city_from_great_wonder(pimprove))) {

notify_player(city_owner(pcity), NULL, E_WONDER_OBSOLETE, ftc_server,

research_advance_name_translation

(research_get(city_owner(pcity)), tech_found),

improvement_name_translation(pimprove),

j++;

}

} advance_index_iterate_max_end;

if (j == 0) {

/* We've moved on to future tech */

if (vresearch->future_tech > presearch->future_tech) {

if (tech != A_FUTURE && !valid_advance_by_number(tech)) {

return;

}

if (tech != A_FUTURE

&& research_invention_state(research, tech) != TECH_PREREQS_KNOWN) {

return;