Marc/server
1
0
Fork 0
forked from github/server
Code Issues Pull requests Projects Releases Wiki Activity

remove even more obsolete datafile version support.

Browse source
This commit is contained in:
Enno Rehling 2014-12-12 23:00:30 +01:00
parent d492487a5b
commit 0967ccaac6
6 changed files with 251 additions and 316 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
src/building_action.c
View file

@ -113,21 +113,16 @@ static int lc_read(struct attrib *a, void *owner, struct storage *store)
else { else {
data->fname = _strdup(name); data->fname = _strdup(name);
} }
if (global.data_version >= BACTION_VERSION) { READ_TOK(store, name, sizeof(name));
READ_TOK(store, name, sizeof(name)); if (strcmp(name, "tnnL") == 0) {
if (strcmp(name, "tnnL") == 0) { /* tunnel_action was the old Weltentore, their code has changed. ignore this object */
/* tunnel_action was the old Weltentore, their code has changed. ignore this object */ result = 0;
result = 0; data->b = 0;
data->b = 0;
}
if (strcmp(name, NULLSTRING) == 0)
data->param = 0;
else {
data->param = _strdup(name);
}
} }
else { if (strcmp(name, NULLSTRING) == 0)
data->param = 0; data->param = 0;
else {
data->param = _strdup(name);
} }
if (result == 0 && !data->b) { if (result == 0 && !data->b) {
return AT_READ_FAIL; return AT_READ_FAIL;

10
src/kernel/curse.c
View file

@ -195,14 +195,8 @@ int curse_read(attrib * a, void *owner, struct storage *store)
READ_TOK(store, cursename, sizeof(cursename)); READ_TOK(store, cursename, sizeof(cursename));
READ_INT(store, &flags); READ_INT(store, &flags);
READ_INT(store, &c->duration); READ_INT(store, &c->duration);
if (global.data_version >= CURSEVIGOURISFLOAT_VERSION) { READ_FLT(store, &flt);
READ_FLT(store, &flt); c->vigour = flt;
c->vigour = flt;
}
else {
READ_INT(store, &n);
c->vigour = (float)n;
}
if (global.data_version < INTPAK_VERSION) { if (global.data_version < INTPAK_VERSION) {
ur = read_reference(&c->magician, store, read_int, resolve_unit); ur = read_reference(&c->magician, store, read_int, resolve_unit);
} }

53
src/kernel/save.c
View file

@ -428,10 +428,6 @@ static void read_alliances(struct storage *store)
{ {
char pbuf[8]; char pbuf[8];
int id, terminator = 0; int id, terminator = 0;
if (global.data_version < SAVEALLIANCE_VERSION) {
if (!AllianceRestricted() && !AllianceAuto())
return;
}
if (global.data_version < ALLIANCELEADER_VERSION) { if (global.data_version < ALLIANCELEADER_VERSION) {
terminator = atoi36("end"); terminator = atoi36("end");
READ_STR(store, pbuf, sizeof(pbuf)); READ_STR(store, pbuf, sizeof(pbuf));
@ -730,14 +726,6 @@ unit *read_unit(struct gamedata *data)
} }
READ_STR(data->store, obuf, sizeof(obuf)); READ_STR(data->store, obuf, sizeof(obuf));
} }
if (data->version < NOLASTORDER_VERSION) {
order *ord;
READ_STR(data->store, obuf, sizeof(obuf));
ord = parse_order(obuf, u->faction->locale);
if (ord != NULL) {
addlist(&u->orders, ord);
}
}
set_order(&u->thisorder, NULL); set_order(&u->thisorder, NULL);
assert(u_race(u)); assert(u_race(u));
@ -1257,9 +1245,7 @@ faction *readfaction(struct gamedata * data)
} }
a_read(data->store, &f->attribs, f); a_read(data->store, &f->attribs, f);
if (data->version >= CLAIM_VERSION) { read_items(data->store, &f->items);
read_items(data->store, &f->items);
}
for (;;) { for (;;) {
READ_TOK(data->store, name, sizeof(name)); READ_TOK(data->store, name, sizeof(name));
if (strcmp("end", name) == 0) if (strcmp("end", name) == 0)
@ -1286,28 +1272,16 @@ faction *readfaction(struct gamedata * data)
} }
sfp = &f->allies; sfp = &f->allies;
if (data->version < ALLIANCES_VERSION) { for (;;) {
int p; int aid = 0;
READ_INT(data->store, &p); READ_INT(data->store, &aid);
while (--p >= 0) { if (aid > 0) {
int aid, state; int state;
READ_INT(data->store, &aid);
READ_INT(data->store, &state); READ_INT(data->store, &state);
sfp = addally(f, sfp, aid, state); sfp = addally(f, sfp, aid, state);
} }
} else {
else { break;
for (;;) {
int aid = 0;
READ_INT(data->store, &aid);
if (aid > 0) {
int state;
READ_INT(data->store, &state);
sfp = addally(f, sfp, aid, state);
}
else {
break;
}
} }
} }
read_groups(data->store, f); read_groups(data->store, f);
@ -1439,9 +1413,8 @@ int readgame(const char *filename, int backup)
getchar(); getchar();
} }
} }
else if (gdata.version >= SAVEXMLNAME_VERSION) { else {
char basefile[32]; READ_STR(&store, NULL, 0);
READ_STR(&store, basefile, sizeof(basefile));
} }
a_read(&store, &global.attribs, NULL); a_read(&store, &global.attribs, NULL);
READ_INT(&store, &turn); READ_INT(&store, &turn);
@ -1512,9 +1485,7 @@ int readgame(const char *filename, int backup)
} }
/* Read factions */ /* Read factions */
if (gdata.version >= ALLIANCES_VERSION) { read_alliances(&store);
read_alliances(&store);
}
READ_INT(&store, &nread); READ_INT(&store, &nread);
log_printf(stdout, " - Einzulesende Parteien: %d\n", nread); log_printf(stdout, " - Einzulesende Parteien: %d\n", nread);
fp = &factions; fp = &factions;
@ -1806,9 +1777,7 @@ int writegame(const char *filename)
} }
/* Write factions */ /* Write factions */
#if RELEASE_VERSION>=ALLIANCES_VERSION
write_alliances(&gdata); write_alliances(&gdata);
#endif
n = listlen(factions); n = listlen(factions);
WRITE_INT(&store, n); WRITE_INT(&store, n);
WRITE_SECTION(&store); WRITE_SECTION(&store);

11
src/kernel/version.h
View file

@ -10,16 +10,6 @@
without prior permission by the authors of Eressea. without prior permission by the authors of Eressea.
*/ */
#define CURSETYPE_VERSION 312 /* turn 287 */
#define ALLIANCES_VERSION 313
#define DBLINK_VERSION 314
#define CURSEVIGOURISFLOAT_VERSION 315
#define SAVEXMLNAME_VERSION 316
#define SAVEALLIANCE_VERSION 317
#define CLAIM_VERSION 318
/* 319 is the HSE4 data version */
#define BACTION_VERSION 319 /* building action gets a param string */
#define NOLASTORDER_VERSION 320 /* do not use lastorder */
#define INTPAK_VERSION 329 /* in binary, ints can get packed */ #define INTPAK_VERSION 329 /* in binary, ints can get packed */
#define NOZEROIDS_VERSION 330 /* 2008-05-16 zero is not a valid ID for anything (including factions) */ #define NOZEROIDS_VERSION 330 /* 2008-05-16 zero is not a valid ID for anything (including factions) */
#define NOBORDERATTRIBS_VERSION 331 /* 2008-05-17 connection::attribs has been moved to userdata */ #define NOBORDERATTRIBS_VERSION 331 /* 2008-05-17 connection::attribs has been moved to userdata */
@ -38,6 +28,7 @@
#define SAVEGAMEID_VERSION 343 /* instead of XMLNAME, save the game.id parameter from the config */ #define SAVEGAMEID_VERSION 343 /* instead of XMLNAME, save the game.id parameter from the config */
#define BUILDNO_VERSION 344 /* storing the build number in the save */ #define BUILDNO_VERSION 344 /* storing the build number in the save */
#define AUTO_RACENAME_VERSION 345 /* NPC units with name==NULL will automatically get their race for a name */ #define AUTO_RACENAME_VERSION 345 /* NPC units with name==NULL will automatically get their race for a name */
#define MIN_VERSION INTPAK_VERSION /* minimal datafile we support */ #define MIN_VERSION INTPAK_VERSION /* minimal datafile we support */
#define RELEASE_VERSION AUTO_RACENAME_VERSION /* current datafile */ #define RELEASE_VERSION AUTO_RACENAME_VERSION /* current datafile */

341
src/spells/unitcurse.c
View file

@ -44,32 +44,33 @@
*/ */
/* erhöht/senkt regeneration und maxaura um effect% */ /* erhöht/senkt regeneration und maxaura um effect% */
static message *cinfo_auraboost(const void *obj, objtype_t typ, const curse * c, static message *cinfo_auraboost(const void *obj, objtype_t typ, const curse * c,
int self) int self)
{ {
struct unit *u = (struct unit *)obj; struct unit *u = (struct unit *)obj;
unused_arg(typ); unused_arg(typ);
assert(typ == TYP_UNIT); assert(typ == TYP_UNIT);
if (self != 0) { if (self != 0) {
if (curse_geteffect(c) > 100) { if (curse_geteffect(c) > 100) {
return msg_message("curseinfo::auraboost_0", "unit id", u, c->no); return msg_message("curseinfo::auraboost_0", "unit id", u, c->no);
} else { }
return msg_message("curseinfo::auraboost_1", "unit id", u, c->no); else {
return msg_message("curseinfo::auraboost_1", "unit id", u, c->no);
}
} }
} return NULL;
return NULL;
} }
static struct curse_type ct_auraboost = { static struct curse_type ct_auraboost = {
"auraboost", "auraboost",
CURSETYP_NORM, CURSE_SPREADMODULO, (NO_MERGE), CURSETYP_NORM, CURSE_SPREADMODULO, (NO_MERGE),
cinfo_auraboost cinfo_auraboost
}; };
/* Magic Boost - Gabe des Chaos */ /* Magic Boost - Gabe des Chaos */
static struct curse_type ct_magicboost = { static struct curse_type ct_magicboost = {
"magicboost", "magicboost",
CURSETYP_UNIT, CURSE_SPREADMODULO | CURSE_IMMUNE, M_MEN, cinfo_simple CURSETYP_UNIT, CURSE_SPREADMODULO | CURSE_IMMUNE, M_MEN, cinfo_simple
}; };
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
@ -77,24 +78,24 @@ static struct curse_type ct_magicboost = {
* C_SLAVE * C_SLAVE
*/ */
static message *cinfo_slave(const void *obj, objtype_t typ, const curse * c, static message *cinfo_slave(const void *obj, objtype_t typ, const curse * c,
int self) int self)
{ {
unit *u; unit *u;
unused_arg(typ); unused_arg(typ);
assert(typ == TYP_UNIT); assert(typ == TYP_UNIT);
u = (unit *) obj; u = (unit *)obj;
if (self != 0) { if (self != 0) {
return msg_message("curseinfo::slave_1", "unit duration id", u, c->duration, return msg_message("curseinfo::slave_1", "unit duration id", u, c->duration,
c->no); c->no);
} }
return NULL; return NULL;
} }
static struct curse_type ct_slavery = { "slavery", static struct curse_type ct_slavery = { "slavery",
CURSETYP_NORM, 0, NO_MERGE, CURSETYP_NORM, 0, NO_MERGE,
cinfo_slave cinfo_slave
}; };
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
@ -102,28 +103,28 @@ static struct curse_type ct_slavery = { "slavery",
* C_CALM * C_CALM
*/ */
static message *cinfo_calm(const void *obj, objtype_t typ, const curse * c, static message *cinfo_calm(const void *obj, objtype_t typ, const curse * c,
int self) int self)
{ {
unused_arg(typ); unused_arg(typ);
assert(typ == TYP_UNIT); assert(typ == TYP_UNIT);
if (c->magician && c->magician->faction) { if (c->magician && c->magician->faction) {
faction *f = c->magician->faction; faction *f = c->magician->faction;
unit *u = (unit *) obj; unit *u = (unit *)obj;
if (f == NULL || self == 0) { if (f == NULL || self == 0) {
const struct race *rc = u_irace(c->magician); const struct race *rc = u_irace(c->magician);
return msg_message("curseinfo::calm_0", "unit race id", u, rc, c->no); return msg_message("curseinfo::calm_0", "unit race id", u, rc, c->no);
}
return msg_message("curseinfo::calm_1", "unit faction id", u, f, c->no);
} }
return msg_message("curseinfo::calm_1", "unit faction id", u, f, c->no); return NULL;
}
return NULL;
} }
static struct curse_type ct_calmmonster = { static struct curse_type ct_calmmonster = {
"calmmonster", "calmmonster",
CURSETYP_NORM, CURSE_SPREADNEVER | CURSE_ONLYONE, NO_MERGE, CURSETYP_NORM, CURSE_SPREADNEVER | CURSE_ONLYONE, NO_MERGE,
cinfo_calm cinfo_calm
}; };
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
@ -131,23 +132,23 @@ static struct curse_type ct_calmmonster = {
* C_SPEED * C_SPEED
*/ */
static message *cinfo_speed(const void *obj, objtype_t typ, const curse * c, static message *cinfo_speed(const void *obj, objtype_t typ, const curse * c,
int self) int self)
{ {
unused_arg(typ); unused_arg(typ);
assert(typ == TYP_UNIT); assert(typ == TYP_UNIT);
if (self != 0) { if (self != 0) {
unit *u = (unit *) obj; unit *u = (unit *)obj;
return msg_message("curseinfo::speed_1", "unit number duration id", u, return msg_message("curseinfo::speed_1", "unit number duration id", u,
c->data.i, c->duration, c->no); c->data.i, c->duration, c->no);
} }
return NULL; return NULL;
} }
static struct curse_type ct_speed = { static struct curse_type ct_speed = {
"speed", "speed",
CURSETYP_UNIT, CURSE_SPREADNEVER, M_MEN, CURSETYP_UNIT, CURSE_SPREADNEVER, M_MEN,
cinfo_speed cinfo_speed
}; };
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
@ -156,21 +157,21 @@ static struct curse_type ct_speed = {
*/ */
message *cinfo_unit(const void *obj, objtype_t typ, const curse * c, int self) message *cinfo_unit(const void *obj, objtype_t typ, const curse * c, int self)
{ {
unused_arg(typ); unused_arg(typ);
assert(typ == TYP_UNIT); assert(typ == TYP_UNIT);
if (self != 0) { if (self != 0) {
unit *u = (unit *) obj; unit *u = (unit *)obj;
return msg_message(mkname("curseinfo", c->type->cname), "unit id", u, return msg_message(mkname("curseinfo", c->type->cname), "unit id", u,
c->no); c->no);
} }
return NULL; return NULL;
} }
static struct curse_type ct_orcish = { static struct curse_type ct_orcish = {
"orcish", "orcish",
CURSETYP_UNIT, CURSE_SPREADMODULO | CURSE_ISNEW, M_MEN, CURSETYP_UNIT, CURSE_SPREADMODULO | CURSE_ISNEW, M_MEN,
cinfo_unit cinfo_unit
}; };
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
@ -178,23 +179,23 @@ static struct curse_type ct_orcish = {
* C_KAELTESCHUTZ * C_KAELTESCHUTZ
*/ */
static message *cinfo_kaelteschutz(const void *obj, objtype_t typ, const curse * c, static message *cinfo_kaelteschutz(const void *obj, objtype_t typ, const curse * c,
int self) int self)
{ {
unused_arg(typ); unused_arg(typ);
assert(typ == TYP_UNIT); assert(typ == TYP_UNIT);
if (self != 0) { if (self != 0) {
unit *u = (unit *) obj; unit *u = (unit *)obj;
return msg_message("curseinfo::warmth_1", "unit number id", u, return msg_message("curseinfo::warmth_1", "unit number id", u,
get_cursedmen(u, c), c->no); get_cursedmen(u, c), c->no);
} }
return NULL; return NULL;
} }
static struct curse_type ct_insectfur = { static struct curse_type ct_insectfur = {
"insectfur", "insectfur",
CURSETYP_UNIT, CURSE_SPREADMODULO, (M_MEN | M_DURATION), CURSETYP_UNIT, CURSE_SPREADMODULO, (M_MEN | M_DURATION),
cinfo_kaelteschutz cinfo_kaelteschutz
}; };
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
@ -202,64 +203,64 @@ static struct curse_type ct_insectfur = {
* C_SPARKLE * C_SPARKLE
*/ */
static message *cinfo_sparkle(const void *obj, objtype_t typ, const curse * c, static message *cinfo_sparkle(const void *obj, objtype_t typ, const curse * c,
int self) int self)
{ {
const char *effects[] = { const char *effects[] = {
NULL, /* end grau */ NULL, /* end grau */
"sparkle_1", "sparkle_1",
"sparkle_2", "sparkle_2",
NULL, /* end traum */ NULL, /* end traum */
"sparkle_3", "sparkle_3",
"sparkle_4", "sparkle_4",
NULL, /* end tybied */ NULL, /* end tybied */
"sparkle_5", "sparkle_5",
"sparkle_6", "sparkle_6",
"sparkle_7", "sparkle_7",
"sparkle_8", "sparkle_8",
NULL, /* end cerrdor */ NULL, /* end cerrdor */
"sparkle_9", "sparkle_9",
"sparkle_10", "sparkle_10",
"sparkle_11", "sparkle_11",
"sparkle_12", "sparkle_12",
NULL, /* end gwyrrd */ NULL, /* end gwyrrd */
"sparkle_13", "sparkle_13",
"sparkle_14", "sparkle_14",
"sparkle_15", "sparkle_15",
"sparkle_16", "sparkle_16",
"sparkle_17", "sparkle_17",
"sparkle_18", "sparkle_18",
NULL, /* end draig */ NULL, /* end draig */
}; };
int m, begin = 0, end = 0; int m, begin = 0, end = 0;
unit *u; unit *u;
unused_arg(typ); unused_arg(typ);
assert(typ == TYP_UNIT); assert(typ == TYP_UNIT);
u = (unit *) obj; u = (unit *)obj;
if (!c->magician || !c->magician->faction) if (!c->magician || !c->magician->faction)
return NULL; return NULL;
for (m = 0; m != c->magician->faction->magiegebiet; ++m) {
while (effects[end] != NULL)
++end;
begin = end + 1;
end = begin;
}
for (m = 0; m != c->magician->faction->magiegebiet; ++m) {
while (effects[end] != NULL) while (effects[end] != NULL)
++end; ++end;
begin = end + 1; if (end == begin)
end = begin; return NULL;
} else {
int index = begin + curse_geteffect_int(c) % (end - begin);
while (effects[end] != NULL) return msg_message(mkname("curseinfo", effects[index]), "unit id", u,
++end; c->no);
if (end == begin) }
return NULL;
else {
int index = begin + curse_geteffect_int(c) % (end - begin);
return msg_message(mkname("curseinfo", effects[index]), "unit id", u,
c->no);
}
} }
static struct curse_type ct_sparkle = { "sparkle", static struct curse_type ct_sparkle = { "sparkle",
CURSETYP_UNIT, CURSE_SPREADMODULO, (M_MEN | M_DURATION), cinfo_sparkle CURSETYP_UNIT, CURSE_SPREADMODULO, (M_MEN | M_DURATION), cinfo_sparkle
}; };
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
@ -267,7 +268,7 @@ static struct curse_type ct_sparkle = { "sparkle",
* C_STRENGTH * C_STRENGTH
*/ */
static struct curse_type ct_strength = { "strength", static struct curse_type ct_strength = { "strength",
CURSETYP_UNIT, CURSE_SPREADMODULO, M_MEN, cinfo_simple CURSETYP_UNIT, CURSE_SPREADMODULO, M_MEN, cinfo_simple
}; };
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
@ -275,7 +276,7 @@ static struct curse_type ct_strength = { "strength",
* C_ALLSKILLS (Alp) * C_ALLSKILLS (Alp)
*/ */
static struct curse_type ct_worse = { static struct curse_type ct_worse = {
"worse", CURSETYP_UNIT, CURSE_SPREADMODULO | CURSE_NOAGE, M_MEN, cinfo_unit "worse", CURSETYP_UNIT, CURSE_SPREADMODULO | CURSE_NOAGE, M_MEN, cinfo_unit
}; };
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
@ -284,24 +285,24 @@ static struct curse_type ct_worse = {
* C_ITEMCLOAK * C_ITEMCLOAK
*/ */
static struct curse_type ct_itemcloak = { static struct curse_type ct_itemcloak = {
"itemcloak", CURSETYP_UNIT, CURSE_SPREADNEVER, M_DURATION, cinfo_unit "itemcloak", CURSETYP_UNIT, CURSE_SPREADNEVER, M_DURATION, cinfo_unit
}; };
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
static struct curse_type ct_fumble = { static struct curse_type ct_fumble = {
"fumble", CURSETYP_NORM, CURSE_SPREADNEVER | CURSE_ONLYONE, NO_MERGE, "fumble", CURSETYP_NORM, CURSE_SPREADNEVER | CURSE_ONLYONE, NO_MERGE,
cinfo_unit cinfo_unit
}; };
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
static struct curse_type ct_oldrace = { static struct curse_type ct_oldrace = {
"oldrace", CURSETYP_NORM, CURSE_SPREADALWAYS, NO_MERGE, NULL "oldrace", CURSETYP_NORM, CURSE_SPREADALWAYS, NO_MERGE, NULL
}; };
static struct curse_type ct_magicresistance = { static struct curse_type ct_magicresistance = {
"magicresistance", CURSETYP_UNIT, CURSE_SPREADMODULO, M_MEN, cinfo_simple "magicresistance", CURSETYP_UNIT, CURSE_SPREADMODULO, M_MEN, cinfo_simple
}; };
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
@ -311,62 +312,58 @@ static struct curse_type ct_magicresistance = {
static int read_skill(struct storage *store, curse * c, void *target) static int read_skill(struct storage *store, curse * c, void *target)
{ {
int skill; int skill;
if (global.data_version < CURSETYPE_VERSION) {
READ_INT(store, &skill); READ_INT(store, &skill);
READ_INT(store, 0); /* men, ignored */ c->data.i = skill;
} else { return 0;
READ_INT(store, &skill);
}
c->data.i = skill;
return 0;
} }
static int static int
write_skill(struct storage *store, const curse * c, const void *target) write_skill(struct storage *store, const curse * c, const void *target)
{ {
WRITE_INT(store, c->data.i); WRITE_INT(store, c->data.i);
return 0; return 0;
} }
static message *cinfo_skillmod(const void *obj, objtype_t typ, const curse * c, static message *cinfo_skillmod(const void *obj, objtype_t typ, const curse * c,
int self) int self)
{ {
unused_arg(typ); unused_arg(typ);
if (self != 0) { if (self != 0) {
unit *u = (unit *) obj; unit *u = (unit *)obj;
int sk = c->data.i; int sk = c->data.i;
if (c->effect > 0) { if (c->effect > 0) {
return msg_message("curseinfo::skill_1", "unit skill id", u, sk, c->no); return msg_message("curseinfo::skill_1", "unit skill id", u, sk, c->no);
} else if (c->effect < 0) { }
return msg_message("curseinfo::skill_2", "unit skill id", u, sk, c->no); else if (c->effect < 0) {
return msg_message("curseinfo::skill_2", "unit skill id", u, sk, c->no);
}
} }
} return NULL;
return NULL;
} }
static struct curse_type ct_skillmod = { static struct curse_type ct_skillmod = {
"skillmod", CURSETYP_NORM, CURSE_SPREADMODULO, M_MEN, cinfo_skillmod, "skillmod", CURSETYP_NORM, CURSE_SPREADMODULO, M_MEN, cinfo_skillmod,
NULL, read_skill, write_skill NULL, read_skill, write_skill
}; };
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
void register_unitcurse(void) void register_unitcurse(void)
{ {
ct_register(&ct_auraboost); ct_register(&ct_auraboost);
ct_register(&ct_magicboost); ct_register(&ct_magicboost);
ct_register(&ct_slavery); ct_register(&ct_slavery);
ct_register(&ct_calmmonster); ct_register(&ct_calmmonster);
ct_register(&ct_speed); ct_register(&ct_speed);
ct_register(&ct_orcish); ct_register(&ct_orcish);
ct_register(&ct_insectfur); ct_register(&ct_insectfur);
ct_register(&ct_sparkle); ct_register(&ct_sparkle);
ct_register(&ct_strength); ct_register(&ct_strength);
ct_register(&ct_worse); ct_register(&ct_worse);
ct_register(&ct_skillmod); ct_register(&ct_skillmod);
ct_register(&ct_itemcloak); ct_register(&ct_itemcloak);
ct_register(&ct_fumble); ct_register(&ct_fumble);
ct_register(&ct_oldrace); ct_register(&ct_oldrace);
ct_register(&ct_magicresistance); ct_register(&ct_magicresistance);
} }

131
src/triggers/createcurse.c
View file

@ -1,7 +1,7 @@
/* /*
Copyright (c) 1998-2010, Enno Rehling <enno@eressea.de> Copyright (c) 1998-2010, Enno Rehling <enno@eressea.de>
Katja Zedel <katze@felidae.kn-bremen.de Katja Zedel <katze@felidae.kn-bremen.de
Christian Schlittchen <corwin@amber.kn-bremen.de> Christian Schlittchen <corwin@amber.kn-bremen.de>
Permission to use, copy, modify, and/or distribute this software for any Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above purpose with or without fee is hereby granted, provided that the above
@ -45,109 +45,98 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
**/ **/
typedef struct createcurse_data { typedef struct createcurse_data {
struct unit *mage; struct unit *mage;
struct unit *target; struct unit *target;
const curse_type *type; const curse_type *type;
float vigour; float vigour;
int duration; int duration;
float effect; float effect;
int men; int men;
} createcurse_data; } createcurse_data;
static void createcurse_init(trigger * t) static void createcurse_init(trigger * t)
{ {
t->data.v = calloc(sizeof(createcurse_data), 1); t->data.v = calloc(sizeof(createcurse_data), 1);
} }
static void createcurse_free(trigger * t) static void createcurse_free(trigger * t)
{ {
free(t->data.v); free(t->data.v);
} }
static int createcurse_handle(trigger * t, void *data) static int createcurse_handle(trigger * t, void *data)
{ {
/* call an event handler on createcurse. /* call an event handler on createcurse.
* data.v -> ( variant event, int timer ) * data.v -> ( variant event, int timer )
*/ */
createcurse_data *td = (createcurse_data *) t->data.v; createcurse_data *td = (createcurse_data *)t->data.v;
if (td->mage && td->target && td->mage->number && td->target->number) { if (td->mage && td->target && td->mage->number && td->target->number) {
create_curse(td->mage, &td->target->attribs, create_curse(td->mage, &td->target->attribs,
td->type, td->vigour, td->duration, td->effect, td->men); td->type, td->vigour, td->duration, td->effect, td->men);
} else { }
log_error("could not perform createcurse::handle()\n"); else {
} log_error("could not perform createcurse::handle()\n");
unused_arg(data); }
return 0; unused_arg(data);
return 0;
} }
static void createcurse_write(const trigger * t, struct storage *store) static void createcurse_write(const trigger * t, struct storage *store)
{ {
createcurse_data *td = (createcurse_data *) t->data.v; createcurse_data *td = (createcurse_data *)t->data.v;
write_unit_reference(td->mage, store); write_unit_reference(td->mage, store);
write_unit_reference(td->target, store); write_unit_reference(td->target, store);
WRITE_TOK(store, td->type->cname); WRITE_TOK(store, td->type->cname);
WRITE_FLT(store, (float)td->vigour); WRITE_FLT(store, (float)td->vigour);
WRITE_INT(store, td->duration); WRITE_INT(store, td->duration);
WRITE_FLT(store, (float)td->effect); WRITE_FLT(store, (float)td->effect);
WRITE_INT(store, td->men); WRITE_INT(store, td->men);
} }
static int createcurse_read(trigger * t, struct storage *store) static int createcurse_read(trigger * t, struct storage *store)
{ {
createcurse_data *td = (createcurse_data *) t->data.v; createcurse_data *td = (createcurse_data *)t->data.v;
char zText[128]; char zText[128];
read_reference(&td->mage, store, read_unit_reference, resolve_unit); read_reference(&td->mage, store, read_unit_reference, resolve_unit);
read_reference(&td->target, store, read_unit_reference, resolve_unit); read_reference(&td->target, store, read_unit_reference, resolve_unit);
if (global.data_version < CURSETYPE_VERSION) {
int id1, id2, n;
READ_INT(store, &id1);
READ_INT(store, &id2);
assert(id2 == 0);
READ_FLT(store, &td->vigour);
READ_INT(store, &td->duration);
READ_INT(store, &n);
td->effect = (float)n;
READ_INT(store, &td->men);
td->type = ct_find(oldcursename(id1));
} else {
READ_TOK(store, zText, sizeof(zText)); READ_TOK(store, zText, sizeof(zText));
td->type = ct_find(zText); td->type = ct_find(zText);
READ_FLT(store, &td->vigour); READ_FLT(store, &td->vigour);
READ_INT(store, &td->duration); READ_INT(store, &td->duration);
if (global.data_version < CURSEFLOAT_VERSION) { if (global.data_version < CURSEFLOAT_VERSION) {
int n; int n;
READ_INT(store, &n); READ_INT(store, &n);
td->effect = (float)n; td->effect = (float)n;
} else { }
READ_FLT(store, &td->effect); else {
READ_FLT(store, &td->effect);
} }
READ_INT(store, &td->men); READ_INT(store, &td->men);
} return AT_READ_OK;
return AT_READ_OK;
} }
trigger_type tt_createcurse = { trigger_type tt_createcurse = {
"createcurse", "createcurse",
createcurse_init, createcurse_init,
createcurse_free, createcurse_free,
createcurse_handle, createcurse_handle,
createcurse_write, createcurse_write,
createcurse_read createcurse_read
}; };
trigger *trigger_createcurse(struct unit * mage, struct unit * target, trigger *trigger_createcurse(struct unit * mage, struct unit * target,
const curse_type * ct, float vigour, int duration, float effect, int men) const curse_type * ct, float vigour, int duration, float effect, int men)
{ {
trigger *t = t_new(&tt_createcurse); trigger *t = t_new(&tt_createcurse);
createcurse_data *td = (createcurse_data *) t->data.v; createcurse_data *td = (createcurse_data *)t->data.v;
td->mage = mage; td->mage = mage;
td->target = target; td->target = target;
td->type = ct; td->type = ct;
td->vigour = vigour; td->vigour = vigour;
td->duration = duration; td->duration = duration;
td->effect = effect; td->effect = effect;
td->men = men; td->men = men;
return t; return t;
} }