/*
* Retrieve cave table information for the given cave id.
*/
void get_cave_info (db_t *database, int cave_id, struct Cave *cave)
{
db_result_t *result = db_query(database,
"SELECT * FROM " DB_TABLE_CAVE " WHERE caveID = %d", cave_id);
if (!db_result_next_row(result))
throwf(SQL_EXCEPTION, "get_cave_info: cave %d not found", cave_id);
cave->result = result;
cave->cave_id = cave_id;
cave->xpos = db_result_get_int(result, "xCoord");
cave->ypos = db_result_get_int(result, "yCoord");
cave->name = db_result_get_string(result, "name");
cave->player_id = db_result_get_int(result, "playerID");
cave->terrain = db_result_get_int(result, "terrain");
cave->takeoverable = db_result_get_int(result, "takeoverable");
cave->artefacts = db_result_get_int(result, "artefacts");
cave->heroID = db_result_get_int(result, "hero");
cave->monster_id = db_result_get_int(result, "monsterID");
cave->secure = db_result_get_int(result, "secureCave");
cave->protect_end = db_result_get_time(result, "protection_end");
get_resource_list(result, cave->resource);
get_building_list(result, cave->building);
get_science_list(result, cave->science);
get_defense_system_list(result, cave->defense_system);
get_unit_list(result, cave->unit);
get_effect_list(result, cave->effect);
}
static void
bom_do_export (HID_Attr_Val * options)
{
int i;
if (!options)
{
bom_get_export_options (0);
for (i = 0; i < NUM_OPTIONS; i++)
bom_values[i] = bom_options[i].default_val;
options = bom_values;
}
bom_filename = options[HA_bomfile].str_value;
if (!bom_filename)
bom_filename = "pcb-out.bom";
xy_filename = options[HA_xyfile].str_value;
if (!xy_filename)
xy_filename = "pcb-out.xy";
if (options[HA_xymm].int_value)
xy_unit = get_unit_struct ("mm");
else
xy_unit = &get_unit_list ()[options[HA_unit].int_value];
PrintBOM ();
}
static void
print_defaults_1 (HID_Attribute * a, void *value)
{
int i;
Coord c;
double d;
const char *s;
/* Remember, at this point we've parsed the command line, so they
may be in the global variable instead of the default_val. */
switch (a->type)
{
case HID_Integer:
i = value ? *(int *) value : a->default_val.int_value;
fprintf (stderr, "%s %d\n", a->name, i);
break;
case HID_Boolean:
i = value ? *(char *) value : a->default_val.int_value;
fprintf (stderr, "%s %s\n", a->name, i ? "yes" : "no");
break;
case HID_Real:
d = value ? *(double *) value : a->default_val.real_value;
fprintf (stderr, "%s %g\n", a->name, d);
break;
case HID_Coord:
c = value ? *(Coord *) value : a->default_val.coord_value;
pcb_fprintf (stderr, "%s %$mS\n", a->name, c);
break;
case HID_String:
case HID_Path:
s = value ? *(char **) value : a->default_val.str_value;
fprintf (stderr, "%s \"%s\"\n", a->name, s);
break;
case HID_Enum:
i = value ? *(int *) value : a->default_val.int_value;
fprintf (stderr, "%s %s\n", a->name, a->enumerations[i]);
break;
case HID_Mixed:
i = value ?
((HID_Attr_Val*)value)->int_value : a->default_val.int_value;
d = value ?
((HID_Attr_Val*)value)->real_value : a->default_val.real_value;
fprintf (stderr, "%s %g%s\n", a->name, d, a->enumerations[i]);
break;
case HID_Label:
break;
case HID_Unit:
i = value ? *(int *) value : a->default_val.int_value;
fprintf (stderr, "%s %s\n", a->name, get_unit_list()[i].suffix);
}
}
int
ghid_attribute_dialog (HID_Attribute * attrs,
int n_attrs, HID_Attr_Val * results,
const char * title,
const char * descr)
{
GtkWidget *dialog;
GtkWidget *content_area;
GtkWidget *main_vbox, *vbox, *vbox1, *hbox, *entry;
GtkWidget *combo;
GtkWidget *widget;
GHidPort *out = &ghid_port;
int i, j, n;
int rc = 0;
dialog = gtk_dialog_new_with_buttons (_(title),
GTK_WINDOW (out->top_window),
(GtkDialogFlags)(GTK_DIALOG_MODAL
| GTK_DIALOG_DESTROY_WITH_PARENT),
GTK_STOCK_CANCEL, GTK_RESPONSE_NONE,
GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
gtk_window_set_wmclass (GTK_WINDOW (dialog), "PCB_attribute_editor", "PCB");
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
main_vbox = gtk_vbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 6);
gtk_container_add (GTK_CONTAINER (content_area), main_vbox);
vbox = ghid_category_vbox (main_vbox, descr != NULL ? descr : "",
4, 2, TRUE, TRUE);
/*
* Iterate over all the export options and build up a dialog box
* that lets us control all of the options. By doing things this
* way, any changes to the exporter HID's automatically are
* reflected in this dialog box.
*/
for (j = 0; j < n_attrs; j++)
{
const Unit *unit_list;
if (attrs[j].help_text == ATTR_UNDOCUMENTED)
continue;
switch (attrs[j].type)
{
case HID_Label:
widget = gtk_label_new (attrs[j].name);
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
gtk_widget_set_tooltip_text (widget, attrs[j].help_text);
break;
case HID_Integer:
hbox = gtk_hbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
/*
* FIXME
* need to pick the "digits" argument based on min/max
* values
*/
ghid_spin_button (hbox, &widget, attrs[j].default_val.int_value,
attrs[j].min_val, attrs[j].max_val, 1.0, 1.0, 0, 0,
intspinner_changed_cb,
&(attrs[j].default_val.int_value), FALSE, NULL);
gtk_widget_set_tooltip_text (widget, attrs[j].help_text);
widget = gtk_label_new (attrs[j].name);
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
break;
case HID_Coord:
hbox = gtk_hbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
entry = ghid_coord_entry_new (attrs[j].min_val, attrs[j].max_val,
attrs[j].default_val.coord_value,
Settings.grid_unit, CE_SMALL);
gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, FALSE, 0);
if(attrs[j].default_val.str_value != NULL)
gtk_entry_set_text (GTK_ENTRY (entry),
attrs[j].default_val.str_value);
gtk_widget_set_tooltip_text (entry, attrs[j].help_text);
g_signal_connect (G_OBJECT (entry), "changed",
G_CALLBACK (coordentry_changed_cb),
&(attrs[j].default_val.coord_value));
widget = gtk_label_new (attrs[j].name);
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
break;
case HID_Real:
hbox = gtk_hbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
/*
* FIXME
* need to pick the "digits" and step size argument more
* intelligently
*/
ghid_spin_button (hbox, &widget, attrs[j].default_val.real_value,
attrs[j].min_val, attrs[j].max_val, 0.01, 0.01, 3,
0,
dblspinner_changed_cb,
&(attrs[j].default_val.real_value), FALSE, NULL);
gtk_widget_set_tooltip_text (widget, attrs[j].help_text);
widget = gtk_label_new (attrs[j].name);
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
break;
case HID_String:
hbox = gtk_hbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, FALSE, 0);
if(attrs[j].default_val.str_value != NULL)
gtk_entry_set_text (GTK_ENTRY (entry),
attrs[j].default_val.str_value);
gtk_widget_set_tooltip_text (entry, attrs[j].help_text);
g_signal_connect (G_OBJECT (entry), "changed",
G_CALLBACK (entry_changed_cb),
&(attrs[j].default_val.str_value));
widget = gtk_label_new (attrs[j].name);
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
break;
case HID_Boolean:
/* put this in a check button */
ghid_check_button_connected (vbox, &widget,
attrs[j].default_val.int_value,
TRUE, FALSE, FALSE, 0, set_flag_cb,
&(attrs[j].default_val.int_value),
attrs[j].name);
gtk_widget_set_tooltip_text (widget, attrs[j].help_text);
break;
case HID_Enum:
hbox = gtk_hbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
do_enum:
combo = gtk_combo_box_new_text ();
gtk_widget_set_tooltip_text (combo, attrs[j].help_text);
gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (combo), "changed",
G_CALLBACK (enum_changed_cb),
&(attrs[j].default_val.int_value));
/*
* Iterate through each value and add them to the
* combo box
*/
i = 0;
while (attrs[j].enumerations[i])
{
gtk_combo_box_append_text (GTK_COMBO_BOX (combo),
attrs[j].enumerations[i]);
i++;
}
gtk_combo_box_set_active (GTK_COMBO_BOX (combo),
attrs[j].default_val.int_value);
widget = gtk_label_new (attrs[j].name);
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
break;
case HID_Mixed:
hbox = gtk_hbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
/*
* FIXME
* need to pick the "digits" and step size argument more
* intelligently
*/
ghid_spin_button (hbox, &widget, attrs[j].default_val.real_value,
attrs[j].min_val, attrs[j].max_val, 0.01, 0.01, 3,
0,
dblspinner_changed_cb,
&(attrs[j].default_val.real_value), FALSE, NULL);
gtk_widget_set_tooltip_text (widget, attrs[j].help_text);
goto do_enum;
break;
case HID_Path:
vbox1 = ghid_category_vbox (vbox, attrs[j].name, 4, 2, TRUE, TRUE);
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (vbox1), entry, FALSE, FALSE, 0);
gtk_entry_set_text (GTK_ENTRY (entry),
attrs[j].default_val.str_value);
g_signal_connect (G_OBJECT (entry), "changed",
G_CALLBACK (entry_changed_cb),
&(attrs[j].default_val.str_value));
gtk_widget_set_tooltip_text (entry, attrs[j].help_text);
break;
case HID_Unit:
unit_list = get_unit_list ();
n = get_n_units ();
hbox = gtk_hbox_new (FALSE, 4);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
combo = gtk_combo_box_new_text ();
gtk_widget_set_tooltip_text (combo, attrs[j].help_text);
gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (combo), "changed",
G_CALLBACK (enum_changed_cb),
&(attrs[j].default_val.int_value));
/*
* Iterate through each value and add them to the
* combo box
*/
for (i = 0; i < n; ++i)
gtk_combo_box_append_text (GTK_COMBO_BOX (combo),
unit_list[i].in_suffix);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo),
attrs[j].default_val.int_value);
widget = gtk_label_new (attrs[j].name);
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
break;
default:
printf ("%s: unknown type of HID attribute\n", __FUNCTION__);
break;
}
}
gtk_widget_show_all (dialog);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
{
/* copy over the results */
for (i = 0; i < n_attrs; i++)
{
results[i] = attrs[i].default_val;
if (results[i].str_value)
results[i].str_value = strdup (results[i].str_value);
}
rc = 0;
}
else
rc = 1;
gtk_widget_destroy (dialog);
return rc;
}
static void
usage_attr (HID_Attribute * a)
{
int i, n;
const Unit *unit_list;
static char buf[200];
if (a->help_text == ATTR_UNDOCUMENTED)
return;
switch (a->type)
{
case HID_Label:
return;
case HID_Integer:
case HID_Real:
sprintf (buf, "--%s <num>", a->name);
break;
case HID_Coord:
sprintf (buf, "--%s <measure>", a->name);
break;
case HID_String:
sprintf (buf, "--%s <string>", a->name);
break;
case HID_Boolean:
sprintf (buf, "--%s", a->name);
break;
case HID_Mixed:
case HID_Enum:
sprintf (buf, "--%s ", a->name);
if (a->type == HID_Mixed)
strcat (buf, " <val>");
for (i = 0; a->enumerations[i]; i++)
{
strcat (buf, i ? "|" : "<");
strcat (buf, a->enumerations[i]);
}
strcat (buf, ">");
break;
case HID_Path:
sprintf (buf, "--%s <path>", a->name);
break;
case HID_Unit:
unit_list = get_unit_list ();
n = get_n_units ();
sprintf (buf, "--%s ", a->name);
for (i = 0; i < n; i++)
{
strcat (buf, i ? "|" : "<");
strcat (buf, unit_list[i].suffix);
}
strcat (buf, ">");
break;
}
if (strlen (buf) <= 30)
{
if (a->help_text)
fprintf (stderr, " %-30s\t%s\n", buf, a->help_text);
else
fprintf (stderr, " %-30s\n", buf);
}
else if (a->help_text && strlen (a->help_text) + strlen (buf) < 72)
fprintf (stderr, " %s\t%s\n", buf, a->help_text);
else if (a->help_text)
fprintf (stderr, " %s\n\t\t\t%s\n", buf, a->help_text);
else
fprintf (stderr, " %s\n", buf);
}
/*
* This function is responsible for all the movement.
*
* @params database the function needs this link to the DB
* @params result current movement event (from DB)
*/
void movement_handler (db_t *database, db_result_t *result)
{
int movementID;
int target_caveID;
int source_caveID;
const char *speed_factor;
time_t event_start;
time_t event_end;
const char *return_start;
char return_end[TIMESTAMP_LEN];
struct Cave cave1;
struct Cave cave2;
struct Player player1;
struct Player player2;
struct Relation relation1;
struct Relation relation2;
int i;
int units[MAX_UNIT];
int resources[MAX_RESOURCE];
int takeover_multiplier;
int change_owner;
int isFarming = 0;
Battle *battle;
dstring_t *ds;
double spy_result;
/* time related issues */
const float *battle_bonus;
/* artefacts */
int artefact = 0;
int artefact_def = 0;
int artefact_id = 0;
int lostTo = 0;
int body_count = 0;
int attacker_lose = 0;
int defender_lose = 0;
int defender_va_lose = 0;
int war_points_attacker = 0;
int war_points_defender = 0;
int war_points_sender = 0;
int war_points_show = 0;
int takeover = 0;
debug(DEBUG_TICKER, "entering function movement_handler()");
/* get movement id and target/source cave id */
movementID = db_result_get_int(result, "movementID");
target_caveID = db_result_get_int(result, "target_caveID");
source_caveID = db_result_get_int(result, "source_caveID");
speed_factor = db_result_get_string(result, "speedFactor");
/* get event_start and event_end */
event_start = db_result_get_gmtime(result, "start");
return_start = db_result_get_string(result, "end");
event_end = make_time_gm(return_start);
make_timestamp_gm(return_end, event_end + (event_end - event_start));
/* get resources, units and artefact id */
get_resource_list(result, resources);
get_unit_list(result, units);
artefact = db_result_get_int(result, "artefactID");
/* TODO reduce number of queries */
get_cave_info(database, source_caveID, &cave1);
get_cave_info(database, target_caveID, &cave2);
if (cave1.player_id)
get_player_info(database, cave1.player_id, &player1);
else{ /* System */
memset(&player1, 0, sizeof player1);
player1.tribe = "";
}
if (cave2.player_id == cave1.player_id)
player2 = player1;
else if (cave2.player_id)
get_player_info(database, cave2.player_id, &player2);
else{ /* System */
memset(&player2, 0, sizeof player2);
player2.tribe = "";
}
debug(DEBUG_TICKER, "caveID = %d, movementID = %d",
target_caveID, movementID);
/**********************************************************************/
/*** THE INFAMOUS GIANT SWITCH ****************************************/
/**********************************************************************/
switch (movementID) {
/**********************************************************************/
/*** ROHSTOFFE BRINGEN ************************************************/
/**********************************************************************/
case ROHSTOFFE_BRINGEN:
/* record in takeover table */
ds = dstring_new("UPDATE " DB_TABLE_CAVE_TAKEOVER " SET ");
for (i = 0; i < MAX_RESOURCE; ++i)
dstring_append(ds, "%s%s = %s + %d", i > 0 ? "," : "",
resource_type[i]->dbFieldName,
resource_type[i]->dbFieldName, resources[i]);
dstring_append(ds, " WHERE caveID = %d AND playerID = %d",
target_caveID, cave1.player_id);
db_query_dstring(database, ds);
if(db_affected_rows(database)!=0){
takeover=1;
}
/* put resources into cave */
dstring_set(ds, "UPDATE " DB_TABLE_CAVE " SET ");
for (i = 0; i < MAX_RESOURCE; ++i)
dstring_append(ds, "%s%s = LEAST(%s + %d, %s)", i > 0 ? "," : "",
resource_type[i]->dbFieldName,
resource_type[i]->dbFieldName,
(takeover==1)?resources[i] * TAKEOVER_RESOURCE_SAVE_PERCENTAGE / 100:resources[i],
function_to_sql(resource_type[i]->maxLevel));
dstring_append(ds, " WHERE caveID = %d", target_caveID);
db_query_dstring(database, ds);
if (artefact > 0)
put_artefact_into_cave(database, artefact, target_caveID);
/* send all units back */
dstring_set(ds, "INSERT INTO Event_movement"
" (caveID, target_caveID, source_caveID, movementID,"
" speedFactor, start, end");
for (i = 0; i < MAX_UNIT; ++i)
dstring_append(ds, ",%s", unit_type[i]->dbFieldName);
dstring_append(ds, ") VALUES (%d, %d, %d, %d, %s, '%s', '%s'",
source_caveID, source_caveID, target_caveID, RUECKKEHR,
speed_factor, return_start, return_end);
for (i = 0; i < MAX_UNIT; ++i)
dstring_append(ds, ",%d", units[i]);
dstring_append(ds, ")");
db_query_dstring(database, ds);
/* generate trade report and receipt for sender */
trade_report(database, &cave1, &player1, &cave2, &player2,
resources, NULL, artefact);
break;
/**********************************************************************/
/*** EINHEITEN/ROHSTOFFE VERSCHIEBEN **********************************/
/**********************************************************************/
case VERSCHIEBEN:
get_relation_info(database, player1.tribe, player2.tribe, &relation1);
/*überprüfen ob sender und versender eine kriegsbeziehung haben */
if(!(isVerschiebenAllowed(database, &player1, &player2, &relation1) ||
isTakeoverableCave(database, target_caveID))){
//bewegung umdrehen//
/* send remaining units back */
ds = dstring_new("INSERT INTO Event_movement"
" (caveID, target_caveID, source_caveID, movementID,"
" speedFactor, start, end, artefactID");
for (i = 0; i < MAX_RESOURCE; ++i)
dstring_append(ds, ",%s", resource_type[i]->dbFieldName);
for (i = 0; i < MAX_UNIT; ++i)
dstring_append(ds, ",%s", unit_type[i]->dbFieldName);
dstring_append(ds, ") VALUES (%d, %d, %d, %d, %s, '%s', '%s', %d",
source_caveID, source_caveID, target_caveID, RUECKKEHR,
speed_factor, return_start, return_end, artefact);
for (i = 0; i < MAX_RESOURCE; ++i)
dstring_append(ds, ",%d", resources[i]);
for (i = 0; i < MAX_UNIT; ++i)
dstring_append(ds, ",%d", units[i]);
dstring_append(ds, ")");
db_query_dstring(database, ds);
break;
}
/* record in takeover table */
ds = dstring_new("UPDATE " DB_TABLE_CAVE_TAKEOVER " SET ");
for (i = 0; i < MAX_RESOURCE; ++i)
dstring_append(ds, "%s%s = %s + %d", i > 0 ? "," : "",
resource_type[i]->dbFieldName,
resource_type[i]->dbFieldName, resources[i]);
dstring_append(ds, " WHERE caveID = %d AND playerID = %d",
target_caveID, cave1.player_id);
db_query_dstring(database, ds);
if(db_affected_rows(database)!=0){
takeover=1;
}
/* put resources and units into cave */
dstring_set(ds, "UPDATE " DB_TABLE_CAVE " SET ");
for (i = 0; i < MAX_RESOURCE; ++i)
dstring_append(ds, "%s%s = LEAST(%s + %d, %s)", i > 0 ? "," : "",
resource_type[i]->dbFieldName,
resource_type[i]->dbFieldName,
(takeover==1)?resources[i] * TAKEOVER_RESOURCE_SAVE_PERCENTAGE / 100:resources[i],
function_to_sql(resource_type[i]->maxLevel));
for (i = 0; i < MAX_UNIT; ++i){
war_points_sender += ((struct Unit *)unit_type[i])->warpoints * units[i];
dstring_append(ds, ",%s = %s + %d",
unit_type[i]->dbFieldName,
unit_type[i]->dbFieldName, units[i]);
}
if(relation1.relationType == RELATION_TYPE_PRE_WAR || relation1.relationType == RELATION_TYPE_WAR){
war_points_update_verschieben(database, player1.tribe, player2.tribe, -1* war_points_sender);
}
dstring_append(ds, " WHERE caveID = %d", target_caveID);
db_query_dstring(database, ds);
if (artefact > 0)
put_artefact_into_cave(database, artefact, target_caveID);
/* generate trade report and receipt for sender */
trade_report(database, &cave1, &player1, &cave2, &player2,
resources, units, artefact);
break;
/**********************************************************************/
/*** RUECKKEHR ********************************************************/
/**********************************************************************/
case RUECKKEHR:
/* put resources into cave */
ds = dstring_new("UPDATE " DB_TABLE_CAVE " SET ");
for (i = 0; i < MAX_RESOURCE; ++i)
dstring_append(ds, "%s%s = LEAST(%s + %d, %s)", i > 0 ? "," : "",
resource_type[i]->dbFieldName,
resource_type[i]->dbFieldName, resources[i],
function_to_sql(resource_type[i]->maxLevel));
for (i = 0; i < MAX_UNIT; ++i)
dstring_append(ds, ",%s = %s + %d",
unit_type[i]->dbFieldName,
unit_type[i]->dbFieldName, units[i]);
dstring_append(ds, " WHERE caveID = %d", target_caveID);
db_query_dstring(database, ds);
if (artefact > 0)
put_artefact_into_cave(database, artefact, target_caveID);
/* generate return report */
return_report(database, &cave1, &player1, &cave2, &player2,
resources, units, artefact);
break;
/**********************************************************************/
/*** ANGREIFEN ********************************************************/
/**********************************************************************/
case ANGREIFEN:
/* beginner protection active in target cave? */
if (cave_is_protected(&cave2))
{
debug(DEBUG_BATTLE, "Is protected Cave");
/* send remaining units back */
ds = dstring_new("INSERT INTO Event_movement"
" (caveID, target_caveID, source_caveID, movementID,"
" speedFactor, start, end, artefactID");
for (i = 0; i < MAX_RESOURCE; ++i)
dstring_append(ds, ",%s", resource_type[i]->dbFieldName);
for (i = 0; i < MAX_UNIT; ++i)
dstring_append(ds, ",%s", unit_type[i]->dbFieldName);
dstring_append(ds, ") VALUES (%d, %d, %d, %d, %s, '%s', '%s', %d",
source_caveID, source_caveID, target_caveID, RUECKKEHR,
speed_factor, return_start, return_end, artefact);
for (i = 0; i < MAX_RESOURCE; ++i)
dstring_append(ds, ",%d", resources[i]);
for (i = 0; i < MAX_UNIT; ++i)
dstring_append(ds, ",%d", units[i]);
dstring_append(ds, ")");
db_query_dstring(database, ds);
debug(DEBUG_BATTLE,"End Handle Protected Cave attack");
/* create and send reports */
protected_report(database, &cave1, &player1, &cave2, &player2);
break;
}
/* get relations between the two players' tribes */
get_relation_info(database, player1.tribe, player2.tribe, &relation1);
get_relation_info(database, player2.tribe, player1.tribe, &relation2);
debug(DEBUG_BATTLE, "Relationtypes: %d and %d", relation1.relationType,
relation2.relationType);
battle = battle_create(1, 1);
battle_bonus = get_battle_bonus();
debug(DEBUG_BATTLE, "entering prepare_battle");
/* prepare structs for battle, exceptions are uncaught! */
prepare_battle(database,
battle,
&player1,
&player2,
&cave1, &cave2, battle_bonus, 0,
units, resources,
&artefact, &artefact_def,
&relation1, &relation2);
/* calculate the fame */
/* Calculatin is diferent if the battle was just pure farming*/
isFarming = check_farming(database, cave2.artefacts, &player1,
&player2, &relation1);
if( relation1.relationType == RELATION_TYPE_WAR){
battle->isWar = 1;
}
/* calculate battle result */
calcBattleResult(battle, &cave2, 0);
/* change artefact ownership */
debug(DEBUG_BATTLE, "entering change artefact");
after_battle_change_artefact_ownership(
database, battle->winner, &artefact, &artefact_id, &artefact_def,
target_caveID, &cave2, &lostTo);
/* attackers artefact (if any) is stored in variable artefact,
artefact_id is id of the artefact that changed owner (or 0) */
/* no relation -> attacker get negative fame*/
debug(DEBUG_BATTLE, "Relation Type %d",relation1.relationType);
/* construct attacker update */
debug(DEBUG_BATTLE, "entering attacker update");
after_battle_attacker_update(database, player1.player_id, battle,
source_caveID, target_caveID, speed_factor,
return_start, return_end, artefact,
&relation1);
/* defender update: exception still uncaught (better leave) */
debug(DEBUG_BATTLE, "entering defender update");
after_battle_defender_update(database, player2.player_id,
battle, target_caveID, &relation2);
/* Farming update */
if(isFarming){
increaseFarming(database, player1.player_id);
}
/* reset DB_TABLE_CAVE_TAKEOVER */
ds = dstring_new("UPDATE " DB_TABLE_CAVE_TAKEOVER " SET status = 0");
for (i = 0; i < MAX_RESOURCE; ++i)
dstring_append(ds, ",%s = 0", resource_type[i]->dbFieldName);
dstring_append(ds, " WHERE caveID = %d AND playerID = %d",
target_caveID, cave1.player_id);
db_query_dstring(database, ds);
/* cave takeover by battle */
if (battle->winner == FLAG_ATTACKER &&
((struct Terrain *)terrain_type[cave2.terrain])->takeoverByCombat) {
db_query(database, "UPDATE " DB_TABLE_CAVE " SET playerID = %d"
" WHERE caveID = %d",
cave1.player_id, target_caveID);
db_query(database, "DELETE FROM Event_science WHERE caveID = %d",
target_caveID);
science_update_caves(database, cave1.player_id);
}
//bodycount calculate
attacker_lose = bodycount_calculate(battle, FLAG_DEFENDER);
defender_lose = bodycount_calculate(battle, FLAG_ATTACKER);
defender_va_lose = bodycount_va_calculate(battle);
bodycount_update( database, player1.player_id, defender_lose);
bodycount_update( database, player2.player_id, attacker_lose);
if(relation1.relationType == RELATION_TYPE_PRE_WAR || relation1.relationType == RELATION_TYPE_WAR){
war_points_show = 1;
war_points_attacker = (defender_lose>10||defender_va_lose>5?war_points_calculate(battle,FLAG_ATTACKER):0);
war_points_defender = (attacker_lose>10?war_points_calculate(battle,FLAG_DEFENDER):0);
war_points_update(database, player1.tribe, player2.tribe, war_points_attacker, war_points_defender);
}
/* create and send reports */
battle_report(database, &cave1, &player1, &cave2, &player2, battle,
artefact_id, lostTo, 0, 0, &relation1, &relation2,
war_points_show, war_points_attacker, war_points_defender);
break;
/**********************************************************************/
/*** Spionieren *******************************************************/
/**********************************************************************/
case SPIONAGE:
/* generate spy report */
spy_result = spy_report(database, &cave1, &player1, &cave2, &player2,
resources, units, artefact);
if (spy_result == 1)
{
/* send all units back */
ds = dstring_new("INSERT INTO Event_movement"
" (caveID, target_caveID, source_caveID, movementID,"
" speedFactor, start, end, artefactID");
for (i = 0; i < MAX_RESOURCE; ++i)
dstring_append(ds, ",%s", resource_type[i]->dbFieldName);
for (i = 0; i < MAX_UNIT; ++i)
dstring_append(ds, ",%s", unit_type[i]->dbFieldName);
dstring_append(ds, ") VALUES (%d, %d, %d, %d, %s, '%s', '%s', %d",
source_caveID, source_caveID, target_caveID, RUECKKEHR,
speed_factor, return_start, return_end, artefact);
for (i = 0; i < MAX_RESOURCE; ++i)
dstring_append(ds, ",%d", resources[i]);
for (i = 0; i < MAX_UNIT; ++i)
dstring_append(ds, ",%d", units[i]);
dstring_append(ds, ")");
db_query_dstring(database, ds);
}
else
{
/* send remaining units back */
int count = 0;
ds = dstring_new("INSERT INTO Event_movement"
" (caveID, target_caveID, source_caveID, movementID,"
" speedFactor, start, end, artefactID");
for (i = 0; i < MAX_UNIT; ++i)
dstring_append(ds, ",%s", unit_type[i]->dbFieldName);
dstring_append(ds, ") VALUES (%d, %d, %d, %d, %s, '%s', '%s', %d",
source_caveID, source_caveID, target_caveID, RUECKKEHR,
speed_factor, return_start, return_end, artefact);
for (i = 0; i < MAX_UNIT; ++i)
{
int num = units[i] * spy_result;
dstring_append(ds, ",%d", num);
count += num;
body_count += units[i] - num;
}
dstring_append(ds, ")");
if (count)
db_query_dstring(database, ds);
/* put resources into cave */
ds = dstring_new("UPDATE " DB_TABLE_CAVE " SET ");
for (i = 0; i < MAX_RESOURCE; ++i)
dstring_append(ds, "%s%s = LEAST(%s + %d, %s)", i > 0 ? "," : "",
resource_type[i]->dbFieldName,
resource_type[i]->dbFieldName, resources[i],
function_to_sql(resource_type[i]->maxLevel));
dstring_append(ds, " WHERE caveID = %d", target_caveID);
db_query_dstring(database, ds);
if (artefact > 0)
put_artefact_into_cave(database, artefact, target_caveID);
}
bodycount_update(database, player2.player_id, body_count);
break;
/**********************************************************************/
/*** UEBERNEHMEN ******************************************************/
/**********************************************************************/
case TAKEOVER:
/* secure or protected target gave? */
if (cave2.secure || cave_is_protected(&cave2))
{
/* send remaining units back */
ds = dstring_new("INSERT INTO Event_movement"
" (caveID, target_caveID, source_caveID, movementID,"
" speedFactor, start, end, artefactID");
for (i = 0; i < MAX_RESOURCE; ++i)
dstring_append(ds, ",%s", resource_type[i]->dbFieldName);
for (i = 0; i < MAX_UNIT; ++i)
dstring_append(ds, ",%s", unit_type[i]->dbFieldName);
dstring_append(ds, ") VALUES (%d, %d, %d, %d, %s, '%s', '%s', %d",
source_caveID, source_caveID, target_caveID, RUECKKEHR,
speed_factor, return_start, return_end, artefact);
for (i = 0; i < MAX_RESOURCE; ++i)
dstring_append(ds, ",%d", resources[i]);
for (i = 0; i < MAX_UNIT; ++i)
dstring_append(ds, ",%d", units[i]);
dstring_append(ds, ")");
db_query_dstring(database, ds);
/* create and send reports */
/* FIXME use different message in report (protected -> secure) */
protected_report(database, &cave1, &player1, &cave2, &player2);
break;
}
get_relation_info(database, player1.tribe, player2.tribe, &relation1);
get_relation_info(database, player2.tribe, player1.tribe, &relation2);
battle = battle_create(1, 1);
battle_bonus = get_battle_bonus();
takeover_multiplier = get_takeover_multiplier(&cave2);
/* prepare structs for battle, exceptions are uncaught! */
prepare_battle(database,
battle,
&player1,
&player2,
&cave1, &cave2, battle_bonus, takeover_multiplier,
units, resources,
&artefact, &artefact_def,
&relation1, &relation2);
/* calculate battle result */
/*bei ner übernahme kein resi klau möglich*/
calcBattleResult(battle, &cave2, 1);
/* change artefact ownership */
after_battle_change_artefact_ownership(
database, battle->winner, &artefact, &artefact_id, &artefact_def,
target_caveID, &cave2, &lostTo);
/* attackers artefact (if any) is stored in variable artefact,
artefact_id is id of the artefact that changed owner (or 0) */
/* defender update: exception still uncaught (better leave) */
after_battle_defender_update(database, player2.player_id,
battle, target_caveID, &relation2);
int war1 = get_tribe_at_war(database,player1.tribe);
int war2 = get_tribe_at_war(database,player2.tribe);
/* attacker won: put survivors into cave, change owner
* attacker lost: send back survivors */
change_owner =
battle->winner == FLAG_ATTACKER && cave2.player_id != PLAYER_SYSTEM &&
player1.max_caves > get_number_of_caves(database, player1.player_id) &&
((relation1.relationType == RELATION_TYPE_WAR &&
relation2.relationType == RELATION_TYPE_WAR) ||
(!war1 && !war2) ||
(strcasecmp(player1.tribe, player2.tribe) == 0)); // Spieler im selben stamm
//bodycount calculate
attacker_lose = bodycount_calculate(battle, FLAG_DEFENDER);
defender_lose = bodycount_calculate(battle, FLAG_ATTACKER);
defender_va_lose = bodycount_va_calculate(battle);
bodycount_update( database, player1.player_id, defender_lose);
bodycount_update( database, player2.player_id, attacker_lose);
if(relation1.relationType == RELATION_TYPE_PRE_WAR || relation1.relationType == RELATION_TYPE_WAR){
war_points_show = 1;
war_points_attacker = (defender_lose>10||defender_va_lose>5?war_points_calculate(battle,FLAG_ATTACKER):0);
war_points_defender = (attacker_lose>10?war_points_calculate(battle,FLAG_DEFENDER):0);
}
if (change_owner){
debug(DEBUG_TAKEOVER, "change owner of cave %d to new owner %d",
target_caveID, cave1.player_id);
takeover_cave(database, target_caveID, cave1.player_id,return_start);
after_takeover_attacker_update(database, player1.player_id,
battle, target_caveID,
artefact, &relation1);
if(relation1.relationType == RELATION_TYPE_PRE_WAR || relation1.relationType == RELATION_TYPE_WAR){
war_points_attacker += WAR_POINTS_FOR_TAKEOVER;
}
} else { /* send survivors back */
debug(DEBUG_TAKEOVER, "send back attacker's suvivors");
after_battle_attacker_update(database, player1.player_id, battle,
source_caveID, target_caveID, speed_factor,
return_start, return_end, artefact,
&relation1);
}
if(relation1.relationType == RELATION_TYPE_PRE_WAR || relation1.relationType == RELATION_TYPE_WAR){
war_points_update(database, player1.tribe, player2.tribe, war_points_attacker, war_points_defender);
}
/* create and send reports */
battle_report(database, &cave1, &player1, &cave2, &player2, battle,
artefact_id, lostTo, change_owner, 1 + takeover_multiplier,
&relation1, &relation2,war_points_show, war_points_attacker, war_points_defender);
//bodycount calculate
bodycount_update( database, player1.player_id, defender_lose);
bodycount_update( database, player2.player_id, attacker_lose);
break;
default:
throw(BAD_ARGUMENT_EXCEPTION, "movement_handler: unknown movementID");
}
/**********************************************************************/
/*** END OF THE INFAMOUS GIANT SWITCH *********************************/
/**********************************************************************/
debug(DEBUG_TICKER, "leaving function movement_handler()");
}
