Freeciv

Call default ai with classic ai type as parameter.

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

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

{

struct ai_type *deftype = classic_ai_get_self();

Call default ai with classic ai type as parameter.

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

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

{

struct ai_type *deftype = classic_ai_get_self();

is the treaty being considered. It is all a question about money :-)

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

void dai_treaty_evaluate(struct ai_type *ait, struct player *pplayer,

{

int total_balance = 0;

bool only_gifts = TRUE;

is the treaty accepted.

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

void dai_treaty_accepted(struct ai_type *ait, struct player *pplayer,

{

bool close_here;

struct ai_plr *ai;

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

static void clear_old_treaty(struct player *pplayer, struct player *aplayer)

{

if (old_treaty != NULL) {

/* Remove existing clauses */

#include "ai.h" /* incident_type */

struct Clause;

struct ai_data;

void dai_diplomacy_actions(struct ai_type *ait, struct player *pplayer);

void dai_treaty_evaluate(struct ai_type *ait, struct player *pplayer,

void dai_treaty_accepted(struct ai_type *ait, struct player *pplayer,

void dai_incident(struct ai_type *ait, enum incident_type type,

enum casus_belli_range scope,

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

static void texwai_treaty_evaluate(struct player *pplayer,

struct player *aplayer,

{

TEXAI_AIT;

TEXAI_DFUNC(dai_treaty_evaluate, pplayer, aplayer, ptreaty);

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

static void texwai_treaty_accepted(struct player *pplayer,

struct player *aplayer,

{

TEXAI_AIT;

TEXAI_DFUNC(dai_treaty_accepted, pplayer, aplayer, ptreaty);

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

void client_init_meeting(int counterpart, int initiated_from)

{

struct player *we;

struct player *they;

void client_recv_accept_treaty(int counterpart, bool I_accepted,

bool other_accepted)

{

struct player *we;

struct player *they;

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

void client_recv_cancel_meeting(int counterpart, int initiated_from)

{

struct player *we;

struct player *they;

void client_recv_create_clause(int counterpart, int giver,

enum clause_type type, int value)

{

struct player *we;

struct player *they;

void client_recv_remove_clause(int counterpart, int giver,

enum clause_type type, int value)

{

struct player *we;

struct player *they;

#include "plrdlg.h"

struct Diplomacy_dialog {

struct gui_dialog *dialog;

GtkWidget *menu0;

static struct dialog_list *dialog_list;

static struct Diplomacy_notebook *dipl_main;

struct player *plr0,

struct player *plr1);

static struct Diplomacy_dialog *find_diplomacy_dialog(struct player *they);

struct player *initiator);

static void diplomacy_dialog_map_callback(GtkWidget *w, gpointer data);

static void diplomacy_dialog_seamap_callback(GtkWidget *w, gpointer data);

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

Server tells us that either party has accepted treaty

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

{

struct Diplomacy_dialog *pdialog = find_diplomacy_dialog(they);

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

Someone is initiating meeting with us.

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

struct player *initiator)

{

popup_diplomacy_dialog(ptreaty, they, initiator);

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

Meeting has been cancelled.

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

struct player *initiator)

{

struct Diplomacy_dialog *pdialog = find_diplomacy_dialog(they);

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

Prepare to clause creation or removal.

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

{

/* Not needed */

}

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

Added clause to the meeting

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

{

struct Diplomacy_dialog *pdialog = find_diplomacy_dialog(they);

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

Removed clause from meeting.

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

{

struct Diplomacy_dialog *pdialog = find_diplomacy_dialog(they);

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

Popup the dialog 10% inside the main-window

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

struct player *initiator)

{

struct Diplomacy_dialog *pdialog = find_diplomacy_dialog(they);

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

Setups diplomacy dialog widgets.

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

struct player *plr0,

struct player *plr1)

{

#include "plrdlg.h"

struct Diplomacy_dialog {

struct gui_dialog *dialog;

GtkWidget *pic0;

static struct dialog_list *dialog_list;

static struct Diplomacy_notebook *dipl_main;

struct player *plr0,

struct player *plr1);

static struct Diplomacy_dialog *find_diplomacy_dialog(struct player *they);

struct player *initiator);

static void diplomacy_dialog_map_callback(GSimpleAction *action,

GVariant *parameter,

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

Server tells us that either party has accepted treaty

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

{

struct Diplomacy_dialog *pdialog = find_diplomacy_dialog(they);

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

Someone is initiating meeting with us.

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

struct player *initiator)

{

popup_diplomacy_dialog(ptreaty, they, initiator);

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

Meeting has been cancelled.

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

struct player *initiator)

{

struct Diplomacy_dialog *pdialog = find_diplomacy_dialog(they);

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

Prepare to clause creation or removal.

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

{

/* Not needed */

}

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

Added clause to the meeting

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

{

struct Diplomacy_dialog *pdialog = find_diplomacy_dialog(they);

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

Removed clause from meeting.

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

{

struct Diplomacy_dialog *pdialog = find_diplomacy_dialog(they);

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

Popup the dialog 10% inside the main-window

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

struct player *initiator)

{

struct Diplomacy_dialog *pdialog = find_diplomacy_dialog(they);

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

Setups diplomacy dialog widgets.

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

struct player *plr0,

struct player *plr1)

{

#include "plrdlg.h"

struct Diplomacy_dialog {

struct gui_dialog *dialog;

GtkWidget *pic0;

static struct dialog_list *dialog_list;

static struct Diplomacy_notebook *dipl_main;

struct player *plr0,

struct player *plr1);

static struct Diplomacy_dialog *find_diplomacy_dialog(struct player *they);

struct player *initiator);

static void diplomacy_dialog_map_callback(GSimpleAction *action,

GVariant *parameter,

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

Server tells us that either party has accepted treaty

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

{

struct Diplomacy_dialog *pdialog = find_diplomacy_dialog(they);

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

Someone is initiating meeting with us.

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

struct player *initiator)

{

popup_diplomacy_dialog(ptreaty, they, initiator);

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

Meeting has been cancelled.

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

struct player *initiator)

{

struct Diplomacy_dialog *pdialog = find_diplomacy_dialog(they);

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

Prepare to clause creation or removal.

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

{

/* Not needed */

}

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

Added clause to the meeting

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

{

struct Diplomacy_dialog *pdialog = find_diplomacy_dialog(they);

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

Removed clause from meeting.

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

{

struct Diplomacy_dialog *pdialog = find_diplomacy_dialog(they);

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

Popup the dialog 10% inside the main-window

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

struct player *initiator)

{

struct Diplomacy_dialog *pdialog = find_diplomacy_dialog(they);

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

Setups diplomacy dialog widgets.

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

struct player *plr0,

struct player *plr1)

{

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

Constructor for diplomacy widget

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

struct player *they, struct player *initiator): QWidget()

{

struct player *we;

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

Constructor for diplomacy dialog

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

struct player *initiator) : QTabWidget()

{

add_widget(ptreaty, they, initiator);

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

Creates new diplomacy widget and adds to diplomacy dialog

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

struct player *initiator)

{

diplo_wdg *dw;

Update a player's acceptance status of a treaty (traditionally shown

with the thumbs-up/thumbs-down sprite).

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

{

int i;

diplo_dlg *dd;

Handle the start of a diplomacy meeting - usually by popping up a

diplomacy dialog.

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

struct player *initiator)

{

int i;

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

Prepare to clause creation or removal.

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

{

// Not needed

}

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

Update the diplomacy dialog by adding a clause.

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

{

int i;

diplo_dlg *dd;

Update the diplomacy dialog when the meeting is canceled (the dialog

should be closed).

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

struct player *initiator)

{

int i;

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

Update the diplomacy dialog by removing a clause.

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

{

int i;

diplo_dlg *dd;

QTableWidget *text_edit;

public:

struct player *they, struct player *initiator);

~diplo_wdg();

void update_wdg();

void set_index(int ind);

int get_index();

private slots:

void all_advances();

QMap<struct player *, diplo_wdg *> treaty_list;

public:

struct player *initiator);

~diplo_dlg();

void reactivate();

bool init(bool raise);

diplo_wdg *find_widget(struct player *they);

void close_widget(struct player *they);

struct player *initiator);

void make_active(struct player *party);

char **qtg_get_gui_specific_themes_directories(int *count);

char **qtg_get_usable_themes_in_directory(const char *directory, int *count);

struct player *initiator);

struct player *initiator);

void qtg_request_action_confirmation(const char *expl,

struct act_confirmation_data *data);

#include "diplodlg.h"

struct diplomacy_dialog {

struct advanced_dialog *pdialog;

struct advanced_dialog *pwants;

struct advanced_dialog *poffers;

Update a player's acceptance status of a treaty (traditionally shown

with the thumbs-up/thumbs-down sprite).

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

{

struct diplomacy_dialog *pdialog = get_diplomacy_dialog(they);

Update the diplomacy dialog when the meeting is canceled (the dialog

should be closed).

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

struct player *initiator)

{

struct diplomacy_dialog *pdialog = get_diplomacy_dialog(they);

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

Prepare to clause creation or removal.

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

{

struct diplomacy_dialog *pdialog = get_diplomacy_dialog(they);

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

Update the diplomacy dialog by adding a clause.

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

{

struct diplomacy_dialog *pdialog = get_diplomacy_dialog(they);

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

Update the diplomacy dialog by removing a clause.

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

{

struct diplomacy_dialog *pdialog = get_diplomacy_dialog(they);

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

Open new diplomacy dialog between players.

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

struct player *plr0,

struct player *plr1)

{

Handle the start of a diplomacy meeting - usually by popping up a

diplomacy dialog.

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

struct player *initiator)

{

struct diplomacy_dialog *pdialog;

#include "diplodlg.h"

struct diplomacy_dialog {

struct advanced_dialog *pdialog;

struct advanced_dialog *pwants;

struct advanced_dialog *poffers;

Update a player's acceptance status of a treaty (traditionally shown

with the thumbs-up/thumbs-down sprite).

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

{

struct diplomacy_dialog *pdialog = get_diplomacy_dialog(they);

Update the diplomacy dialog when the meeting is canceled (the dialog

should be closed).

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

struct player *initiator)

{

struct diplomacy_dialog *pdialog = get_diplomacy_dialog(they);

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

Prepare to clause creation or removal.

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

{

struct diplomacy_dialog *pdialog = get_diplomacy_dialog(they);

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

Update the diplomacy dialog by adding a clause.

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

{

struct diplomacy_dialog *pdialog = get_diplomacy_dialog(they);

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

Update the diplomacy dialog by removing a clause.

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

{

struct diplomacy_dialog *pdialog = get_diplomacy_dialog(they);

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

Open new diplomacy dialog between players.

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

struct player *plr0,

struct player *plr1)

{

Handle the start of a diplomacy meeting - usually by popping up a

diplomacy dialog.

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

struct player *initiator)

{

struct diplomacy_dialog *pdialog;

Update a player's acceptance status of a treaty (traditionally shown

with the thumbs-up/thumbs-down sprite).

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

{

/* PORTME */

}

Handle the start of a diplomacy meeting - usually by popping up a

diplomacy dialog.

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

struct player *initiator)

{

/* PORTME */

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

Update the diplomacy dialog by adding a clause.

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

{

/* PORTME */

}

Update the diplomacy dialog when the meeting is canceled (the dialog

should be closed).

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

struct player *initiator)

{

/* PORTME */

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

Update the diplomacy dialog by removing a clause.

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

{

/* PORTME */

}

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

Prepare to clause creation or removal.

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

{

/* PORTME */

}

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

Call gui_init_meeting callback

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

struct player *initiator)

{

funcs.gui_init_meeting(ptreaty, they, initiator);

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

Call gui_recv_cancel_meeting callback

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

struct player *initiator)

{

funcs.gui_recv_cancel_meeting(ptreaty, they, initiator);

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

Call gui_prepare_clause_updt callback

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

{

funcs.gui_prepare_clause_updt(ptreaty, they);

}

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

Call gui_recv_create_clause callback

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

{

funcs.gui_recv_create_clause(ptreaty, they);

}

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

Call gui_recv_remove_clause callback

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

{

funcs.gui_recv_remove_clause(ptreaty, they);

}

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

Call gui_recv_accept_treaty callback

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

{

funcs.gui_recv_accept_treaty(ptreaty, they);

}

char **(*get_gui_specific_themes_directories)(int *count);

char **(*get_usable_themes_in_directory)(const char *directory, int *count);

struct player *initiator);

struct player *initiator);

void (*request_action_confirmation)(const char *expl,

struct act_confirmation_data *data);

#include "gui_proto_constructor.h"

GUI_FUNC_PROTO(void, gui_init_meeting,

struct player *initiator)

GUI_FUNC_PROTO(void, gui_recv_cancel_meeting,

struct player *initiator)

GUI_FUNC_PROTO(void, gui_prepare_clause_updt,

GUI_FUNC_PROTO(void, gui_recv_create_clause,

GUI_FUNC_PROTO(void, gui_recv_remove_clause,

struct player *they)

GUI_FUNC_PROTO(void, close_all_diplomacy_dialogs, void)

# undef DEBUG_AITIMERS

#endif /* FREECIV_DEBUG */

struct player;

struct adv_choice;

struct city;

/* Called for player AI type when diplomatic treaty requires evaluation. */

void (*treaty_evaluate)(struct player *pplayer, struct player *aplayer,

/* Called for player AI type when diplomatic treaty has been accepted

* by both parties. */

void (*treaty_accepted)(struct player *pplayer, struct player *aplayer,

/* Called for player AI type when first contact with another player has been

* established. Note that when contact is between two AI players, callback

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

Initialize treaty structure between two players.

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

struct player *plr0, struct player *plr1)

{

ptreaty->accept0 = FALSE;

ptreaty->accept1 = FALSE;

ptreaty->clauses = clause_list_new();

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

Free the clauses of a treaty.

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

{

clause_list_iterate(ptreaty->clauses, pclause) {

free(pclause);

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

Remove clause from treaty

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

enum clause_type type, int val)

{

clause_list_iterate(ptreaty->clauses, pclause) {

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

Add clause to treaty.

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

enum clause_type type, int val,

struct player *client_player)

{

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

Find currently active treaty between two players.

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

{

treaty_list_iterate(treaties, ptreaty) {

if ((ptreaty->plr0 == plr0 && ptreaty->plr1 == plr1)

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

Add treaty to the global list.

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

{

treaty_list_prepend(treaties, ptreaty);

}

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

Remove treaty from the global list.

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

{

treaty_list_remove(treaties, ptreaty);

int value;

};

struct player *plr0, *plr1;

bool accept0, accept1;

struct clause_list *clauses;

bool could_intel_with_player(const struct player *pplayer,

const struct player *aplayer);

struct player *plr0, struct player *plr1);

enum clause_type type, int val,

struct player *client_player);

enum clause_type type, int val);

void clause_infos_init(void);

void clause_infos_free(void);

bool clause_enabled(enum clause_type type);

#define SPECLIST_TAG treaty

#include "speclist.h"

#define treaty_list_iterate(list, p) \

#define treaty_list_iterate_end LIST_ITERATE_END

void treaties_init(void);

void treaties_free(void);

void free_treaties(void);

void treaties_iterate(treaty_cb cb, void *data);

#ifdef __cplusplus

Diplomacy

=========================================================================

A few words about the diplomacy system. When a diplomacy meeting is

on the server. All these structures are updated concurrently as clauses

are added and removed.

Calls treaty_evaluate function if such is set for AI player.

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

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

{

if (is_ai(pplayer)) {

CALL_PLR_AI_FUNC(treaty_evaluate, pplayer, pplayer, aplayer, ptreaty);

Calls treaty_accepted function if such is set for AI player.

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

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

{

if (is_ai(pplayer)) {

CALL_PLR_AI_FUNC(treaty_accepted, pplayer, pplayer, aplayer, ptreaty);

agreed clauses.

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

void handle_diplomacy_accept_treaty_req(struct player *pplayer,

{

bool *player_accept, *other_accept;

enum dipl_reason diplcheck;

bool worker_refresh_required = FALSE;

Handle request to remove clause from treaty.

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

void handle_diplomacy_remove_clause_req(struct player *pplayer,

{

struct player *pgiver = player_by_number(giver);

struct player *pother = player_by_number(counterpart);

Handle request to add clause to treaty between two players.

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

void handle_diplomacy_create_clause_req(struct player *pplayer,

{

struct player *pgiver = player_by_number(giver);

struct player *pother = player_by_number(counterpart);

this with input directly from untrusted source.

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

static void really_diplomacy_cancel_meeting(struct player *pplayer,

{

if (ptreaty) {

dlsend_packet_diplomacy_cancel_meeting(pother->connections,

Handle meeting opening request.

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

void handle_diplomacy_init_meeting_req(struct player *pplayer,

{

struct player *pother = player_by_number(counterpart);

}

if (could_meet_with_player(pplayer, pother)) {

ptreaty = fc_malloc(sizeof(*ptreaty));

init_treaty(ptreaty, pplayer, pother);

return;

}

players_iterate(other) {

if (ptreaty) {

fc_assert_action(pplayer != other, continue);

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

void reject_all_treaties(struct player *pplayer)

{

players_iterate(pplayer2) {

treaty = find_treaty(pplayer, pplayer2);

continue;

}

treaty->accept0 = FALSE;

/* server */

#include <hand_gen.h> /* <> so looked from the build directory first. */

struct packet_diplomacy_info;

struct connection;

if (p0 == NULL || p1 == NULL) {

log_error("Treaty between unknown players %s and %s", plr0, plr1);

} else {

init_treaty(ptreaty, p0, p1);

treaty_add(ptreaty);

if (p0 == NULL || p1 == NULL) {

log_error("Treaty between unknown players %s and %s", plr0, plr1);

} else {

init_treaty(ptreaty, p0, p1);

treaty_add(ptreaty);

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

Save '[treaty_xxx]'.

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

{

char tpath[512];

int cidx = 0;