static void
alp_write(const attrib * a, const void *owner, struct storage *store)
{
alp_data *ad = (alp_data *) a->data.v;
write_unit_reference(ad->mage, store);
write_unit_reference(ad->target, store);
}
static void createcurse_write(const trigger * t, struct storage *store)
{
createcurse_data *td = (createcurse_data *)t->data.v;
write_unit_reference(td->mage, store);
write_unit_reference(td->target, store);
WRITE_TOK(store, td->type->cname);
WRITE_FLT(store, (float)td->vigour);
WRITE_INT(store, td->duration);
WRITE_FLT(store, (float)td->effect);
WRITE_INT(store, td->men);
}
static void wall_write(const connection * b, storage * store)
{
wall_data *fd = (wall_data *)b->data.v;
write_unit_reference(fd->mage, store);
WRITE_INT(store, fd->force);
WRITE_INT(store, fd->countdown);
}
void curse_write(const attrib * a, const void *owner, struct storage *store)
{
unsigned int flags;
curse *c = (curse *) a->data.v;
const curse_type *ct = c->type;
unit *mage = (c->magician && c->magician->number) ? c->magician : NULL;
/* copied from c_clearflag */
flags = (c->flags & ~CURSE_ISNEW) | (c->type->flags & CURSE_ISNEW);
WRITE_INT(store, c->no);
WRITE_TOK(store, ct->cname);
WRITE_INT(store, flags);
WRITE_INT(store, c->duration);
WRITE_FLT(store, (float)c->vigour);
write_unit_reference(mage, store);
WRITE_FLT(store, (float)c->effect);
if (c->type->write)
c->type->write(store, c, owner);
else if (c->type->typ == CURSETYP_UNIT) {
WRITE_INT(store, c->data.i);
}
if (c->type->typ == CURSETYP_REGION) {
write_region_reference((region *) c->data.v, store);
}
}
static void giveitem_write(const trigger * t, struct storage *store)
{
giveitem_data *td = (giveitem_data *)t->data.v;
write_unit_reference(td->u, store);
WRITE_INT(store, td->number);
WRITE_TOK(store, td->itype->rtype->_name);
}
static void unitmessage_write(const trigger * t, struct storage *store)
{
unitmessage_data *td = (unitmessage_data *) t->data.v;
write_unit_reference(td->target, store);
WRITE_TOK(store, td->string);
WRITE_INT(store, td->type);
WRITE_INT(store, td->level);
}
static void shock_write(const trigger * t, struct storage *store)
{
unit *u = (unit *) t->data.v;
trigger *next = t->next;
while (next) {
/* make sure it is unique! */
if (next->type == t->type && next->data.v == t->data.v)
break;
next = next->next;
}
if (next && u) {
log_error("more than one shock-attribut for %s on a unit. FIXED.\n", unitid(u));
write_unit_reference(NULL, store);
} else {
write_unit_reference(u, store);
}
}
static void
object_write(const attrib * a, const void *owner, struct storage *store)
{
const object_data *data = (object_data *) a->data.v;
int type = (int)data->type;
WRITE_TOK(store, data->name);
WRITE_INT(store, type);
switch (data->type) {
case TINTEGER:
WRITE_INT(store, data->data.i);
break;
case TREAL:
WRITE_FLT(store, (float)data->data.real);
break;
case TSTRING:
WRITE_STR(store, data->data.str);
break;
case TUNIT:
write_unit_reference(data->data.u, store);
break;
case TFACTION:
write_faction_reference(data->data.f, store);
break;
case TBUILDING:
write_building_reference(data->data.b, store);
break;
case TSHIP:
/* write_ship_reference(data->data.sh, store); */
assert(!"not implemented");
break;
case TREGION:
write_region_reference(data->data.r, store);
break;
case TNONE:
break;
default:
assert(!"illegal type in object-attribute");
}
}
static void clonedied_write(const trigger * t, struct storage *store)
{
unit *u = (unit *) t->data.v;
write_unit_reference(u, store);
}
