static void
lc_write(const struct attrib *a, const void *owner, struct storage *store)
{
building_action *data = (building_action *)a->data.v;
const char *fname = data->fname;
const char *fparam = data->param;
unused_arg(owner);
WRITE_TOK(store, fname);
WRITE_TOK(store, fparam ? fparam : NULLSTRING);
}
void write_triggers(struct storage *store, const trigger * t)
{
while (t) {
if (t->type->write) {
WRITE_TOK(store, t->type->name);
t->type->write(t, store);
}
t = t->next;
}
WRITE_TOK(store, "end");
}
static void
a_writedirection(const attrib * a, const void *owner, struct storage *store)
{
spec_direction *d = (spec_direction *)(a->data.v);
unused_arg(owner);
WRITE_INT(store, d->x);
WRITE_INT(store, d->y);
WRITE_INT(store, d->duration);
WRITE_TOK(store, d->desc);
WRITE_TOK(store, d->keyword);
}
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
write_handler(const attrib * a, const void *owner, struct storage *store)
{
handler_info *hi = (handler_info *)a->data.v;
WRITE_TOK(store, hi->event);
write_triggers(store, hi->triggers);
}
static void
a_writeeffect(const attrib * a, const void *owner, struct storage *store)
{
effect_data *edata = (effect_data *) a->data.v;
WRITE_TOK(store, resourcename(edata->type->itype->rtype, 0));
WRITE_INT(store, edata->value);
}
static void
write_gmcreate(const attrib * a, const void *owner, struct storage *store)
{
const item_type *itype = (const item_type *)a->data.v;
assert(itype);
WRITE_TOK(store, resourcename(itype->rtype, 0));
}
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 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);
}
void a_write(struct storage *store, const attrib * attribs, const void *owner)
{
const attrib *na = attribs;
while (na) {
if (na->type->write) {
assert(na->type->hashkey || !"attribute not registered");
WRITE_TOK(store, na->type->name);
na->type->write(na, owner, store);
na = na->next;
}
else {
na = na->nexttype;
}
}
WRITE_TOK(store, "end");
}
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);
}
void write_borders(struct storage *store)
{
int i;
for (i = 0; i != BORDER_MAXHASH; ++i) {
connection *bhash;
for (bhash = borders[i]; bhash; bhash = bhash->nexthash) {
connection *b;
for (b = bhash; b != NULL; b = b->next) {
if (b->type->valid && !b->type->valid(b))
continue;
WRITE_TOK(store, b->type->__name);
WRITE_INT(store, b->id);
WRITE_INT(store, b->from->uid);
WRITE_INT(store, b->to->uid);
if (b->type->write)
b->type->write(b, store);
WRITE_SECTION(store);
}
}
}
WRITE_TOK(store, "end");
}
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 test_memstream(CuTest *tc) {
storage store;
stream out = { 0 };
char buf[1024];
int val=0;
mstream_init(&out);
binstore_init(&store, &out);
store.handle.data = &out;
WRITE_INT(&store, 999999);
WRITE_TOK(&store, "fortytwo");
WRITE_INT(&store, 42);
out.api->rewind(out.handle);
READ_INT(&store, &val);
READ_TOK(&store, buf, 1024);
CuAssertIntEquals(tc, 999999, val);
CuAssertStrEquals(tc, "fortytwo", buf);
READ_INT(&store, &val);
CuAssertIntEquals(tc, 42, val);
mstream_done(&out);
}
static void xmasgate_write(const trigger * t, struct storage *store)
{
building *b = (building *)t->data.v;
WRITE_TOK(store, itoa36(b->no));
}
void write_race_reference(const race * rc, struct storage *store)
{
WRITE_TOK(store, rc ? rc->_name[0] : "none");
}
static void removecurse_write(const trigger * t, struct storage *store)
{
removecurse_data *td = (removecurse_data *) t->data.v;
WRITE_TOK(store, td->target ? itoa36(td->target->no) : 0);
WRITE_INT(store, td->curse ? td->curse->no : 0);
}
