Freeciv-3.2
Loading...
Searching...
No Matches
Macros | Enumerations | Functions
plrhand.h File Reference

Go to the source code of this file.

Macros

#define allowed_nations_iterate(pnation)
 
#define allowed_nations_iterate_end
 
#define shuffled_players_iterate(NAME_pplayer)
 
#define shuffled_players_iterate_end
 
#define phase_players_iterate(pplayer)
 
#define phase_players_iterate_end
 
#define alive_phase_players_iterate(pplayer)
 
#define alive_phase_players_iterate_end
 

Enumerations

enum  plr_info_level { INFO_MINIMUM , INFO_MEETING , INFO_EMBASSY , INFO_FULL }
 

Functions

struct playerserver_create_player (int player_id, const char *ai_tname, struct rgbcolor *prgbcolor, bool allow_ai_type_fallbacking)
 
const struct rgbcolorplayer_preferred_color (struct player *pplayer)
 
bool player_color_changeable (const struct player *pplayer, const char **reason)
 
void assign_player_colors (void)
 
void server_player_set_color (struct player *pplayer, const struct rgbcolor *prgbcolor)
 
const charplayer_color_ftstr (struct player *pplayer)
 
void server_player_init (struct player *pplayer, bool initmap, bool needs_team)
 
void give_midgame_initial_units (struct player *pplayer, struct tile *ptile)
 
void server_remove_player (struct player *pplayer)
 
void kill_player (struct player *pplayer)
 
void update_revolution (struct player *pplayer)
 
void government_change (struct player *pplayer, struct government *gov, bool revolution_finished)
 
void player_loot_player (struct player *pvictor, struct player *pvictim)
 
int revolution_length (struct government *gov, struct player *plr)
 
void update_capital (struct player *pplayer)
 
void player_limit_to_max_rates (struct player *pplayer)
 
void server_player_set_name (struct player *pplayer, const char *name)
 
bool server_player_set_name_full (const struct connection *caller, struct player *pplayer, const struct nation_type *pnation, const char *name, char *error_buf, size_t error_buf_len)
 
struct nation_typepick_a_nation (const struct nation_list *choices, bool ignore_conflicts, bool needs_startpos, enum barbarian_type barb_type)
 
bool nation_is_in_current_set (const struct nation_type *pnation)
 
bool client_can_pick_nation (const struct nation_type *nation)
 
void count_playable_nations (void)
 
void send_nation_availability (struct conn_list *dest, bool nationset_change)
 
void fit_nationset_to_players (void)
 
void check_player_max_rates (struct player *pplayer)
 
void make_contact (struct player *pplayer1, struct player *pplayer2, struct tile *ptile)
 
void maybe_make_contact (struct tile *ptile, struct player *pplayer)
 
void enter_war (struct player *pplayer, struct player *pplayer2)
 
void player_update_last_war_action (struct player *pplayer)
 
void player_info_freeze (void)
 
void player_info_thaw (void)
 
void send_player_all_c (struct player *src, struct conn_list *dest)
 
void send_player_info_c (struct player *src, struct conn_list *dest)
 
void send_player_diplstate_c (struct player *src, struct conn_list *dest)
 
struct conn_listplayer_reply_dest (struct player *pplayer)
 
void shuffle_players (void)
 
void set_shuffled_players (int *shuffled_players)
 
struct playershuffled_player (int i)
 
void reset_all_start_commands (bool plrchange)
 
bool civil_war_possible (struct player *pplayer, bool conquering_city, bool honour_server_option)
 
bool civil_war_triggered (struct player *pplayer)
 
struct playercivil_war (struct player *pplayer)
 
void update_players_after_alliance_breakup (struct player *pplayer, struct player *pplayer2, const struct unit_list *pplayer_seen_units, const struct unit_list *pplayer2_seen_units)
 
int barbarian_count (void)
 
int normal_player_count (void)
 
void player_status_add (struct player *plr, enum player_status status)
 
bool player_status_check (struct player *plr, enum player_status status)
 
void player_status_reset (struct player *plr)
 
const charplayer_delegation_get (const struct player *pplayer)
 
void player_delegation_set (struct player *pplayer, const char *username)
 
bool player_delegation_active (const struct player *pplayer)
 
void send_delegation_info (const struct connection *pconn)
 
struct playerplayer_by_user_delegated (const char *name)
 
void playercolor_init (void)
 
void playercolor_free (void)
 
int playercolor_count (void)
 
void playercolor_add (struct rgbcolor *prgbcolor)
 
struct rgbcolorplayercolor_get (int id)
 
void player_set_to_ai_mode (struct player *pplayer, enum ai_level skill_level)
 
void player_set_under_human_control (struct player *pplayer)
 
void update_national_activities (struct player *pplayer, int old_gold)
 

Macro Definition Documentation

◆ alive_phase_players_iterate

#define alive_phase_players_iterate (   pplayer)
Value:
do { \
if (pplayer->is_alive) {
char * incite_cost
Definition comments.c:75

Definition at line 123 of file plrhand.h.

◆ alive_phase_players_iterate_end

#define alive_phase_players_iterate_end
Value:
} \
} while (FALSE);
#define phase_players_iterate_end
Definition plrhand.h:118
#define FALSE
Definition support.h:47

Definition at line 128 of file plrhand.h.

◆ allowed_nations_iterate

#define allowed_nations_iterate (   pnation)
Value:
nations_iterate(pnation) { \
#define nations_iterate(NAME_pnation)
Definition nation.h:333
bool nation_is_in_current_set(const struct nation_type *pnation)
Definition plrhand.c:2589

Definition at line 69 of file plrhand.h.

◆ allowed_nations_iterate_end

#define allowed_nations_iterate_end
Value:
} \
#define nations_iterate_end
Definition nation.h:336

Definition at line 73 of file plrhand.h.

◆ phase_players_iterate

#define phase_players_iterate (   pplayer)
Value:
do {\
struct civ_game game
Definition game.c:62
bool is_player_phase(const struct player *pplayer, int phase)
Definition game.c:707
struct packet_game_info info
Definition game.h:89

Definition at line 113 of file plrhand.h.

◆ phase_players_iterate_end

#define phase_players_iterate_end
Value:
}\
} while (FALSE);
#define shuffled_players_iterate_end
Definition plrhand.h:108

Definition at line 118 of file plrhand.h.

◆ shuffled_players_iterate

#define shuffled_players_iterate (   NAME_pplayer)
Value:
do {\
int MY_i;\
log_debug("shuffled_players_iterate @ %s line %d",\
#define __FC_LINE__
Definition log.h:40
int player_slot_count(void)
Definition player.c:418
struct player * shuffled_player(int i)
Definition plrhand.c:2420

Definition at line 98 of file plrhand.h.

◆ shuffled_players_iterate_end

#define shuffled_players_iterate_end
Value:
}\
}\
} while (FALSE)

Definition at line 108 of file plrhand.h.

Enumeration Type Documentation

◆ plr_info_level

Enumerator
INFO_MINIMUM 
INFO_MEETING 
INFO_EMBASSY 
INFO_FULL 

Definition at line 25 of file plrhand.h.

Function Documentation

◆ assign_player_colors()

void assign_player_colors ( void  )

Permanently assign colors to any players that don't already have them. First assign preferred colors, then assign the rest randomly, trying to avoid clashes.

Definition at line 1733 of file plrhand.c.

Referenced by create_animals(), create_barbarian_player(), create_command_newcomer(), handle_edit_player_create(), sg_load_players(), sg_load_players(), split_player(), and srv_ready().

◆ barbarian_count()

int barbarian_count ( void  )

Return the number of barbarian players.

Definition at line 3196 of file plrhand.c.

◆ check_player_max_rates()

void check_player_max_rates ( struct player pplayer)

The following checks that government rates are acceptable for the present form of government. Has to be called when switching governments or when toggling from AI to human.

Definition at line 776 of file plrhand.c.

Referenced by adv_best_government(), dai_gov_value(), government_change(), handle_player_change_government(), and player_set_under_human_control().

◆ civil_war()

struct player * civil_war ( struct player pplayer)

Capturing a nation's primary capital is a devastating blow. This function creates a new AI player, and randomly splits the original players city list into two. Of course this results in a real mix up of territory - but since when have civil wars ever been tidy, or civil.

Embassies: All embassies with other players are lost. Other players retain their embassies with pplayer. Units: Units inside cities are assigned to the new owner of the city. Units outside are transferred along with the ownership of their supporting city. If the units are in a unit stack with non rebel units, then whichever units are nearest an allied city are teleported to that city. If the stack is a transport at sea, then all rebel units on the transport are teleported to their nearest allied city.

Cities: Are split randomly into 2. This results in a real mix up of teritory - but since when have civil wars ever been tidy, or for any matter civil?

One caveat, since the spliting of cities is random, you can conceive that this could result in either the original player or the rebel getting 0 cities. To prevent this, the hack below ensures that each side gets roughly half, which ones is still determined randomly.

  • Kris Bubendorfer

Definition at line 3005 of file plrhand.c.

Referenced by api_edit_civil_war(), kill_player(), unit_conquer_city(), and unit_do_destroy_city().

◆ civil_war_possible()

bool civil_war_possible ( struct player pplayer,
bool  conquering_city,
bool  honour_server_option 
)

Check if civil war is possible for a player. If conquering_city is TRUE, one of the cities currently in the empire will shortly not be and shouldn't be considered. honour_server_option controls whether we honour the 'civilwarsize' server option. (If we don't, we still enforce a minimum empire size, to avoid the risk of creating a new player with no cities.)

Definition at line 2908 of file plrhand.c.

Referenced by api_edit_civil_war(), unit_conquer_city(), and unit_do_destroy_city().

◆ civil_war_triggered()

bool civil_war_triggered ( struct player pplayer)

civil_war_triggered: The capture of a primary capital is not a sure fire way to throw and empire into civil war. Some governments are more susceptible than others, here are the base probabilities: Anarchy 90% Despotism 80% Monarchy 70% Fundamentalism 60% (Only in civ2 ruleset) Communism 50% Republic 40% Democracy 30% In addition each city in disorder adds and each celebrating city subtracts from the probability of a civil war. If you have at least 1 turns notice of the impending loss of your capital, you can hike luxuries up to the highest value, and by this reduce the chance of a civil war. In fact by hiking the luxuries to 100% under Democracy, it is easy to get massively negative numbers - guaranteeing imunity from civil war. Likewise, 3 cities in disorder under despotism guarantees a civil war. This routine calculates these probabilities and returns true if a civil war is triggered.

  • Kris Bubendorfer

Definition at line 2955 of file plrhand.c.

Referenced by api_edit_civil_war(), unit_conquer_city(), and unit_do_destroy_city().

◆ client_can_pick_nation()

bool client_can_pick_nation ( const struct nation_type pnation)

Return whether a nation is "pickable" – whether players can select it at game start. (is_nation_pickable() is the equivalent function on the client.)

Definition at line 2613 of file plrhand.c.

Referenced by generate_players(), handle_nation_select_req(), playernation_command(), and send_nation_availability_real().

◆ count_playable_nations()

void count_playable_nations ( void  )

Update the server's cached number of playable nations. Call when the nationset changes.

Definition at line 2598 of file plrhand.c.

Referenced by fit_nationset_to_players(), load_ruleset_nations(), and nationset_action().

◆ enter_war()

void enter_war ( struct player pplayer,
struct player pplayer2 
)

Two players enter war.

Definition at line 848 of file plrhand.c.

Referenced by handle_diplomacy_cancel_pact(), and update_diplomatics().

◆ fit_nationset_to_players()

void fit_nationset_to_players ( void  )

Try to select a nation set that fits the current players' nations, or failing that, unset the nations of some of the players.

Does not update clients, as is assumed to be called during game setup, and to be followed by sending full game info to clients.

Definition at line 2658 of file plrhand.c.

Referenced by sg_load_players(), and sg_load_players().

◆ give_midgame_initial_units()

void give_midgame_initial_units ( struct player pplayer,
struct tile ptile 
)

Gives units that every player should have. Usually called for players created midgame.

Definition at line 1869 of file plrhand.c.

Referenced by civil_war().

◆ government_change()

void government_change ( struct player pplayer,
struct government gov,
bool  revolution_finished 
)

Finish the revolution and set the player's government. Call this as soon as the player has set a target_government and the revolution_finishes turn has arrived.

Definition at line 337 of file plrhand.c.

Referenced by end_phase(), handle_edit_player(), and update_revolution().

◆ kill_player()

void kill_player ( struct player pplayer)

Murder a player in cold blood.

Called from srv_main kill_dying_players() and edit packet handler handle_edit_player_remove().

Definition at line 126 of file plrhand.c.

Referenced by handle_edit_player_remove(), and kill_dying_players().

◆ make_contact()

void make_contact ( struct player pplayer1,
struct player pplayer2,
struct tile ptile 
)

Update contact info.

Definition at line 2302 of file plrhand.c.

Referenced by do_have_contacts_effect(), and maybe_make_contact().

◆ maybe_make_contact()

void maybe_make_contact ( struct tile ptile,
struct player pplayer 
)

Check if we make contact with anyone.

Definition at line 2361 of file plrhand.c.

Referenced by create_city(), do_paradrop(), illegal_action_pay_price(), place_unit(), transfer_city(), transfer_unit(), and unit_move().

◆ nation_is_in_current_set()

bool nation_is_in_current_set ( const struct nation_type pnation)

Is the nation in the currently selected nationset? If not, it's not allowed to appear in the game.

Definition at line 2589 of file plrhand.c.

Referenced by client_can_pick_nation(), create_command_newcomer(), dai_can_requirement_be_met_in_city(), fit_nationset_to_players(), handle_edit_player(), handle_nation_select_req(), nationset_action(), and pick_a_nation().

◆ normal_player_count()

int normal_player_count ( void  )

◆ pick_a_nation()

struct nation_type * pick_a_nation ( const struct nation_list choices,
bool  ignore_conflicts,
bool  needs_startpos,
enum barbarian_type  barb_type 
)

This function returns a random-ish nation that is suitable for 'barb_type' and is usable (not already in use by an existing player, and if needs_startpos is set, would not be prohibited from starting on the map by the current scenario – NB this doesn't check that any start position is actually free).

Unless 'ignore_conflicts' is set, this function tries hard to avoid a nation marked as "conflicting with" one already in the game. A conflicting nation will be returned only if the alternative is to return NO_NATION_SELECTED. Such a return indicates that there are no remaining nations which match the above criteria.

If 'choices' is non-NULL, nations from the supplied list are preferred; but if there are no (non-conflicting) nations on the list that match the criteria, one will be chosen from outside the list (as if the list had not been supplied).

All other things being equal, prefers to pick a nation which returns a high score from nations_match() relative to any nations already in the game.

Definition at line 2452 of file plrhand.c.

Referenced by create_animals(), create_barbarian_player(), create_command_newcomer(), generate_players(), handle_edit_player_create(), sg_load_players(), sg_load_players(), and split_player().

◆ player_by_user_delegated()

struct player * player_by_user_delegated ( const char name)

For a given user, if there is some player that the user originally controlled but is currently delegated to another user, return that player. See also player_by_user().

Definition at line 3317 of file plrhand.c.

Referenced by establish_new_connection().

◆ player_color_changeable()

bool player_color_changeable ( const struct player pplayer,
const char **  reason 
)

Return whether a player's color can currently be set with the '/playercolor' command. If not, give a reason why not, if 'reason' is not NULL (need not be freed).

Definition at line 1716 of file plrhand.c.

Referenced by package_player_info(), and playercolor_command().

◆ player_color_ftstr()

const char * player_color_ftstr ( struct player pplayer)

Return the player color as featured text string. (In pregame, this uses the color the player will take, if known, even if not assigned yet.)

Definition at line 1842 of file plrhand.c.

Referenced by playercolor_command(), show_colors(), and show_players().

◆ player_delegation_active()

bool player_delegation_active ( const struct player pplayer)

Returns TRUE if a delegation is active. This means that either the player is controlled by a delegate, or the player has been temporarily 'put aside' by a delegate.

Definition at line 3266 of file plrhand.c.

Referenced by delegate_command(), show_delegations(), and take_command().

◆ player_delegation_get()

const char * player_delegation_get ( const struct player pplayer)

Returns the username that control of the player is delegated to, if any.

Definition at line 3237 of file plrhand.c.

Referenced by delegate_command(), establish_new_connection(), player_by_user_delegated(), send_delegation_info(), sg_save_player_main(), and show_delegations().

◆ player_delegation_set()

void player_delegation_set ( struct player pplayer,
const char username 
)

Define a delegation. NULL for no delegate.

Definition at line 3250 of file plrhand.c.

Referenced by delegate_command(), sg_load_player_main(), and sg_load_player_main().

◆ player_info_freeze()

void player_info_freeze ( void  )

Do not compute and send PACKET_PLAYER_INFO or PACKET_NATION_AVAILABILITY until a call to player_info_thaw(). This is used during savegame load or ruleset (re)load cycles, to avoid sending infos to the client that depend on ruleset data it does not yet have.

Definition at line 1101 of file plrhand.c.

Referenced by load_command(), and set_rulesetdir().

◆ player_info_thaw()

void player_info_thaw ( void  )

If the frozen level is back to 0, send all players' infos, and nation availability, to all connections.

Definition at line 1110 of file plrhand.c.

Referenced by load_command(), and set_rulesetdir().

◆ player_limit_to_max_rates()

void player_limit_to_max_rates ( struct player pplayer)

The following limits a player's rates to those that are presently acceptable. If a rate exceeds current maxrate, it adjusts rates automatically adding the extra to the 2nd highest rate, preferring science to taxes and taxes to luxuries. (It assumes that for maxrate * 3 >= 100 in any situation)

Returns actual max rate used. This function should be called after team information are defined.

Definition at line 2056 of file plrhand.c.

Referenced by check_player_max_rates(), handle_edit_player_create(), server_player_init(), sg_load_sanitycheck(), sg_load_sanitycheck(), split_player(), and srv_ready().

◆ player_loot_player()

void player_loot_player ( struct player pvictor,
struct player pvictim 
)

pvictor gets parts of treasury, map and cities of pvictim. Normally happens when pvictim's gameloss unit is killed. FIXME: Any control over types of the loot? TODO: Proper event types (likely needs a new one). For now ones related to Huts (similar loot) used.

Definition at line 411 of file plrhand.c.

Referenced by api_methods_player_lose(), and wipe_unit_full().

◆ player_preferred_color()

const struct rgbcolor * player_preferred_color ( struct player pplayer)

If a player's color will be predictable when colors are assigned (or assignment has already happened), return that color. Otherwise (if the player's color is yet to be assigned randomly), return NULL.

Definition at line 1673 of file plrhand.c.

Referenced by assign_player_colors(), package_player_info(), and player_color_ftstr().

◆ player_reply_dest()

struct conn_list * player_reply_dest ( struct player pplayer)

Convenience function to return "reply" destination connection list for player: pplayer->current_conn if set, else pplayer->connections.

Definition at line 1593 of file plrhand.c.

Referenced by handle_unit_sscs_set(), unit_move(), and unit_move_handling().

◆ player_set_to_ai_mode()

void player_set_to_ai_mode ( struct player pplayer,
enum ai_level  skill_level 
)

Toggle player to AI mode.

Definition at line 3429 of file plrhand.c.

Referenced by away_command(), and toggle_ai_player_direct().

◆ player_set_under_human_control()

void player_set_under_human_control ( struct player pplayer)

Toggle player under human control.

Definition at line 3451 of file plrhand.c.

Referenced by away_command(), and toggle_ai_player_direct().

◆ player_status_add()

void player_status_add ( struct player plr,
enum player_status  pstatus 
)

◆ player_status_check()

bool player_status_check ( struct player plr,
enum player_status  pstatus 
)

Check player status flag.

Definition at line 3220 of file plrhand.c.

Referenced by check_for_game_over(), kill_dying_players(), rank_users(), and surrender_command().

◆ player_status_reset()

void player_status_reset ( struct player plr)

Reset player status to 'normal'.

Definition at line 3228 of file plrhand.c.

Referenced by create_barbarian_player(), kill_player(), and server_player_init().

◆ player_update_last_war_action()

void player_update_last_war_action ( struct player pplayer)

Update last war action timestamp (affects player mood).

Definition at line 865 of file plrhand.c.

Referenced by action_give_casus_belli(), handle_diplomacy_cancel_pact(), unit_bombs_unit(), and unit_versus_unit().

◆ playercolor_add()

void playercolor_add ( struct rgbcolor prgbcolor)

Add a color to the list of all available player colors.

Definition at line 3360 of file plrhand.c.

Referenced by load_ruleset_game().

◆ playercolor_count()

int playercolor_count ( void  )

Number of player colors defined.

Definition at line 3380 of file plrhand.c.

Referenced by load_ruleset_game(), mapimg_server_plrcolor_count(), and player_preferred_color().

◆ playercolor_free()

void playercolor_free ( void  )

Free the memory allocated for the player color.

Definition at line 3341 of file plrhand.c.

Referenced by load_rulesetdir(), and server_game_free().

◆ playercolor_get()

struct rgbcolor * playercolor_get ( int  id)

Get the player color with the index 'id'.

Definition at line 3370 of file plrhand.c.

Referenced by mapimg_server_plrcolor_get(), and player_preferred_color().

◆ playercolor_init()

void playercolor_init ( void  )

Initialise the player colors.

Definition at line 3332 of file plrhand.c.

Referenced by load_rulesetdir(), and server_game_init().

◆ reset_all_start_commands()

void reset_all_start_commands ( bool  plrchange)

Called when something is changed; this resets everyone's readiness.

Definition at line 2723 of file plrhand.c.

Referenced by connection_detach(), create_command_pregame(), establish_new_connection(), and set_command().

◆ revolution_length()

int revolution_length ( struct government gov,
struct player plr 
)

Get length of a revolution.

Definition at line 550 of file plrhand.c.

Referenced by handle_edit_player(), and handle_player_change_government().

◆ send_delegation_info()

void send_delegation_info ( const struct connection pconn)

Send information about delegations to reconnecting users.

Definition at line 3274 of file plrhand.c.

Referenced by connection_attach_real(), and establish_new_connection().

◆ send_nation_availability()

void send_nation_availability ( struct conn_list dest,
bool  nationset_change 
)

Tell clients which nations can be picked given current server settings.

Definition at line 2641 of file plrhand.c.

Referenced by nationset_action(), and send_ruleset_nations().

◆ send_player_all_c()

void send_player_all_c ( struct player src,
struct conn_list dest 
)

Send all information about a player (player_info and all player_diplstates) to the given connections.

Send all players if src is NULL; send to all connections if dest is NULL.

This function also sends the diplstate of the player. So take care, that all players are defined in the client and in the server. To create a player without sending the diplstate, use send_player_info_c().

Definition at line 1129 of file plrhand.c.

Referenced by action_consequence_common(), begin_phase(), civil_war(), create_animals(), create_barbarian_player(), diplomat_bribe(), diplomat_get_tech(), diplomat_may_lose_gold(), end_turn(), establish_embassy(), found_new_tech(), handle_diplomacy_accept_treaty_req(), handle_diplomacy_cancel_pact(), handle_edit_player(), handle_edit_player_create(), handle_player_phase_done(), make_contact(), send_all_info(), split_player(), and update_players_after_alliance_breakup().

◆ send_player_diplstate_c()

void send_player_diplstate_c ( struct player src,
struct conn_list dest 
)

Identical to send_player_info_c(), but sends the diplstate of the player.

This function solves one problem of using an extra packet for the diplstate. It can only be send if the player exists at the destination. Thus, this function should be called after the player(s) exists on both sides of the connection.

Definition at line 1212 of file plrhand.c.

Referenced by create_command_newcomer(), load_command(), and send_player_all_c().

◆ send_player_info_c()

void send_player_info_c ( struct player src,
struct conn_list dest 
)

Send information about player slot 'src', or all valid (i.e. used and initialized) players if 'src' is NULL, to specified clients 'dest'. If 'dest' is NULL, it is treated as game.est_connections.

Note: package_player_info contains incomplete info if it has NULL as a dest arg and and info is < INFO_EMBASSY. NB: If 'src' is NULL (meaning send information about all players) this function will only send info for used players, i.e. player slots with a player defined.

Definition at line 1146 of file plrhand.c.

Referenced by aifill(), announce_player(), api_edit_change_gold(), api_edit_change_infrapoints(), api_edit_create_building(), api_edit_remove_building(), autotoggle_action(), away_command(), city_build_free_buildings(), collect_ransom(), connection_attach_real(), connection_delegate_restore(), connection_detach(), create_city_for_player(), create_command_newcomer(), create_command_pregame(), dai_manage_taxes(), detach_command(), diplomat_incite(), do_unit_establish_trade(), do_unit_upgrade(), establish_new_connection(), give_shared_vision(), government_change(), handle_edit_city(), handle_edit_unit_create(), handle_nation_select_req(), handle_player_change_government(), handle_player_multiplier(), handle_player_place_infra(), handle_player_rates(), handle_player_ready(), handle_unit_type_upgrade(), kill_player(), nationset_action(), player_info_thaw(), player_update_last_war_action(), playernation_command(), plrcol_action(), really_handle_city_buy(), really_handle_city_sell(), remove_city(), remove_obsolete_buildings_city(), remove_shared_vision(), research_tech_lost(), reset_all_start_commands(), send_player_all_c(), server_player_set_color(), set_ai_level(), set_ai_level_direct(), split_player(), spy_steal_gold(), team_command(), toggle_ai_command(), transfer_city(), unit_conquer_city(), unit_do_help_build(), unit_enter_hut(), and update_revolution().

◆ server_create_player()

struct player * server_create_player ( int  player_id,
const char ai_tname,
struct rgbcolor prgbcolor,
bool  allow_ai_type_fallbacking 
)

Creates a new, uninitialized, used player slot. You should probably call server_player_init() to initialize it, and send_player_info_c() later to tell clients about it.

May return NULL if creation was not possible.

Definition at line 1893 of file plrhand.c.

Referenced by aifill(), connection_attach_real(), create_animals(), create_barbarian_player(), create_command_newcomer(), create_command_pregame(), handle_edit_player_create(), sg_load_players_basic(), sg_load_players_basic(), and split_player().

◆ server_player_init()

void server_player_init ( struct player pplayer,
bool  initmap,
bool  needs_team 
)

Initialize ANY newly-created player on the server.

The initmap option is used because we don't want to initialize the map before the x and y sizes have been determined. This should generally be FALSE in pregame.

The needs_team options should be set for players who should be assigned a team. They will be put on their own newly-created team.

Definition at line 1618 of file plrhand.c.

Referenced by aifill(), connection_attach_real(), create_animals(), create_barbarian_player(), create_command_newcomer(), create_command_pregame(), handle_edit_player_create(), server_create_player(), sg_load_players_basic(), sg_load_players_basic(), and split_player().

◆ server_player_set_color()

void server_player_set_color ( struct player pplayer,
const struct rgbcolor prgbcolor 
)

Set the player's color. If 'prgbcolor' is not NULL the caller should free the pointer, as player_set_color() copies the data.

Definition at line 1822 of file plrhand.c.

Referenced by playercolor_command(), and plrcol_action().

◆ server_player_set_name()

void server_player_set_name ( struct player pplayer,
const char name 
)

◆ server_player_set_name_full()

bool server_player_set_name_full ( const struct connection caller,
struct player pplayer,
const struct nation_type pnation,
const char name,
char error_buf,
size_t  error_buf_len 
)

Try to set the player name to 'name'. Else, find a default name. Returns TRUE on success.

Definition at line 2167 of file plrhand.c.

Referenced by handle_edit_player(), handle_nation_select_req(), playernation_command(), and server_player_set_name().

◆ server_remove_player()

void server_remove_player ( struct player pplayer)

This function does not close any connections attached to this player. The function cut_connection() is used for that. Be sure to send_player_slot_info_c() afterwards to tell clients that the player slot has become unused.

Definition at line 1942 of file plrhand.c.

Referenced by aifill(), connection_detach(), create_command_newcomer(), handle_edit_player_remove(), remove_player_command(), server_game_free(), sg_load_players_basic(), sg_load_players_basic(), and start_command().

◆ set_shuffled_players()

void set_shuffled_players ( int shuffled_players)

Initialize the shuffled players list (as from a loaded savegame).

Definition at line 2402 of file plrhand.c.

Referenced by sg_load_players_basic(), and sg_load_players_basic().

◆ shuffle_players()

void shuffle_players ( void  )

Shuffle or reshuffle the player order, storing in static variables above.

Definition at line 2377 of file plrhand.c.

Referenced by begin_turn(), sg_load_players_basic(), sg_load_players_basic(), and srv_ready().

◆ shuffled_player()

struct player * shuffled_player ( int  i)

Returns the i'th shuffled player, or NULL.

NB: You should never need to call this function directly.

Definition at line 2420 of file plrhand.c.

◆ update_capital()

void update_capital ( struct player pplayer)

Recalculate what city is the named capital

Definition at line 731 of file plrhand.c.

Referenced by begin_phase(), and transfer_city().

◆ update_national_activities()

void update_national_activities ( struct player pplayer,
int  old_gold 
)

National level turn change activities.

Definition at line 3471 of file plrhand.c.

Referenced by end_phase().

◆ update_players_after_alliance_breakup()

void update_players_after_alliance_breakup ( struct player pplayer,
struct player pplayer2,
const struct unit_list *  pplayer_seen_units,
const struct unit_list *  pplayer2_seen_units 
)

After the alliance is breaken, we need to do two things:

  • Inform clients that they cannot see units inside the former's ally cities
  • Remove units stacked together Note that you shouldn't use the units listed in 'pplayer_seen_units' and 'pplayer2_seen_units' after calling this function because these units might have died during the process.

Definition at line 804 of file plrhand.c.

Referenced by handle_diplomacy_accept_treaty_req(), and handle_diplomacy_cancel_pact().

◆ update_revolution()

void update_revolution ( struct player pplayer)

See if the player has finished their revolution. This function should be called at the beginning of a player's phase.

Definition at line 672 of file plrhand.c.

Referenced by begin_phase().