static int createcurse_read(trigger * t, gamedata *data)
{
createcurse_data *td = (createcurse_data *)t->data.v;
char zText[128];
float flt;
read_reference(&td->mage, data, read_unit_reference, resolve_unit);
read_reference(&td->target, data, read_unit_reference, resolve_unit);
READ_TOK(data->store, zText, sizeof(zText));
td->type = ct_find(zText);
READ_FLT(data->store, &flt);
td->vigour = flt;
READ_INT(data->store, &td->duration);
if (data->version < CURSEFLOAT_VERSION) {
int n;
READ_INT(data->store, &n);
td->effect = (float)n;
}
else {
READ_FLT(data->store, &flt);
td->effect = flt;
}
READ_INT(data->store, &td->men);
return AT_READ_OK;
}
static int tolua_storage_read_float(lua_State * L)
{
gamedata *data = (gamedata *)tolua_tousertype(L, 1, 0);
float num;
READ_FLT(data->store, &num);
tolua_pushnumber(L, (lua_Number) num);
return 1;
}
/** reads curses that have been removed from the code */
static int read_ccompat(const char *cursename, struct storage *store)
{
struct compat {
const char *name;
const char *tokens;
} *seek, old_curses[] = { {
"disorientationzone", ""}, {
"shipdisorientation", ""}, {
NULL, NULL}};
for (seek = old_curses; seek->name; ++seek) {
if (strcmp(seek->tokens, cursename) == 0) {
const char *p;
for (p = seek->name; p; ++p) {
switch (*p) {
case 'd':
READ_INT(store, 0);
break;
case 's':
READ_STR(store, 0, 0);
break;
case 't':
READ_TOK(store, 0, 0);
break;
case 'i':
READ_INT(store, 0);
break;
case 'f':
READ_FLT(store, 0);
break;
}
}
return 0;
}
}
return -1;
}
static int object_read(attrib * a, void *owner, struct storage *store)
{
char name[NAMESIZE];
object_data *data = (object_data *) a->data.v;
int result, n;
float flt;
READ_STR(store, name, sizeof(name));
data->name = _strdup(name);
READ_INT(store, &n);
data->type = (object_type)n;
switch (data->type) {
case TINTEGER:
READ_INT(store, &data->data.i);
break;
case TREAL:
READ_FLT(store, &flt);
data->data.real = flt;
break;
case TSTRING:
READ_STR(store, name, sizeof(name));
data->data.str = _strdup(name);
break;
case TBUILDING:
result =
read_reference(&data->data.b, store, read_building_reference,
resolve_building);
if (result == 0 && !data->data.b) {
return AT_READ_FAIL;
}
break;
case TUNIT:
result =
read_reference(&data->data.u, store, read_unit_reference, resolve_unit);
if (result == 0 && !data->data.u) {
return AT_READ_FAIL;
}
break;
case TFACTION:
result =
read_reference(&data->data.f, store, read_faction_reference,
resolve_faction);
if (result == 0 && !data->data.f) {
return AT_READ_FAIL;
}
break;
case TREGION:
result =
read_reference(&data->data.r, store, read_region_reference,
RESOLVE_REGION(global.data_version));
if (result == 0 && !data->data.r) {
return AT_READ_FAIL;
}
break;
case TSHIP:
/* return read_ship_reference(&data->data.sh, store); */
assert(!"not implemented");
break;
case TNONE:
break;
default:
return AT_READ_FAIL;
}
return AT_READ_OK;
}
int curse_read(attrib * a, void *owner, struct storage *store)
{
curse *c = (curse *) a->data.v;
int ur;
char cursename[64];
int n;
int flags;
float flt;
READ_INT(store, &c->no);
chash(c);
READ_TOK(store, cursename, sizeof(cursename));
READ_INT(store, &flags);
READ_INT(store, &c->duration);
if (global.data_version >= CURSEVIGOURISFLOAT_VERSION) {
READ_FLT(store, &flt);
c->vigour = flt;
} else {
READ_INT(store, &n);
c->vigour = (float)n;
}
if (global.data_version < INTPAK_VERSION) {
ur = read_reference(&c->magician, store, read_int, resolve_unit);
} else {
ur = read_reference(&c->magician, store, read_unit_reference, resolve_unit);
}
if (global.data_version < CURSEFLOAT_VERSION) {
READ_INT(store, &n);
c->effect = (float)n;
} else {
READ_FLT(store, &flt);
c->effect = flt;
}
c->type = ct_find(cursename);
if (c->type == NULL) {
int result = read_ccompat(cursename, store);
if (result != 0) {
log_error("missing curse %s, no compatibility code either.\n", cursename);
}
assert(result == 0);
return AT_READ_FAIL;
}
if (global.data_version < CURSEFLAGS_VERSION) {
c_setflag(c, flags);
} else {
c->flags = flags;
}
c_clearflag(c, CURSE_ISNEW);
if (c->type->read)
c->type->read(store, c, owner);
else if (c->type->typ == CURSETYP_UNIT) {
READ_INT(store, &c->data.i);
}
if (c->type->typ == CURSETYP_REGION) {
int rr =
read_reference(&c->data.v, store, read_region_reference,
RESOLVE_REGION(global.data_version));
if (ur == 0 && rr == 0 && !c->data.v) {
return AT_READ_FAIL;
}
}
return AT_READ_OK;
}
