/*
* Status already set to ARTEFACT_INITIATED, now apply the effects.
*/
void apply_effects_to_cave (db_t *database, int artefactID)
{
struct Artefact artefact;
struct Artefact_class artefact_class;
dstring_t *ds = dstring_new("UPDATE Cave SET ");
int i;
/* get artefact values; throws exception, if that artefact is missing */
get_artefact_by_id(database, artefactID, &artefact);
/* get artefactClass; throws exception, if that artefactClass is missing */
get_artefact_class_by_id(database, artefact.artefactClassID, &artefact_class);
/* Bedingung: muss eingeweiht sein */
if (artefact.initiated != ARTEFACT_INITIATED)
throw(BAD_ARGUMENT_EXCEPTION, "initiate_artefact: artefact was not initiated");
for (i = 0; i < MAX_EFFECT; ++i)
dstring_append(ds, "%s %s = %s + %f",
(i == 0 ? "" : ","),
effect_type[i]->dbFieldName,
effect_type[i]->dbFieldName,
artefact_class.effect[i]);
dstring_append(ds, " WHERE caveID = %d", artefact.caveID);
db_query_dstring(database, ds);
debug(DEBUG_ARTEFACT, "apply_effects_to_cave: %s", dstring_str(ds));
}
/*
* User wants to remove the artefact from a cave or another user just robbed
* that user. Remove the effects (actually same as apply_effects but with a
* "-" instead of the "+").
*/
void remove_effects_from_cave (db_t *database, int artefactID)
{
struct Artefact artefact;
struct Artefact_class artefact_class;
dstring_t *ds = dstring_new("UPDATE Cave SET ");
int i;
/* get artefact values; throws exception, if that artefact is missing */
get_artefact_by_id(database, artefactID, &artefact);
/* get artefactClass; throws exception, if that artefactClass is missing */
get_artefact_class_by_id(database, artefact.artefactClassID, &artefact_class);
/* Wenn das Artefakt nicht mehr eingeweiht ist, m�ssen die Effekte nicht mehr entfernt werden. */
if (artefact.initiated != ARTEFACT_INITIATED) return;
for (i = 0; i < MAX_EFFECT; ++i)
dstring_append(ds, "%s %s = %s - %f",
(i == 0 ? "" : ","),
effect_type[i]->dbFieldName,
effect_type[i]->dbFieldName,
artefact_class.effect[i]);
dstring_append(ds, " WHERE caveID = %d", artefact.caveID);
db_query_dstring(database, ds);
debug(DEBUG_ARTEFACT, "remove_effects_from_cave: %s", dstring_str(ds));
}
static void after_battle_defender_update(db_t *database,
int player_id,
const Battle *battle,
int cave_id,
struct Relation *relation)
{
dstring_t *ds;
int update = 0;
int i;
/* construct defender update */
ds = dstring_new("UPDATE " DB_TABLE_CAVE " SET ");
/* which units need an update */
debug(DEBUG_BATTLE, "preparing units update");
for (i = 0; i < MAX_UNIT; ++i) {
const struct Army_unit *unit = &battle->defenders[0].units[i];
if (unit->amount_before != unit->amount_after) {
dstring_append(ds, "%s%s = %d", update ? "," : "",
unit_type[i]->dbFieldName, unit->amount_after);
update = 1;
}
}
/* which defense systems need an update */
debug(DEBUG_BATTLE, "preparing defensesystems update");
for (i = 0; i < MAX_DEFENSESYSTEM; ++i) {
const struct Army_unit *defense_system =
&battle->defenders[0].defenseSystems[i];
// if ((relation->relationType == RELATION_TYPE_WAR) || (((struct DefenseSystem *)defense_system_type[i])->warpoints == 0 )) {
if (defense_system->amount_before != defense_system->amount_after) {
dstring_append(ds, "%s%s = %d", update ? "," : "",
defense_system_type[i]->dbFieldName,
defense_system->amount_after);
update = 1;
}
// }
}
/* which resources need an update */
debug(DEBUG_BATTLE, "preparing resources update");
for (i = 0; i < MAX_RESOURCE; ++i)
if (battle->defenders[0].resourcesBefore[i] !=
battle->defenders[0].resourcesAfter[i]) {
dstring_append(ds, "%s%s = LEAST(%d, %s)", update ? "," : "",
resource_type[i]->dbFieldName,
battle->defenders[0].resourcesAfter[i],
function_to_sql(resource_type[i]->maxLevel));
update = 1;
}
dstring_append(ds, " WHERE caveID = %d", cave_id);
if (update) {
debug(DEBUG_SQL, "%s", dstring_str(ds));
db_query_dstring(database, ds);
}
}
/*
* Function is called to instantiate a wonder's impact.
*/
void weatherEnd_handler (db_t *database, db_result_t *result)
{
int region_id;
int weather_id;
int impact_id;
const struct Weather *weather;
const struct WeatherImpact *impact;
float effect[MAX_EFFECT];
dstring_t *query;
int index, len;
debug(DEBUG_TICKER, "entering function weatherEnd_handler()");
/* fetch data from event table */
region_id = db_result_get_int(result, "regionID");
weather_id = db_result_get_int(result, "weatherID");
impact_id = db_result_get_int(result, "impactID");
get_effect_list(result, effect);
debug(DEBUG_TICKER, "regionID = %d, weatherID = %d", region_id, weather_id);
weather = (struct Weather *) weather_type[weather_id];
impact = &weather->impacts[impact_id];
/* prepare update statement */
query = dstring_new("UPDATE " DB_TABLE_CAVE " SET ");
for (index = 0; index < MAX_EFFECT; ++index)
{
double delta = -effect[index];
if (delta != 0)
{
const char *dbFieldName = effect_type[index]->dbFieldName;
dstring_append(query, "%s = %s + %f,",
dbFieldName, dbFieldName, delta);
}
}
/* update the cave */
len = dstring_len(query) - 1;
if (dstring_str(query)[len] == ',')
{
dstring_truncate(query, len);
dstring_append(query, " WHERE regionID = %d", region_id);
debug(DEBUG_SQL, "%s", dstring_str(query));
db_query_dstring(database, query);
}
debug(DEBUG_TICKER, "leaving function weatherEnd_handler()");
}
static void after_takeover_attacker_update(db_t *database,
int player_id,
const Battle *battle,
int target_caveID,
int artefact,
struct Relation *relation)
{
int update = 0;
int i;
/* construct attacker update */
for (i = 0; i < MAX_UNIT; ++i)
if (battle->attackers[0].units[i].amount_after > 0) {
update = 1;
break;
}
if (update) {
dstring_t *ds;
/* put artefact into cave */
if (artefact > 0)
put_artefact_into_cave(database, artefact, target_caveID);
/* put remaining units into target_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,
battle->attackers[0].resourcesAfter[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,
battle->attackers[0].units[i].amount_after);
dstring_append(ds, " WHERE caveID = %d", target_caveID);
debug(DEBUG_SQL, "%s", dstring_str(ds));
db_query_dstring(database, ds);
}
}
/*
* Converts a g4_primer_pair array into a dstring_t dynamic string suitable
* for passing back to Tcl.
*/
dstring_t *g4_pp2dstring(dstring_t *ds, g4_primer_pair *pp, int npairs)
{
int i;
if (!ds)
ds = dstring_create(NULL);
for (i = 0; i < npairs; i++) {
dstring_append(ds, "{ ");
/* pair info */
dstring_appendf(ds, "{ %d %f %f %f %f %f } ",
i == 0 ? 1 : 0, /* First is always picked */
pp[i].pair->pair_quality,
pp[i].pair->compl_measure,
pp[i].pair->diff_tm,
pp[i].pair->product_tm,
pp[i].pair->product_tm_oligo_tm_diff);
/* left primer */
dstring_appendf(ds, "{ %s %d %d %d %f %f } ",
pp[i].seq[0],
pp[i].contig[0], pp[i].pos[0], pp[i].len[0],
pp[i].pair->left->temp,
pp[i].pair->left->gc_content);
/* right primer */
dstring_appendf(ds, "{ %s %d %d %d %f %f } ",
pp[i].seq[1],
pp[i].contig[1], pp[i].pos[1], pp[i].len[1],
pp[i].pair->right->temp,
pp[i].pair->right->gc_content);
dstring_append(ds, "} ");
}
return ds;
}
static void takeover_cave(db_t *database,
int cave_id,
int attacker_id,
const char *return_start)
{
/* change owner of cave */
db_query(database, "UPDATE " DB_TABLE_CAVE " SET playerID = %d"
" WHERE caveID = %d", attacker_id, cave_id);
dstring_t *ds;
ds = dstring_new("UPDATE Event_movement SET target_caveID = source_caveID, ");
dstring_append(ds, "end = addtime('%s',timediff('%s',start)), ",return_start,return_start);
dstring_append(ds, "start='%s', ",return_start);
dstring_append(ds, "movementID = 5 where caveID = %d and caveID = source_caveID",cave_id);
debug(DEBUG_SQL, "Torben %s", dstring_str(ds));
db_query_dstring(database, ds);
/* delete research from event table*/
db_query(database, "DELETE FROM Event_science WHERE caveID = %d", cave_id);
/* copy sciences from new owner to cave */
science_update_caves(database, attacker_id);
}
/*
ClusterFlow
Builds the entire visibility list for a cluster
*/
void
ClusterFlow (int clusternum)
{
byte compressed[MAX_MAP_LEAFS / 8];
byte *outbuffer;
int numvis, i, j;
cluster_t *cluster;
portal_t *portal;
outbuffer = uncompressed + clusternum * bitbytes_l;
cluster = &clusters[clusternum];
// flow through all portals, collecting visible bits
memset (compressed, 0, sizeof (compressed));
for (i = 0; i < cluster->numportals; i++) {
portal = cluster->portals[i];
if (portal->status != stat_done)
Sys_Error ("portal not done");
for (j = 0; j < bitbytes; j++)
compressed[j] |= portal->visbits[j];
}
if (compressed[clusternum >> 3] & (1 << (clusternum & 7)))
Sys_Error ("Cluster portals saw into cluster");
compressed[clusternum >> 3] |= (1 << (clusternum & 7));
numvis = 0;
for (i = 0; i < portalclusters; i++)
if (compressed[i >> 3] & (1 << (i & 3)))
numvis++;
// expand to cluster->leaf PVS
ClusterFlowExpand (compressed, outbuffer);
// compress the bit string
if (options.verbosity > 0)
printf ("cluster %4i : %4i visible\n", clusternum, numvis);
totalvis += numvis;
i = CompressRow (outbuffer, compressed);
cluster->visofs = visdata->size;
dstring_append (visdata, (char *) compressed, i);
}
static void after_battle_attacker_update (
db_t *database,
int player_id,
const Battle *battle,
int source_caveID,
int target_caveID,
const char *speed_factor,
const char *return_start,
const char *return_end,
int artefact,
struct Relation *relation
)
{
int update = 0;
int i;
/* construct attacker update */
for (i = 0; i < MAX_UNIT; ++i)
if (battle->attackers[0].units[i].amount_after > 0) {
update = 1;
break;
}
if (update) {
dstring_t *ds;
/* 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", battle->attackers[0].resourcesAfter[i]);
for (i = 0; i < MAX_UNIT; ++i)
dstring_append(ds, ",%d", battle->attackers[0].units[i].amount_after);
dstring_append(ds, ")");
debug(DEBUG_SQL, "%s", dstring_str(ds));
db_query_dstring(database, ds);
}
}
/*
* 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()");
}
/* ----------
* slon_appendquery_int
*
* Implementation of slon_mkquery() and slon_appendquery().
* ----------
*/
static int
slon_appendquery_int(SlonDString * dsp, char *fmt, va_list ap)
{
char *s;
char buf[64];
while (*fmt)
{
switch (*fmt)
{
case '%':
fmt++;
switch (*fmt)
{
case 's':
s = va_arg(ap, char *);
dstring_append(dsp, s);
fmt++;
break;
case 'q':
s = va_arg(ap, char *);
while (s && *s != '\0')
{
switch (*s)
{
case '\'':
dstring_addchar(dsp, '\'');
break;
case '\\':
dstring_addchar(dsp, '\\');
break;
default:
break;
}
dstring_addchar(dsp, *s);
s++;
}
fmt++;
break;
case 'Q':
s = va_arg(ap, char *);
while (s && *s != '\0')
{
switch (*s)
{
case '\'':
case '\\':
dstring_addchar(dsp, '\\');
break;
default:
break;
}
dstring_addchar(dsp, *s);
s++;
}
fmt++;
break;
case 'd':
sprintf(buf, "%d", va_arg(ap, int));
dstring_append(dsp, buf);
fmt++;
break;
default:
dstring_addchar(dsp, '%');
dstring_addchar(dsp, *fmt);
fmt++;
break;
}
break;
case '\\':
fmt++;
dstring_addchar(dsp, *fmt);
fmt++;
break;
default:
dstring_addchar(dsp, *fmt);
fmt++;
break;
}
}
dstring_terminate(dsp);
return 0;
}
