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

Merge pull request from ennorehling/feature/data_version

Browse source 
eliminate global.data_version
This commit is contained in:
Enno Rehling 2016-02-25 16:01:44 +01:00
commit 5fd4d5f30b
71 changed files with 565 additions and 451 deletions

4
src/alchemy.c
View file

@ -33,6 +33,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
/* util includes */ /* util includes */
#include <util/attrib.h> #include <util/attrib.h>
#include <util/gamedata.h>
#include <util/base36.h> #include <util/base36.h>
#include <util/log.h> #include <util/log.h>
#include <util/rand.h> #include <util/rand.h>
@ -301,8 +302,9 @@ a_writeeffect(const attrib * a, const void *owner, struct storage *store)
WRITE_INT(store, edata->value); WRITE_INT(store, edata->value);
} }
static int a_readeffect(attrib * a, void *owner, struct storage *store) static int a_readeffect(attrib * a, void *owner, struct gamedata *data)
{ {
struct storage *store = data->store;
int power; int power;
const resource_type *rtype; const resource_type *rtype;
effect_data *edata = (effect_data *)a->data.v; effect_data *edata = (effect_data *)a->data.v;

7
src/attributes/attributes.c
View file

@ -57,6 +57,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
/* util includes */ /* util includes */
#include <util/attrib.h> #include <util/attrib.h>
#include <util/event.h> #include <util/event.h>
#include <util/gamedata.h>
#include <storage.h> #include <storage.h>
@ -64,12 +65,12 @@ attrib_type at_unitdissolve = {
"unitdissolve", NULL, NULL, NULL, a_writechars, a_readchars "unitdissolve", NULL, NULL, NULL, a_writechars, a_readchars
}; };
static int read_ext(attrib * a, void *owner, struct storage *store) static int read_ext(attrib * a, void *owner, gamedata *data)
{ {
int len; int len;
READ_INT(store, &len); READ_INT(data->store, &len);
store->api->r_bin(store->handle, NULL, (size_t)len); data->store->api->r_bin(data->store->handle, NULL, (size_t)len);
return AT_READ_OK; return AT_READ_OK;
} }

42
src/attributes/dict.c
View file

@ -31,6 +31,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
/* util includes */ /* util includes */
#include <util/attrib.h> #include <util/attrib.h>
#include <util/gamedata.h>
#include <util/resolve.h> #include <util/resolve.h>
#include <storage.h> #include <storage.h>
@ -95,63 +96,64 @@ dict_write(const attrib * a, const void *owner, struct storage *store)
} }
} }
static int dict_read(attrib * a, void *owner, struct storage *store) static int dict_read(attrib * a, void *owner, gamedata *data)
{ {
storage *store = data->store;
char name[NAMESIZE]; char name[NAMESIZE];
dict_data *data = (dict_data *)a->data.v; dict_data *dd = (dict_data *)a->data.v;
int result, n; int result, n;
float flt; float flt;
READ_STR(store, name, sizeof(name)); READ_STR(store, name, sizeof(name));
data->name = _strdup(name); dd->name = _strdup(name);
READ_INT(store, &n); READ_INT(store, &n);
data->type = (dict_type)n; dd->type = (dict_type)n;
switch (data->type) { switch (dd->type) {
case TINTEGER: case TINTEGER:
READ_INT(store, &data->data.i); READ_INT(store, &dd->data.i);
break; break;
case TREAL: case TREAL:
READ_FLT(store, &flt); READ_FLT(store, &flt);
if ((int)flt == flt) { if ((int)flt == flt) {
data->type = TINTEGER; dd->type = TINTEGER;
data->data.i = (int)flt; dd->data.i = (int)flt;
} }
else { else {
data->data.real = flt; dd->data.real = flt;
} }
break; break;
case TSTRING: case TSTRING:
READ_STR(store, name, sizeof(name)); READ_STR(store, name, sizeof(name));
data->data.str = _strdup(name); dd->data.str = _strdup(name);
break; break;
case TBUILDING: case TBUILDING:
result = result =
read_reference(&data->data.b, store, read_building_reference, read_reference(&dd->data.b, data, read_building_reference,
resolve_building); resolve_building);
if (result == 0 && !data->data.b) { if (result == 0 && !dd->data.b) {
return AT_READ_FAIL; return AT_READ_FAIL;
} }
break; break;
case TUNIT: case TUNIT:
result = result =
read_reference(&data->data.u, store, read_unit_reference, resolve_unit); read_reference(&dd->data.u, data, read_unit_reference, resolve_unit);
if (result == 0 && !data->data.u) { if (result == 0 && !dd->data.u) {
return AT_READ_FAIL; return AT_READ_FAIL;
} }
break; break;
case TFACTION: case TFACTION:
result = result =
read_reference(&data->data.f, store, read_faction_reference, read_reference(&dd->data.f, data, read_faction_reference,
resolve_faction); resolve_faction);
if (result == 0 && !data->data.f) { if (result == 0 && !dd->data.f) {
return AT_READ_FAIL; return AT_READ_FAIL;
} }
break; break;
case TREGION: case TREGION:
result = result =
read_reference(&data->data.r, store, read_region_reference, read_reference(&dd->data.r, data, read_region_reference,
RESOLVE_REGION(global.data_version)); RESOLVE_REGION(data->version));
if (result == 0 && !data->data.r) { if (result == 0 && !dd->data.r) {
return AT_READ_FAIL; return AT_READ_FAIL;
} }
break; break;

5
src/attributes/follow.c
View file

@ -23,13 +23,14 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <kernel/unit.h> #include <kernel/unit.h>
#include <util/attrib.h> #include <util/attrib.h>
#include <util/gamedata.h>
#include <util/variant.h> #include <util/variant.h>
#include <storage.h> #include <storage.h>
static int read_follow(attrib * a, void *owner, struct storage *store) static int read_follow(attrib * a, void *owner, gamedata *data)
{ {
read_unit_reference(store); /* skip it */ read_unit_reference(data); /* skip it */
return AT_READ_FAIL; return AT_READ_FAIL;
} }

7
src/attributes/hate.c
View file

@ -24,6 +24,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <kernel/version.h> #include <kernel/version.h>
#include <util/attrib.h> #include <util/attrib.h>
#include <util/gamedata.h>
#include <util/resolve.h> #include <util/resolve.h>
#include <storage.h> #include <storage.h>
@ -43,10 +44,10 @@ write_hate(const attrib * a, const void *owner, struct storage *store)
write_unit_reference((unit *)a->data.v, store); write_unit_reference((unit *)a->data.v, store);
} }
static int read_hate(attrib * a, void *owner, struct storage *store) static int read_hate(attrib * a, void *owner, gamedata *data)
{ {
int result = int result = read_reference(&a->data.v, data, read_unit_reference,
read_reference(&a->data.v, store, read_unit_reference, resolve_unit); resolve_unit);
if (result == 0 && !a->data.v) { if (result == 0 && !a->data.v) {
return AT_READ_FAIL; return AT_READ_FAIL;
} }

11
src/attributes/key.c
View file

@ -22,6 +22,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <kernel/save.h> #include <kernel/save.h>
#include <util/attrib.h> #include <util/attrib.h>
#include <util/gamedata.h>
#include <storage.h> #include <storage.h>
#include <stdlib.h> #include <stdlib.h>
@ -35,20 +36,20 @@ static void a_writekeys(const attrib *a, const void *o, storage *store) {
} }
} }
static int a_readkeys(attrib * a, void *owner, struct storage *store) { static int a_readkeys(attrib * a, void *owner, gamedata *data) {
int i, *p = 0; int i, *p = 0;
READ_INT(store, &i); READ_INT(data->store, &i);
assert(i < 4096 && i>0); assert(i < 4096 && i>0);
a->data.v = p = malloc(sizeof(int)*(i + 1)); a->data.v = p = malloc(sizeof(int)*(i + 1));
*p++ = i; *p++ = i;
while (i--) { while (i--) {
READ_INT(store, p++); READ_INT(data->store, p++);
} }
return AT_READ_OK; return AT_READ_OK;
} }
static int a_readkey(attrib *a, void *owner, struct storage *store) { static int a_readkey(attrib *a, void *owner, struct gamedata *data) {
int res = a_readint(a, owner, store); int res = a_readint(a, owner, data);
return (res != AT_READ_FAIL) ? AT_READ_DEPR : res; return (res != AT_READ_FAIL) ? AT_READ_DEPR : res;
} }

5
src/attributes/moved.c
View file

@ -21,6 +21,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include "moved.h" #include "moved.h"
#include <util/attrib.h> #include <util/attrib.h>
#include <util/gamedata.h>
#include <storage.h> #include <storage.h>
@ -37,9 +38,9 @@ write_moved(const attrib * a, const void *owner, struct storage *store)
WRITE_INT(store, a->data.i); WRITE_INT(store, a->data.i);
} }
static int read_moved(attrib * a, void *owner, struct storage *store) static int read_moved(attrib * a, void *owner, gamedata *data)
{ {
READ_INT(store, &a->data.i); READ_INT(data->store, &a->data.i);
if (a->data.i != 0) if (a->data.i != 0)
return AT_READ_OK; return AT_READ_OK;
else else

5
src/attributes/movement.c
View file

@ -22,6 +22,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <kernel/save.h> #include <kernel/save.h>
#include <util/attrib.h> #include <util/attrib.h>
#include <util/gamedata.h>
#include <storage.h> #include <storage.h>
@ -34,9 +35,9 @@ write_movement(const attrib * a, const void *owner, struct storage *store)
WRITE_INT(store, a->data.i); WRITE_INT(store, a->data.i);
} }
static int read_movement(attrib * a, void *owner, struct storage *store) static int read_movement(attrib * a, void *owner, gamedata *data)
{ {
READ_INT(store, &a->data.i); READ_INT(data->store, &a->data.i);
if (a->data.i != 0) if (a->data.i != 0)
return AT_READ_OK; return AT_READ_OK;
else else

5
src/attributes/otherfaction.c
View file

@ -24,6 +24,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <kernel/faction.h> #include <kernel/faction.h>
#include <kernel/unit.h> #include <kernel/unit.h>
#include <util/attrib.h> #include <util/attrib.h>
#include <util/gamedata.h>
#include <storage.h> #include <storage.h>
#include <assert.h> #include <assert.h>
@ -38,11 +39,11 @@ void write_of(const struct attrib *a, const void *owner, struct storage *store)
WRITE_INT(store, f->no); WRITE_INT(store, f->no);
} }
int read_of(struct attrib *a, void *owner, struct storage *store) int read_of(struct attrib *a, void *owner, gamedata *data)
{ /* return 1 on success, 0 if attrib needs removal */ { /* return 1 on success, 0 if attrib needs removal */
int of; int of;
READ_INT(store, &of); READ_INT(data->store, &of);
if (rule_stealth_other()) { if (rule_stealth_other()) {
a->data.v = findfaction(of); a->data.v = findfaction(of);
if (a->data.v) { if (a->data.v) {

8
src/attributes/targetregion.c
View file

@ -25,6 +25,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <kernel/version.h> #include <kernel/version.h>
#include <util/attrib.h> #include <util/attrib.h>
#include <util/gamedata.h>
#include <util/resolve.h> #include <util/resolve.h>
#include <storage.h> #include <storage.h>
@ -35,11 +36,10 @@ write_targetregion(const attrib * a, const void *owner, struct storage *store)
write_region_reference((region *)a->data.v, store); write_region_reference((region *)a->data.v, store);
} }
static int read_targetregion(attrib * a, void *owner, struct storage *store) static int read_targetregion(attrib * a, void *owner, gamedata *data)
{ {
int result = int result = read_reference(&a->data.v, data, read_region_reference,
read_reference(&a->data.v, store, read_region_reference, RESOLVE_REGION(data->version));
RESOLVE_REGION(global.data_version));
if (result == 0 && !a->data.v) if (result == 0 && !a->data.v)
return AT_READ_FAIL; return AT_READ_FAIL;
return AT_READ_OK; return AT_READ_OK;

9
src/bind_storage.c
View file

@ -17,6 +17,8 @@ without prior permission by the authors of Eressea.
#include <kernel/save.h> #include <kernel/save.h>
#include <kernel/version.h> #include <kernel/version.h>
#include <util/log.h>
#include <storage.h> #include <storage.h>
#include <stream.h> #include <stream.h>
#include <filestream.h> #include <filestream.h>
@ -26,6 +28,7 @@ without prior permission by the authors of Eressea.
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <stdlib.h> #include <stdlib.h>
#include <errno.h>
#include <tolua.h> #include <tolua.h>
@ -35,11 +38,12 @@ static int tolua_storage_create(lua_State * L)
const char *type = tolua_tostring(L, 2, "rb"); const char *type = tolua_tostring(L, 2, "rb");
gamedata *data; gamedata *data;
data = gamedata_open(filename, type); data = gamedata_open(filename, type, RELEASE_VERSION);
if (data) { if (data) {
tolua_pushusertype(L, (void *)data, TOLUA_CAST "storage"); tolua_pushusertype(L, (void *)data, TOLUA_CAST "storage");
return 1; return 1;
} }
log_error("could not open %s, mode %s (%s).", filename, type, strerror(errno));
return 0; return 0;
} }
@ -97,8 +101,7 @@ static int tolua_storage_tostring(lua_State * L)
{ {
gamedata *data = (gamedata *)tolua_tousertype(L, 1, 0); gamedata *data = (gamedata *)tolua_tousertype(L, 1, 0);
char name[64]; char name[64];
_snprintf(name, sizeof(name), "<storage enc=%d ver=%d>", data->encoding, _snprintf(name, sizeof(name), "<gamedata %p ver=%d>", (void *)data, data->version);
data->version);
lua_pushstring(L, name); lua_pushstring(L, name);
return 1; return 1;
} }

16
src/building_action.c
View file

@ -15,6 +15,7 @@ without prior permission by the authors of Eressea.
#include <kernel/building.h> #include <kernel/building.h>
#include <kernel/version.h> #include <kernel/version.h>
#include <util/attrib.h> #include <util/attrib.h>
#include <util/gamedata.h>
#include <util/log.h> #include <util/log.h>
#include <util/resolve.h> #include <util/resolve.h>
@ -98,14 +99,15 @@ lc_write(const struct attrib *a, const void *owner, struct storage *store)
WRITE_TOK(store, fparam ? fparam : NULLSTRING); WRITE_TOK(store, fparam ? fparam : NULLSTRING);
} }
static int lc_read(struct attrib *a, void *owner, struct storage *store) static int lc_read(struct attrib *a, void *owner, gamedata *data)
{ {
struct storage *store = data->store;
char name[NAMESIZE]; char name[NAMESIZE];
building_action *data = (building_action *)a->data.v; building_action *bd = (building_action *)a->data.v;
building *b = (building *)owner; building *b = (building *)owner;
int result = 0; int result = 0;
if (global.data_version < ATTRIBOWNER_VERSION) { if (data->version < ATTRIBOWNER_VERSION) {
result = read_reference(&b, store, read_building_reference, resolve_building); result = read_reference(&b, data, read_building_reference, resolve_building);
assert(b == owner); assert(b == owner);
} }
READ_TOK(store, name, sizeof(name)); READ_TOK(store, name, sizeof(name));
@ -115,7 +117,7 @@ static int lc_read(struct attrib *a, void *owner, struct storage *store)
b = 0; b = 0;
} }
else { else {
data->fname = _strdup(name); bd->fname = _strdup(name);
} }
READ_TOK(store, name, sizeof(name)); READ_TOK(store, name, sizeof(name));
if (strcmp(name, "tnnL") == 0) { if (strcmp(name, "tnnL") == 0) {
@ -124,9 +126,9 @@ static int lc_read(struct attrib *a, void *owner, struct storage *store)
b = 0; b = 0;
} }
if (strcmp(name, NULLSTRING) == 0) if (strcmp(name, NULLSTRING) == 0)
data->param = 0; bd->param = 0;
else { else {
data->param = _strdup(name); bd->param = _strdup(name);
} }
if (result == 0 && !b) { if (result == 0 && !b) {
return AT_READ_FAIL; return AT_READ_FAIL;

4
src/kernel/building.c
View file

@ -386,10 +386,10 @@ int resolve_building(variant id, void *address)
return result; return result;
} }
variant read_building_reference(struct storage * store) variant read_building_reference(gamedata * data)
{ {
variant result; variant result;
READ_INT(store, &result.i); READ_INT(data->store, &result.i);
return result; return result;
} }

4
src/kernel/building.h
View file

@ -26,6 +26,8 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
extern "C" { extern "C" {
#endif #endif
struct gamedata;
/* maintenance::flags */ /* maintenance::flags */
#define MTF_NONE 0x00 #define MTF_NONE 0x00
#define MTF_VARIABLE 0x01 /* resource usage scales with size */ #define MTF_VARIABLE 0x01 /* resource usage scales with size */
@ -158,7 +160,7 @@ extern "C" {
extern int resolve_building(variant data, void *address); extern int resolve_building(variant data, void *address);
extern void write_building_reference(const struct building *b, extern void write_building_reference(const struct building *b,
struct storage *store); struct storage *store);
extern variant read_building_reference(struct storage *store); extern variant read_building_reference(struct gamedata *data);
extern struct building *findbuilding(int n); extern struct building *findbuilding(int n);

21
src/kernel/connection.c
View file

@ -28,6 +28,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <util/attrib.h> #include <util/attrib.h>
#include <util/bsdstring.h> #include <util/bsdstring.h>
#include <util/gamedata.h>
#include <util/language.h> #include <util/language.h>
#include <util/log.h> #include <util/log.h>
#include <quicklist.h> #include <quicklist.h>
@ -217,8 +218,9 @@ border_type *find_bordertype(const char *name)
return bt; return bt;
} }
void b_read(connection * b, storage * store) void b_read(connection * b, gamedata * data)
{ {
storage * store = data->store;
int n, result = 0; int n, result = 0;
switch (b->type->datatype) { switch (b->type->datatype) {
case VAR_NONE: case VAR_NONE:
@ -529,8 +531,9 @@ static const char *b_nameroad(const connection * b, const region * r,
return buffer; return buffer;
} }
static void b_readroad(connection * b, storage * store) static void b_readroad(connection * b, gamedata * data)
{ {
storage * store = data->store;
int n; int n;
READ_INT(store, &n); READ_INT(store, &n);
b->data.sa[0] = (short)n; b->data.sa[0] = (short)n;
@ -601,8 +604,9 @@ void write_borders(struct storage *store)
WRITE_TOK(store, "end"); WRITE_TOK(store, "end");
} }
int read_borders(struct storage *store) int read_borders(gamedata *data)
{ {
struct storage *store = data->store;
for (;;) { for (;;) {
int bid = 0; int bid = 0;
char zText[32]; char zText[32];
@ -613,7 +617,7 @@ int read_borders(struct storage *store)
if (!strcmp(zText, "end")) if (!strcmp(zText, "end"))
break; break;
READ_INT(store, &bid); READ_INT(store, &bid);
if (global.data_version < UIDHASH_VERSION) { if (data->version < UIDHASH_VERSION) {
int fx, fy, tx, ty; int fx, fy, tx, ty;
READ_INT(store, &fx); READ_INT(store, &fx);
READ_INT(store, &fy); READ_INT(store, &fy);
@ -655,11 +659,12 @@ int read_borders(struct storage *store)
nextborder--; /* new_border erhöht den Wert */ nextborder--; /* new_border erhöht den Wert */
b->id = bid; b->id = bid;
assert(bid <= nextborder); assert(bid <= nextborder);
if (type->read) if (type->read) {
type->read(b, store); type->read(b, data);
if (global.data_version < NOBORDERATTRIBS_VERSION) { }
if (data->version < NOBORDERATTRIBS_VERSION) {
attrib *a = NULL; attrib *a = NULL;
int result = read_attribs(store, &a, b); int result = read_attribs(data, &a, b);
if (border_convert_cb) { if (border_convert_cb) {
border_convert_cb(b, a); border_convert_cb(b, a);
} }

7
src/kernel/connection.h
View file

@ -30,6 +30,7 @@ extern "C" {
struct faction; struct faction;
struct region; struct region;
struct storage; struct storage;
struct gamedata;
struct unit; struct unit;
extern int nextborder; extern int nextborder;
@ -52,7 +53,7 @@ extern "C" {
/* constructor: initialize the connection. allocate extra memory if needed */ /* constructor: initialize the connection. allocate extra memory if needed */
void(*destroy) (connection *); void(*destroy) (connection *);
/* destructor: remove all extra memory for destruction */ /* destructor: remove all extra memory for destruction */
void(*read) (connection *, struct storage *); void(*read) (connection *, struct gamedata *);
void(*write) (const connection *, struct storage *); void(*write) (const connection *, struct storage *);
bool(*block) (const connection *, const struct unit *, bool(*block) (const connection *, const struct unit *,
const struct region * r); const struct region * r);
@ -113,12 +114,12 @@ extern "C" {
void register_bordertype(border_type * type); void register_bordertype(border_type * type);
/* register a new bordertype */ /* register a new bordertype */
int read_borders(struct storage *store); int read_borders(struct gamedata *store);
void write_borders(struct storage *store); void write_borders(struct storage *store);
void age_borders(void); void age_borders(void);
/* provide default implementations for some member functions: */ /* provide default implementations for some member functions: */
void b_read(connection * b, struct storage *store); void b_read(connection * b, struct gamedata *store);
void b_write(const connection * b, struct storage *store); void b_write(const connection * b, struct storage *store);
bool b_blockall(const connection *, const struct unit *, bool b_blockall(const connection *, const struct unit *,
const struct region *); const struct region *);

34
src/kernel/curse.c
View file

@ -35,6 +35,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
/* util includes */ /* util includes */
#include <util/attrib.h> #include <util/attrib.h>
#include <util/base36.h> #include <util/base36.h>
#include <util/gamedata.h>
#include <util/goodies.h> #include <util/goodies.h>
#include <util/language.h> #include <util/language.h>
#include <util/log.h> #include <util/log.h>
@ -184,8 +185,9 @@ static int read_ccompat(const char *cursename, struct storage *store)
return -1; return -1;
} }
int curse_read(attrib * a, void *owner, struct storage *store) int curse_read(attrib * a, void *owner, gamedata *data)
{ {
storage *store = data->store;
curse *c = (curse *)a->data.v; curse *c = (curse *)a->data.v;
int ur; int ur;
char cursename[64]; char cursename[64];
@ -200,13 +202,13 @@ int curse_read(attrib * a, void *owner, struct storage *store)
READ_INT(store, &c->duration); READ_INT(store, &c->duration);
READ_FLT(store, &flt); READ_FLT(store, &flt);
c->vigour = flt; c->vigour = flt;
if (global.data_version < INTPAK_VERSION) { if (data->version < INTPAK_VERSION) {
ur = read_reference(&c->magician, store, read_int, resolve_unit); ur = resolve_unit(read_int(data->store), &c->magician);
} }
else { else {
ur = read_reference(&c->magician, store, read_unit_reference, resolve_unit); ur = read_reference(&c->magician, data, read_unit_reference, resolve_unit);
} }
if (global.data_version < CURSEFLOAT_VERSION) { if (data->version < CURSEFLOAT_VERSION) {
READ_INT(store, &n); READ_INT(store, &n);
c->effect = (float)n; c->effect = (float)n;
} }
@ -224,19 +226,20 @@ int curse_read(attrib * a, void *owner, struct storage *store)
return AT_READ_FAIL; return AT_READ_FAIL;
} }
c->flags = flags; c->flags = flags;
if (global.data_version < EXPLICIT_CURSE_ISNEW_VERSION) { if (data->version < EXPLICIT_CURSE_ISNEW_VERSION) {
c_clearflag(c, CURSE_ISNEW); c_clearflag(c, CURSE_ISNEW);
} }
if (c->type->read) if (c->type->read) {
c->type->read(store, c, owner); c->type->read(data, c, owner);
}
else if (c->type->typ == CURSETYP_UNIT) { else if (c->type->typ == CURSETYP_UNIT) {
READ_INT(store, &c->data.i); READ_INT(store, &c->data.i);
} }
if (c->type->typ == CURSETYP_REGION) { if (c->type->typ == CURSETYP_REGION) {
int rr = int rr =
read_reference(&c->data.v, store, read_region_reference, read_reference(&c->data.v, data, read_region_reference,
RESOLVE_REGION(global.data_version)); RESOLVE_REGION(data->version));
if (ur == 0 && rr == 0 && !c->data.v) { if (ur == 0 && rr == 0 && !c->data.v) {
return AT_READ_FAIL; return AT_READ_FAIL;
} }
@ -253,12 +256,11 @@ void curse_write(const attrib * a, const void *owner, struct storage *store)
unit *mage = (c->magician && c->magician->number) ? c->magician : NULL; unit *mage = (c->magician && c->magician->number) ? c->magician : NULL;
/* copied from c_clearflag */ /* copied from c_clearflag */
if (global.data_version < EXPLICIT_CURSE_ISNEW_VERSION) { #if RELEASE_VERSION < EXPLICIT_CURSE_ISNEW_VERSION
flags = (c->flags & ~CURSE_ISNEW) | (c->type->flags & CURSE_ISNEW); flags = (c->flags & ~CURSE_ISNEW) | (c->type->flags & CURSE_ISNEW);
} #else
else { flags = c->flags | c->type->flags;
flags = c->flags | c->type->flags; #endif
}
WRITE_INT(store, c->no); WRITE_INT(store, c->no);
WRITE_TOK(store, ct->cname); WRITE_TOK(store, ct->cname);

13
src/kernel/curse.h
View file

@ -28,6 +28,8 @@ extern "C" {
struct curse; struct curse;
struct curse_type; struct curse_type;
struct gamedata;
struct storage;
/* Sprueche in der struct region und auf Einheiten, Schiffen oder Burgen /* Sprueche in der struct region und auf Einheiten, Schiffen oder Burgen
* (struct attribute) * (struct attribute)
@ -93,7 +95,7 @@ extern "C" {
* *
* */ * */
#include <util/variant.h> extern struct attrib_type at_curse;
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Zauberwirkungen */ /* Zauberwirkungen */
@ -194,8 +196,8 @@ extern "C" {
struct message *(*curseinfo) (const void *, objtype_t, struct message *(*curseinfo) (const void *, objtype_t,
const struct curse *, int); const struct curse *, int);
void(*change_vigour) (struct curse *, double); void(*change_vigour) (struct curse *, double);
int(*read) (struct storage * store, struct curse *, void *target); int(*read) (struct gamedata *data, struct curse *, void *target);
int(*write) (struct storage * store, const struct curse *, int(*write) (struct storage *store, const struct curse *,
const void *target); const void *target);
int(*cansee) (const struct faction *, const void *, objtype_t, int(*cansee) (const struct faction *, const void *, objtype_t,
const struct curse *, int); const struct curse *, int);
@ -216,10 +218,9 @@ extern "C" {
void free_curses(void); /* de-register all curse-types */ void free_curses(void); /* de-register all curse-types */
extern struct attrib_type at_curse;
void curse_write(const struct attrib *a, const void *owner, void curse_write(const struct attrib *a, const void *owner,
struct storage *store); struct storage *store);
int curse_read(struct attrib *a, void *owner, struct storage *store); int curse_read(struct attrib *a, void *owner, struct gamedata *store);
/* ------------------------------------------------------------- */ /* ------------------------------------------------------------- */
/* Kommentare: /* Kommentare:

23
src/kernel/curse.test.c
View file

@ -5,6 +5,7 @@
#include <kernel/unit.h> #include <kernel/unit.h>
#include <kernel/version.h> #include <kernel/version.h>
#include <util/attrib.h> #include <util/attrib.h>
#include <util/gamedata.h>
#include <util/message.h> #include <util/message.h>
#include <binarystore.h> #include <binarystore.h>
#include <filestream.h> #include <filestream.h>
@ -122,29 +123,21 @@ static void test_memstream(CuTest *tc) {
static void test_write_flag(CuTest *tc) { static void test_write_flag(CuTest *tc) {
curse_fixture fix; curse_fixture fix;
gamedata data;
storage store; storage store;
char buf[1024];
stream out = { 0 };
size_t len;
mstream_init(&out); mstream_init(&data.strm);
binstore_init(&store, &out); gamedata_init(&data, &store, RELEASE_VERSION);
store.handle.data = &out;
setup_curse(&fix, "gbdream"); setup_curse(&fix, "gbdream");
fix.c->flags = 42 | CURSE_ISNEW; fix.c->flags = 42 | CURSE_ISNEW;
curse_write(fix.r->attribs, fix.r, &store); curse_write(fix.r->attribs, fix.r, &store);
out.api->rewind(out.handle); data.strm.api->rewind(data.strm.handle);
len = out.api->read(out.handle, buf, sizeof(buf)); curse_read(fix.r->attribs, fix.r, &data);
buf[len] = '\0';
out.api->rewind(out.handle);
curse_read(fix.r->attribs, fix.r, &store);
CuAssertIntEquals(tc, 42 | CURSE_ISNEW, ((curse *) fix.r->attribs->data.v)->flags); CuAssertIntEquals(tc, 42 | CURSE_ISNEW, ((curse *) fix.r->attribs->data.v)->flags);
global.data_version = RELEASE_VERSION;
CuAssertIntEquals(tc, RELEASE_VERSION, global.data_version);
mstream_done(&out); mstream_done(&data.strm);
binstore_done(&store); gamedata_done(&data);
test_cleanup(); test_cleanup();
} }

4
src/kernel/faction.c
View file

@ -325,10 +325,10 @@ bool checkpasswd(const faction * f, const char *passwd)
return true; return true;
} }
variant read_faction_reference(struct storage * store) variant read_faction_reference(gamedata * data)
{ {
variant id; variant id;
READ_INT(store, &id.i); READ_INT(data->store, &id.i);
return id; return id;
} }

3
src/kernel/faction.h
View file

@ -30,6 +30,7 @@ extern "C" {
struct item; struct item;
struct seen_region; struct seen_region;
struct attrib_type; struct attrib_type;
struct gamedata;
extern struct attrib_type at_maxmagicians; extern struct attrib_type at_maxmagicians;
/* SMART_INTERVALS: define to speed up finding the interval of regions that a /* SMART_INTERVALS: define to speed up finding the interval of regions that a
@ -133,7 +134,7 @@ extern "C" {
void write_faction_reference(const struct faction *f, void write_faction_reference(const struct faction *f,
struct storage *store); struct storage *store);
variant read_faction_reference(struct storage *store); variant read_faction_reference(struct gamedata *store);
int resolve_faction(variant data, void *addr); int resolve_faction(variant data, void *addr);
void renumber_faction(faction * f, int no); void renumber_faction(faction * f, int no);

11
src/kernel/group.c
View file

@ -33,6 +33,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
/* util includes */ /* util includes */
#include <util/attrib.h> #include <util/attrib.h>
#include <util/base36.h> #include <util/base36.h>
#include <util/gamedata.h>
#include <util/resolve.h> #include <util/resolve.h>
#include <util/unicode.h> #include <util/unicode.h>
@ -95,8 +96,9 @@ static group *find_group(int gid)
return g; return g;
} }
static int read_group(attrib * a, void *owner, struct storage *store) static int read_group(attrib * a, void *owner, gamedata *data)
{ {
struct storage *store = data->store;
group *g; group *g;
int gid; int gid;
@ -215,8 +217,9 @@ void write_groups(struct storage *store, const faction * f)
WRITE_INT(store, 0); WRITE_INT(store, 0);
} }
void read_groups(struct storage *store, faction * f) void read_groups(gamedata *data, faction * f)
{ {
struct storage *store = data->store;
for (;;) { for (;;) {
ally **pa; ally **pa;
group *g; group *g;
@ -233,7 +236,7 @@ void read_groups(struct storage *store, faction * f)
ally *a; ally *a;
variant fid; variant fid;
fid = read_faction_reference(store); fid = read_faction_reference(data);
if (fid.i <= 0) if (fid.i <= 0)
break; break;
a = ally_add(pa, findfaction(fid.i)); a = ally_add(pa, findfaction(fid.i));
@ -241,6 +244,6 @@ void read_groups(struct storage *store, faction * f)
if (!a->faction) if (!a->faction)
ur_add(fid, &a->faction, resolve_faction); ur_add(fid, &a->faction, resolve_faction);
} }
read_attribs(store, &g->attribs, g); read_attribs(data, &g->attribs, g);
} }
} }

2
src/kernel/group.h
View file

@ -43,7 +43,7 @@ extern "C" {
struct group *new_group(struct faction * f, const char *name, int gid); struct group *new_group(struct faction * f, const char *name, int gid);
extern void write_groups(struct storage *data, const struct faction *f); extern void write_groups(struct storage *data, const struct faction *f);
extern void read_groups(struct storage *data, struct faction *f); extern void read_groups(struct gamedata *data, struct faction *f);
#ifdef __cplusplus #ifdef __cplusplus
} }

35
src/kernel/group.test.c
View file

@ -5,8 +5,13 @@
#include "faction.h" #include "faction.h"
#include "unit.h" #include "unit.h"
#include "region.h" #include "region.h"
#include "save.h"
#include "version.h"
#include <util/gamedata.h>
#include <util/attrib.h> #include <util/attrib.h>
#include <attributes/key.h> #include <attributes/key.h>
#include <stream.h> #include <stream.h>
#include <filestream.h> #include <filestream.h>
#include <storage.h> #include <storage.h>
@ -21,35 +26,29 @@ static void test_group_readwrite(CuTest * tc)
faction * f; faction * f;
group *g; group *g;
ally *al; ally *al;
storage store;
FILE *F;
stream strm;
int i; int i;
gamedata *data;
F = fopen("test.dat", "wb");
fstream_init(&strm, F);
binstore_init(&store, &strm);
test_cleanup(); test_cleanup();
test_create_world(); data = gamedata_open("test.dat", "wb", RELEASE_VERSION);
CuAssertPtrNotNull(tc, data);
f = test_create_faction(0); f = test_create_faction(0);
g = new_group(f, "NW", 42); g = new_group(f, "NW", 42);
g = new_group(f, "Egoisten", 43); g = new_group(f, "Egoisten", 43);
key_set(&g->attribs, 44); key_set(&g->attribs, 44);
al = ally_add(&g->allies, f); al = ally_add(&g->allies, f);
al->status = HELP_GIVE; al->status = HELP_GIVE;
write_groups(&store, f); write_groups(data->store, f);
WRITE_INT(&store, 47); WRITE_INT(data->store, 47);
binstore_done(&store); binstore_done(data->store);
fstream_done(&strm); gamedata_close(data);
F = fopen("test.dat", "rb");
fstream_init(&strm, F);
binstore_init(&store, &strm);
f->groups = 0; f->groups = 0;
read_groups(&store, f); free_group(g);
READ_INT(&store, &i); data = gamedata_open("test.dat", "rb", RELEASE_VERSION);
binstore_done(&store); read_groups(data, f);
fstream_done(&strm); READ_INT(data->store, &i);
gamedata_close(data);
CuAssertIntEquals(tc, 47, i); CuAssertIntEquals(tc, 47, i);
CuAssertPtrNotNull(tc, f->groups); CuAssertPtrNotNull(tc, f->groups);

10
src/kernel/region.c
View file

@ -42,6 +42,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
/* util includes */ /* util includes */
#include <util/attrib.h> #include <util/attrib.h>
#include <util/bsdstring.h> #include <util/bsdstring.h>
#include <util/gamedata.h>
#include <util/strings.h> #include <util/strings.h>
#include <util/lists.h> #include <util/lists.h>
#include <util/log.h> #include <util/log.h>
@ -176,12 +177,12 @@ void a_initmoveblock(attrib * a)
a->data.v = calloc(1, sizeof(moveblock)); a->data.v = calloc(1, sizeof(moveblock));
} }
int a_readmoveblock(attrib * a, void *owner, struct storage *store) int a_readmoveblock(attrib * a, void *owner, gamedata *data)
{ {
moveblock *m = (moveblock *)(a->data.v); moveblock *m = (moveblock *)(a->data.v);
int i; int i;
READ_INT(store, &i); READ_INT(data->store, &i);
m->dir = (direction_t)i; m->dir = (direction_t)i;
return AT_READ_OK; return AT_READ_OK;
} }
@ -1225,10 +1226,11 @@ int resolve_region_id(variant id, void *address)
return 0; return 0;
} }
variant read_region_reference(struct storage * store) variant read_region_reference(gamedata *data)
{ {
struct storage * store = data->store;
variant result; variant result;
if (global.data_version < UIDHASH_VERSION) { if (data->version < UIDHASH_VERSION) {
int n; int n;
READ_INT(store, &n); READ_INT(store, &n);
result.sa[0] = (short)n; result.sa[0] = (short)n;

11
src/kernel/region.h
View file

@ -18,9 +18,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#ifndef H_KRNL_REGION #ifndef H_KRNL_REGION
#define H_KRNL_REGION #define H_KRNL_REGION
#ifdef __cplusplus
extern "C" {
#endif
#include <stddef.h> #include <stddef.h>
#include "types.h" #include "types.h"
@ -67,6 +64,7 @@ extern "C" {
struct rawmaterial; struct rawmaterial;
struct item; struct item;
struct faction; struct faction;
struct gamedata;
#define MORALE_TAX_FACTOR 0.005 /* 0.5% tax per point of morale */ #define MORALE_TAX_FACTOR 0.005 /* 0.5% tax per point of morale */
#define MORALE_MAX 10 /* Maximum morale allowed */ #define MORALE_MAX 10 /* Maximum morale allowed */
@ -76,6 +74,11 @@ extern "C" {
#define MORALE_AVERAGE 6 /* default average time for morale to change */ #define MORALE_AVERAGE 6 /* default average time for morale to change */
#define MORALE_TRANSFER 2 /* points of morale lost when GIVE COMMAND */ #define MORALE_TRANSFER 2 /* points of morale lost when GIVE COMMAND */
#ifdef __cplusplus
extern "C" {
#endif
typedef struct region_owner { typedef struct region_owner {
struct faction *owner; struct faction *owner;
struct faction *last_owner; struct faction *last_owner;
@ -255,7 +258,7 @@ extern "C" {
void region_set_morale(region * r, int morale, int turn); void region_set_morale(region * r, int morale, int turn);
void write_region_reference(const struct region *r, struct storage *store); void write_region_reference(const struct region *r, struct storage *store);
variant read_region_reference(struct storage *store); variant read_region_reference(struct gamedata *data);
int resolve_region_coor(variant id, void *address); int resolve_region_coor(variant id, void *address);
int resolve_region_id(variant id, void *address); int resolve_region_id(variant id, void *address);
#define RESOLVE_REGION(version) ((version<UIDHASH_VERSION)?resolve_region_coor:resolve_region_id) #define RESOLVE_REGION(version) ((version<UIDHASH_VERSION)?resolve_region_coor:resolve_region_id)

134
src/kernel/save.c
View file

@ -59,7 +59,9 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <util/bsdstring.h> #include <util/bsdstring.h>
#include <util/event.h> #include <util/event.h>
#include <util/filereader.h> #include <util/filereader.h>
#include <util/gamedata.h>
#include <util/goodies.h> #include <util/goodies.h>
#include <util/gamedata.h>
#include <util/language.h> #include <util/language.h>
#include <util/lists.h> #include <util/lists.h>
#include <util/log.h> #include <util/log.h>
@ -417,11 +419,12 @@ void read_items(struct storage *store, item ** ilist)
} }
} }
static void read_alliances(struct storage *store) static void read_alliances(struct gamedata *data)
{ {
storage *store = data->store;
char pbuf[8]; char pbuf[8];
int id, terminator = 0; int id, terminator = 0;
if (global.data_version < ALLIANCELEADER_VERSION) { if (data->version < ALLIANCELEADER_VERSION) {
terminator = atoi36("end"); terminator = atoi36("end");
READ_STR(store, pbuf, sizeof(pbuf)); READ_STR(store, pbuf, sizeof(pbuf));
id = atoi36(pbuf); id = atoi36(pbuf);
@ -434,11 +437,11 @@ static void read_alliances(struct storage *store)
alliance *al; alliance *al;
READ_STR(store, aname, sizeof(aname)); READ_STR(store, aname, sizeof(aname));
al = makealliance(id, aname); al = makealliance(id, aname);
if (global.data_version >= OWNER_2_VERSION) { if (data->version >= OWNER_2_VERSION) {
READ_INT(store, &al->flags); READ_INT(store, &al->flags);
} }
if (global.data_version >= ALLIANCELEADER_VERSION) { if (data->version >= ALLIANCELEADER_VERSION) {
read_reference(&al->_leader, store, read_faction_reference, read_reference(&al->_leader, data, read_faction_reference,
resolve_faction); resolve_faction);
READ_INT(store, &id); READ_INT(store, &id);
} }
@ -525,7 +528,7 @@ static void read_owner(struct gamedata *data, region_owner ** powner)
else { else {
owner->last_owner = NULL; owner->last_owner = NULL;
} }
read_reference(owner, data->store, &read_faction_reference, &resolve_owner); read_reference(owner, data, &read_faction_reference, &resolve_owner);
*powner = owner; *powner = owner;
} }
else { else {
@ -581,12 +584,12 @@ writeorder(struct gamedata *data, const struct order *ord,
WRITE_STR(data->store, obuf); WRITE_STR(data->store, obuf);
} }
int read_attribs(storage *store, attrib **alist, void *owner) { int read_attribs(gamedata *data, attrib **alist, void *owner) {
if (global.data_version < ATHASH_VERSION) { if (data->version < ATHASH_VERSION) {
return a_read_orig(store, alist, owner); return a_read_orig(data, alist, owner);
} }
else { else {
return a_read(store, alist, owner); return a_read(data, alist, owner);
} }
} }
@ -770,7 +773,7 @@ unit *read_unit(struct gamedata *data)
log_error("Einheit %s hat %u Personen, und %u Trefferpunkte\n", itoa36(u->no), u->number, u->hp); log_error("Einheit %s hat %u Personen, und %u Trefferpunkte\n", itoa36(u->no), u->number, u->hp);
u->hp = u->number; u->hp = u->number;
} }
read_attribs(data->store, &u->attribs, u); read_attribs(data, &u->attribs, u);
return u; return u;
} }
@ -1004,7 +1007,7 @@ static region *readregion(struct gamedata *data, int x, int y)
read_owner(data, &r->land->ownership); read_owner(data, &r->land->ownership);
} }
} }
read_attribs(data->store, &r->attribs, r); read_attribs(data, &r->attribs, r);
return r; return r;
} }
@ -1126,14 +1129,14 @@ int get_spell_level_faction(const spell * sp, void * cbdata)
return 0; return 0;
} }
void read_spellbook(spellbook **bookp, struct storage *store, int(*get_level)(const spell * sp, void *), void * cbdata) void read_spellbook(spellbook **bookp, gamedata *data, int(*get_level)(const spell * sp, void *), void * cbdata)
{ {
for (;;) { for (;;) {
spell *sp = 0; spell *sp = 0;
char spname[64]; char spname[64];
int level = 0; int level = 0;
READ_TOK(store, spname, sizeof(spname)); READ_TOK(data->store, spname, sizeof(spname));
if (strcmp(spname, "end") == 0) if (strcmp(spname, "end") == 0)
break; break;
if (bookp) { if (bookp) {
@ -1142,8 +1145,8 @@ void read_spellbook(spellbook **bookp, struct storage *store, int(*get_level)(co
log_error("read_spells: could not find spell '%s'\n", spname); log_error("read_spells: could not find spell '%s'\n", spname);
} }
} }
if (global.data_version >= SPELLBOOK_VERSION) { if (data->version >= SPELLBOOK_VERSION) {
READ_INT(store, &level); READ_INT(data->store, &level);
} }
if (sp) { if (sp) {
spellbook * sb = *bookp; spellbook * sb = *bookp;
@ -1154,7 +1157,7 @@ void read_spellbook(spellbook **bookp, struct storage *store, int(*get_level)(co
*bookp = create_spellbook(0); *bookp = create_spellbook(0);
sb = *bookp; sb = *bookp;
} }
if (level > 0 && (global.data_version >= SPELLBOOK_VERSION || !spellbook_get(sb, sp))) { if (level > 0 && (data->version >= SPELLBOOK_VERSION || !spellbook_get(sb, sp))) {
spellbook_add(sb, sp, level); spellbook_add(sb, sp, level);
} }
} }
@ -1326,7 +1329,7 @@ faction *readfaction(struct gamedata * data)
} }
} }
read_attribs(data->store, &f->attribs, f); read_attribs(data, &f->attribs, f);
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));
@ -1369,10 +1372,10 @@ faction *readfaction(struct gamedata * data)
break; break;
} }
} }
read_groups(data->store, f); read_groups(data, f);
f->spellbook = 0; f->spellbook = 0;
if (data->version >= REGIONOWNER_VERSION) { if (data->version >= REGIONOWNER_VERSION) {
read_spellbook(FactionSpells() ? &f->spellbook : 0, data->store, get_spell_level_faction, (void *)f); read_spellbook(FactionSpells() ? &f->spellbook : 0, data, get_spell_level_faction, (void *)f);
} }
return f; return f;
} }
@ -1496,11 +1499,9 @@ int readgame(const char *filename, bool backup)
assert(gdata.version >= MIN_VERSION || !"unsupported data format"); assert(gdata.version >= MIN_VERSION || !"unsupported data format");
assert(gdata.version <= MAX_VERSION || !"unsupported data format"); assert(gdata.version <= MAX_VERSION || !"unsupported data format");
gdata.encoding = enc_gamedata;
fstream_init(&strm, F); fstream_init(&strm, F);
binstore_init(&store, &strm); binstore_init(&store, &strm);
gdata.store = &store; gdata.store = &store;
global.data_version = gdata.version; /* HACK: attribute::read does not have access to gamedata, only storage */
if (gdata.version >= BUILDNO_VERSION) { if (gdata.version >= BUILDNO_VERSION) {
int build; int build;
@ -1525,7 +1526,7 @@ int readgame(const char *filename, bool backup)
else { else {
READ_STR(&store, NULL, 0); READ_STR(&store, NULL, 0);
} }
read_attribs(&store, &global.attribs, NULL); read_attribs(&gdata, &global.attribs, NULL);
READ_INT(&store, &turn); READ_INT(&store, &turn);
global.data_turn = turn; global.data_turn = turn;
log_debug(" - reading turn %d\n", turn); log_debug(" - reading turn %d\n", turn);
@ -1577,20 +1578,20 @@ int readgame(const char *filename, bool backup)
else { else {
/* WATCHERS - eliminated in February 2016, ca. turn 966 */ /* WATCHERS - eliminated in February 2016, ca. turn 966 */
if (gdata.version < NOWATCH_VERSION) { if (gdata.version < NOWATCH_VERSION) {
fno = read_faction_reference(&store); fno = read_faction_reference(&gdata);
while (fno.i) { while (fno.i) {
fno = read_faction_reference(&store); fno = read_faction_reference(&gdata);
} }
} }
} }
read_attribs(&store, &pl->attribs, pl); read_attribs(&gdata, &pl->attribs, pl);
if (pl->id != 1094969858) { // Regatta if (pl->id != 1094969858) { // Regatta
addlist(&planes, pl); addlist(&planes, pl);
} }
} }
/* Read factions */ /* Read factions */
read_alliances(&store); read_alliances(&gdata);
READ_INT(&store, &nread); READ_INT(&store, &nread);
log_debug(" - Einzulesende Parteien: %d\n", nread); log_debug(" - Einzulesende Parteien: %d\n", nread);
fp = &factions; fp = &factions;
@ -1651,7 +1652,7 @@ int readgame(const char *filename, bool backup)
READ_STR(&store, name, sizeof(name)); READ_STR(&store, name, sizeof(name));
b->type = bt_find(name); b->type = bt_find(name);
b->region = r; b->region = r;
read_attribs(&store, &b->attribs, b); read_attribs(&gdata, &b->attribs, b);
if (b->type == bt_lighthouse) { if (b->type == bt_lighthouse) {
r->flags |= RF_LIGHTHOUSE; r->flags |= RF_LIGHTHOUSE;
} }
@ -1698,7 +1699,7 @@ int readgame(const char *filename, bool backup)
if (sh->type->flags & SFL_NOCOAST) { if (sh->type->flags & SFL_NOCOAST) {
sh->coast = NODIRECTION; sh->coast = NODIRECTION;
} }
read_attribs(&store, &sh->attribs, sh); read_attribs(&gdata, &sh->attribs, sh);
} }
*shp = 0; *shp = 0;
@ -1726,7 +1727,7 @@ int readgame(const char *filename, bool backup)
update_interval(u->faction, u->region); update_interval(u->faction, u->region);
} }
} }
read_borders(&store); read_borders(&gdata);
binstore_done(&store); binstore_done(&store);
fstream_done(&strm); fstream_done(&strm);
@ -1757,7 +1758,7 @@ int readgame(const char *filename, bool backup)
} }
else { else {
for (u = f->units; u; u = u->nextF) { for (u = f->units; u; u = u->nextF) {
if (global.data_version < SPELL_LEVEL_VERSION) { if (gdata.version < SPELL_LEVEL_VERSION) {
sc_mage *mage = get_mage(u); sc_mage *mage = get_mage(u);
if (mage) { if (mage) {
faction *f = u->faction; faction *f = u->faction;
@ -1776,12 +1777,12 @@ int readgame(const char *filename, bool backup)
} }
if (u->number > 0) { if (u->number > 0) {
f->_alive = true; f->_alive = true;
if (global.data_version >= SPELL_LEVEL_VERSION) { if (gdata.version >= SPELL_LEVEL_VERSION) {
break; break;
} }
} }
} }
if (global.data_version < SPELL_LEVEL_VERSION && f->spellbook) { if (gdata.version < SPELL_LEVEL_VERSION && f->spellbook) {
spellbook_foreach(f->spellbook, cb_sb_maxlevel, f); spellbook_foreach(f->spellbook, cb_sb_maxlevel, f);
} }
} }
@ -1832,9 +1833,7 @@ int writegame(const char *filename)
} }
gdata.store = &store; gdata.store = &store;
gdata.encoding = enc_gamedata;
gdata.version = RELEASE_VERSION; gdata.version = RELEASE_VERSION;
global.data_version = RELEASE_VERSION;
n = STREAM_VERSION; n = STREAM_VERSION;
fwrite(&gdata.version, sizeof(int), 1, F); fwrite(&gdata.version, sizeof(int), 1, F);
fwrite(&n, sizeof(int), 1, F); fwrite(&n, sizeof(int), 1, F);
@ -1954,55 +1953,10 @@ int writegame(const char *filename)
return 0; return 0;
} }
void gamedata_close(gamedata *data) { int a_readint(attrib * a, void *owner, struct gamedata *data)
binstore_done(data->store);
fstream_done(&data->strm);
}
gamedata *gamedata_open(const char *filename, const char *mode) {
FILE *F = fopen(filename, mode);
if (F) {
gamedata *data = (gamedata *)calloc(1, sizeof(gamedata));
storage *store = (storage *)calloc(1, sizeof(storage));
int err = 0;
size_t sz;
data->store = store;
if (strchr(mode, 'r')) {
sz = fread(&data->version, 1, sizeof(int), F);
if (sz != sizeof(int)) {
err = ferror(F);
}
else {
err = fseek(F, sizeof(int), SEEK_CUR);
}
}
else if (strchr(mode, 'w')) {
int n = STREAM_VERSION;
data->version = RELEASE_VERSION;
fwrite(&data->version, sizeof(int), 1, F);
fwrite(&n, sizeof(int), 1, F);
}
if (err) {
fclose(F);
free(data);
free(store);
}
else {
fstream_init(&data->strm, F);
binstore_init(store, &data->strm);
return data;
}
}
log_error("could not open %s: %s", filename, strerror(errno));
return 0;
}
int a_readint(attrib * a, void *owner, struct storage *store)
{ {
/* assert(sizeof(int)==sizeof(a->data)); */ /* assert(sizeof(int)==sizeof(a->data)); */
READ_INT(store, &a->data.i); READ_INT(data->store, &a->data.i);
return AT_READ_OK; return AT_READ_OK;
} }
@ -2011,12 +1965,12 @@ void a_writeint(const attrib * a, const void *owner, struct storage *store)
WRITE_INT(store, a->data.i); WRITE_INT(store, a->data.i);
} }
int a_readshorts(attrib * a, void *owner, struct storage *store) int a_readshorts(attrib * a, void *owner, struct gamedata *data)
{ {
int n; int n;
READ_INT(store, &n); READ_INT(data->store, &n);
a->data.sa[0] = (short)n; a->data.sa[0] = (short)n;
READ_INT(store, &n); READ_INT(data->store, &n);
a->data.sa[1] = (short)n; a->data.sa[1] = (short)n;
return AT_READ_OK; return AT_READ_OK;
} }
@ -2027,12 +1981,12 @@ void a_writeshorts(const attrib * a, const void *owner, struct storage *store)
WRITE_INT(store, a->data.sa[1]); WRITE_INT(store, a->data.sa[1]);
} }
int a_readchars(attrib * a, void *owner, struct storage *store) int a_readchars(attrib * a, void *owner, struct gamedata *data)
{ {
int i; int i;
for (i = 0; i != 4; ++i) { for (i = 0; i != 4; ++i) {
int n; int n;
READ_INT(store, &n); READ_INT(data->store, &n);
a->data.ca[i] = (char)n; a->data.ca[i] = (char)n;
} }
return AT_READ_OK; return AT_READ_OK;
@ -2047,7 +2001,7 @@ void a_writechars(const attrib * a, const void *owner, struct storage *store)
} }
} }
int a_readvoid(attrib * a, void *owner, struct storage *store) int a_readvoid(attrib * a, void *owner, struct gamedata *data)
{ {
return AT_READ_OK; return AT_READ_OK;
} }
@ -2056,14 +2010,14 @@ void a_writevoid(const attrib * a, const void *owner, struct storage *store)
{ {
} }
int a_readstring(attrib * a, void *owner, struct storage *store) int a_readstring(attrib * a, void *owner, struct gamedata *data)
{ {
char buf[DISPLAYSIZE]; char buf[DISPLAYSIZE];
char * result = 0; char * result = 0;
int e; int e;
size_t len = 0; size_t len = 0;
do { do {
e = READ_STR(store, buf, sizeof(buf)); e = READ_STR(data->store, buf, sizeof(buf));
if (result) { if (result) {
result = realloc(result, len + DISPLAYSIZE - 1); result = realloc(result, len + DISPLAYSIZE - 1);
strcpy(result + len, buf); strcpy(result + len, buf);

30
src/kernel/save.h
View file

@ -20,6 +20,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#define H_KRNL_SAVE #define H_KRNL_SAVE
#include <stream.h> #include <stream.h>
#include <util/gamedata.h> // FIXME: eliminate include dependency from this file
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
@ -30,13 +31,7 @@ extern "C" {
struct spell; struct spell;
struct spellbook; struct spellbook;
struct unit; struct unit;
struct gamedata;
typedef struct gamedata {
struct storage *store;
stream strm;
int version;
int encoding;
} gamedata;
#define MAX_INPUT_SIZE DISPLAYSIZE*2 #define MAX_INPUT_SIZE DISPLAYSIZE*2
/* Nach MAX_INPUT_SIZE brechen wir das Einlesen der Zeile ab und nehmen an, /* Nach MAX_INPUT_SIZE brechen wir das Einlesen der Zeile ab und nehmen an,
@ -55,37 +50,34 @@ extern "C" {
void read_items(struct storage *store, struct item **it); void read_items(struct storage *store, struct item **it);
void write_items(struct storage *store, struct item *it); void write_items(struct storage *store, struct item *it);
void read_spellbook(struct spellbook **bookp, struct storage *store, int(*get_level)(const struct spell * sp, void *), void * cbdata); void read_spellbook(struct spellbook **bookp, struct gamedata *data, int(*get_level)(const struct spell * sp, void *), void * cbdata);
void write_spellbook(const struct spellbook *book, struct storage *store); void write_spellbook(const struct spellbook *book, struct storage *store);
void write_attribs(struct storage *store, struct attrib *alist, const void *owner); void write_attribs(struct storage *store, struct attrib *alist, const void *owner);
int read_attribs(struct storage *store, struct attrib **alist, void *owner); int read_attribs(struct gamedata *store, struct attrib **alist, void *owner);
void write_unit(struct gamedata *data, const struct unit *u); void write_unit(struct gamedata *data, const struct unit *u);
struct unit *read_unit(struct gamedata *data); struct unit *read_unit(struct gamedata *data);
int a_readint(struct attrib *a, void *owner, struct storage *store); int a_readint(struct attrib *a, void *owner, struct gamedata *);
void a_writeint(const struct attrib *a, const void *owner, void a_writeint(const struct attrib *a, const void *owner,
struct storage *store); struct storage *store);
int a_readshorts(struct attrib *a, void *owner, struct storage *store); int a_readshorts(struct attrib *a, void *owner, struct gamedata *);
void a_writeshorts(const struct attrib *a, const void *owner, void a_writeshorts(const struct attrib *a, const void *owner,
struct storage *store); struct storage *store);
int a_readchars(struct attrib *a, void *owner, struct storage *store); int a_readchars(struct attrib *a, void *owner, struct gamedata *);
void a_writechars(const struct attrib *a, const void *owner, void a_writechars(const struct attrib *a, const void *owner,
struct storage *store); struct storage *store);
int a_readvoid(struct attrib *a, void *owner, struct storage *store); int a_readvoid(struct attrib *a, void *owner, struct gamedata *);
void a_writevoid(const struct attrib *a, const void *owner, void a_writevoid(const struct attrib *a, const void *owner,
struct storage *store); struct storage *);
int a_readstring(struct attrib *a, void *owner, struct storage *store); int a_readstring(struct attrib *a, void *owner, struct gamedata *);
void a_writestring(const struct attrib *a, const void *owner, void a_writestring(const struct attrib *a, const void *owner,
struct storage *store); struct storage *);
void a_finalizestring(struct attrib *a); void a_finalizestring(struct attrib *a);
void create_backup(char *file); void create_backup(char *file);
struct gamedata *gamedata_open(const char *filename, const char *mode);
void gamedata_close(struct gamedata *data);
/* test-only functions that give access to internal implementation details (BAD) */ /* test-only functions that give access to internal implementation details (BAD) */
void _test_write_password(struct gamedata *data, const struct faction *f); void _test_write_password(struct gamedata *data, const struct faction *f);
void _test_read_password(struct gamedata *data, struct faction *f); void _test_read_password(struct gamedata *data, struct faction *f);

62
src/kernel/save.test.c
View file

@ -1,6 +1,7 @@
#include <platform.h> #include <platform.h>
#include <kernel/config.h> #include <kernel/config.h>
#include <util/attrib.h> #include <util/attrib.h>
#include <util/gamedata.h>
#include <attributes/key.h> #include <attributes/key.h>
#include "save.h" #include "save.h"
@ -11,6 +12,7 @@
#include "plane.h" #include "plane.h"
#include "region.h" #include "region.h"
#include "version.h" #include "version.h"
#include <triggers/changefaction.h> #include <triggers/changefaction.h>
#include <triggers/createunit.h> #include <triggers/createunit.h>
#include <triggers/timeout.h> #include <triggers/timeout.h>
@ -19,6 +21,8 @@
#include <util/base36.h> #include <util/base36.h>
#include <util/password.h> #include <util/password.h>
#include <storage.h>
#include <memstream.h>
#include <CuTest.h> #include <CuTest.h>
#include <tests.h> #include <tests.h>
@ -33,7 +37,6 @@ static void test_readwrite_data(CuTest * tc)
test_cleanup(); test_cleanup();
CuAssertIntEquals(tc, 0, writegame(filename)); CuAssertIntEquals(tc, 0, writegame(filename));
CuAssertIntEquals(tc, 0, readgame(filename, false)); CuAssertIntEquals(tc, 0, readgame(filename, false));
CuAssertIntEquals(tc, RELEASE_VERSION, global.data_version);
join_path(datapath(), filename, path, sizeof(path)); join_path(datapath(), filename, path, sizeof(path));
CuAssertIntEquals(tc, 0, remove(path)); CuAssertIntEquals(tc, 0, remove(path));
test_cleanup(); test_cleanup();
@ -41,69 +44,60 @@ static void test_readwrite_data(CuTest * tc)
static void test_readwrite_unit(CuTest * tc) static void test_readwrite_unit(CuTest * tc)
{ {
const char *filename = "test.dat"; gamedata data;
char path[MAX_PATH]; storage store;
gamedata *data;
struct unit *u; struct unit *u;
struct region *r; struct region *r;
struct faction *f; struct faction *f;
int fno; int fno;
/* FIXME: at some point during this test, errno is set to 17 (File exists), why? */
create_directories();
test_cleanup(); test_cleanup();
r = test_create_region(0, 0, 0); r = test_create_region(0, 0, 0);
f = test_create_faction(0); f = test_create_faction(0);
fno = f->no; fno = f->no;
u = test_create_unit(f, r); u = test_create_unit(f, r);
join_path(datapath(), filename, path, sizeof(path));
data = gamedata_open(path, "wb"); mstream_init(&data.strm);
CuAssertPtrNotNull(tc, data); // TODO: intermittent test (even after the 'b' fix!) gamedata_init(&data, &store, RELEASE_VERSION);
write_unit(&data, u);
write_unit(data, u);
gamedata_close(data);
data.strm.api->rewind(data.strm.handle);
free_gamedata(); free_gamedata();
f = test_create_faction(0); f = test_create_faction(0);
renumber_faction(f, fno); renumber_faction(f, fno);
data = gamedata_open(path, "rb"); gamedata_init(&data, &store, RELEASE_VERSION);
CuAssertPtrNotNull(tc, data); u = read_unit(&data);
mstream_done(&data.strm);
u = read_unit(data); gamedata_done(&data);
gamedata_close(data);
CuAssertPtrNotNull(tc, u); CuAssertPtrNotNull(tc, u);
CuAssertPtrEquals(tc, f, u->faction); CuAssertPtrEquals(tc, f, u->faction);
CuAssertPtrEquals(tc, 0, u->region); CuAssertPtrEquals(tc, 0, u->region);
CuAssertIntEquals(tc, 0, remove(path));
test_cleanup(); test_cleanup();
} }
static void test_readwrite_attrib(CuTest *tc) { static void test_readwrite_attrib(CuTest *tc) {
gamedata *data; gamedata data;
storage store;
attrib *a = NULL; attrib *a = NULL;
const char *path = "attrib.dat";
test_cleanup(); test_cleanup();
global.data_version = RELEASE_VERSION; // FIXME: hack!
data = gamedata_open(path, "wb");
CuAssertPtrNotNull(tc, data);
key_set(&a, 41); key_set(&a, 41);
key_set(&a, 42); key_set(&a, 42);
write_attribs(data->store, a, NULL); mstream_init(&data.strm);
gamedata_close(data); gamedata_init(&data, &store, RELEASE_VERSION);
write_attribs(data.store, a, NULL);
a_removeall(&a, NULL); a_removeall(&a, NULL);
CuAssertPtrEquals(tc, 0, a); CuAssertPtrEquals(tc, 0, a);
data = gamedata_open(path, "rb"); data.strm.api->rewind(data.strm.handle);
CuAssertPtrNotNull(tc, data); read_attribs(&data, &a, NULL);
read_attribs(data->store, &a, NULL); mstream_done(&data.strm);
gamedata_close(data); gamedata_done(&data);
CuAssertTrue(tc, key_get(a, 41)); CuAssertTrue(tc, key_get(a, 41));
CuAssertTrue(tc, key_get(a, 42)); CuAssertTrue(tc, key_get(a, 42));
a_removeall(&a, NULL); a_removeall(&a, NULL);
CuAssertIntEquals(tc, 0, remove(path));
test_cleanup(); test_cleanup();
} }
@ -237,11 +231,11 @@ static void test_read_password(CuTest *tc) {
faction *f; faction *f;
f = test_create_faction(0); f = test_create_faction(0);
faction_setpassword(f, password_encode("secret", PASSWORD_DEFAULT)); faction_setpassword(f, password_encode("secret", PASSWORD_DEFAULT));
data = gamedata_open(path, "wb"); data = gamedata_open(path, "wb", RELEASE_VERSION);
CuAssertPtrNotNull(tc, data); CuAssertPtrNotNull(tc, data);
_test_write_password(data, f); _test_write_password(data, f);
gamedata_close(data); gamedata_close(data);
data = gamedata_open(path, "rb"); data = gamedata_open(path, "rb", RELEASE_VERSION);
CuAssertPtrNotNull(tc, data); CuAssertPtrNotNull(tc, data);
_test_read_password(data, f); _test_read_password(data, f);
gamedata_close(data); gamedata_close(data);
@ -259,12 +253,12 @@ static void test_read_password_external(CuTest *tc) {
f = test_create_faction(0); f = test_create_faction(0);
faction_setpassword(f, password_encode("secret", PASSWORD_DEFAULT)); faction_setpassword(f, password_encode("secret", PASSWORD_DEFAULT));
CuAssertPtrNotNull(tc, f->_password); CuAssertPtrNotNull(tc, f->_password);
data = gamedata_open(path, "wb"); data = gamedata_open(path, "wb", RELEASE_VERSION);
CuAssertPtrNotNull(tc, data); CuAssertPtrNotNull(tc, data);
WRITE_TOK(data->store, (const char *)f->_password); WRITE_TOK(data->store, (const char *)f->_password);
WRITE_TOK(data->store, (const char *)f->_password); WRITE_TOK(data->store, (const char *)f->_password);
gamedata_close(data); gamedata_close(data);
data = gamedata_open(path, "rb"); data = gamedata_open(path, "rb", RELEASE_VERSION);
CuAssertPtrNotNull(tc, data); CuAssertPtrNotNull(tc, data);
data->version = BADCRYPT_VERSION; data->version = BADCRYPT_VERSION;
_test_read_password(data, f); _test_read_password(data, f);

43
src/kernel/unit.c
View file

@ -52,6 +52,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <util/base36.h> #include <util/base36.h>
#include <util/bsdstring.h> #include <util/bsdstring.h>
#include <util/event.h> #include <util/event.h>
#include <util/gamedata.h>
#include <util/strings.h> #include <util/strings.h>
#include <util/language.h> #include <util/language.h>
#include <util/lists.h> #include <util/lists.h>
@ -116,9 +117,9 @@ unit *findunitr(const region * r, int n)
{ {
unit *u; unit *u;
/* findunit regional! */ /* findunit regional! */
assert(n>0); assert(n > 0);
u = ufindhash(n); u = ufindhash(n);
return (u && u->region==r)?u:0; return (u && u->region == r) ? u : 0;
} }
// TODO: deprecated, replace with findunit(n) // TODO: deprecated, replace with findunit(n)
@ -443,8 +444,9 @@ int ualias(const unit * u)
return a->data.i; return a->data.i;
} }
int a_readprivate(attrib * a, void *owner, struct storage *store) int a_readprivate(attrib * a, void *owner, gamedata *data)
{ {
struct storage *store = data->store;
char lbuf[DISPLAYSIZE]; char lbuf[DISPLAYSIZE];
READ_STR(store, lbuf, sizeof(lbuf)); READ_STR(store, lbuf, sizeof(lbuf));
a->data.v = _strdup(lbuf); a->data.v = _strdup(lbuf);
@ -579,9 +581,9 @@ void a_writesiege(const attrib * a, const void *owner, struct storage *store)
write_building_reference(b, store); write_building_reference(b, store);
} }
int a_readsiege(attrib * a, void *owner, struct storage *store) int a_readsiege(attrib * a, void *owner, gamedata *data)
{ {
int result = read_reference(&a->data.v, store, read_building_reference, int result = read_reference(&a->data.v, data, read_building_reference,
resolve_building); resolve_building);
if (result == 0 && !a->data.v) { if (result == 0 && !a->data.v) {
return AT_READ_FAIL; return AT_READ_FAIL;
@ -656,7 +658,7 @@ bool ucontact(const unit * u, const unit * u2)
/* Explizites KONTAKTIERE */ /* Explizites KONTAKTIERE */
for (ru = a_find(u->attribs, &at_contact); ru && ru->type == &at_contact; for (ru = a_find(u->attribs, &at_contact); ru && ru->type == &at_contact;
ru = ru->next) { ru = ru->next) {
if (((unit *)ru->data.v) == u2) { if (((unit *)ru->data.v) == u2) {
return true; return true;
} }
@ -698,10 +700,10 @@ int resolve_unit(variant id, void *address)
return 0; return 0;
} }
variant read_unit_reference(struct storage * store) variant read_unit_reference(gamedata *data)
{ {
variant var; variant var;
READ_INT(store, &var.i); READ_INT(data->store, &var.i);
return var; return var;
} }
@ -830,7 +832,7 @@ bool can_leave(unit * u)
rule_leave = config_get_int("rules.move.owner_leave", 0); rule_leave = config_get_int("rules.move.owner_leave", 0);
if (rule_leave!=0 && u->building && u == building_owner(u->building)) { if (rule_leave != 0 && u->building && u == building_owner(u->building)) {
return false; return false;
} }
return true; return true;
@ -1001,7 +1003,7 @@ void transfermen(unit * u, unit * dst, int n)
set_leftship(dst, sh); set_leftship(dst, sh);
dst->flags |= dst->flags |=
u->flags & (UFL_LONGACTION | UFL_NOTMOVING | UFL_HUNGER | UFL_MOVED | u->flags & (UFL_LONGACTION | UFL_NOTMOVING | UFL_HUNGER | UFL_MOVED |
UFL_ENTER); UFL_ENTER);
if (u->attribs) { if (u->attribs) {
transfer_curse(u, dst, n); transfer_curse(u, dst, n);
} }
@ -1132,8 +1134,8 @@ bool learn_skill(unit * u, skill_t sk, double learn_chance)
{ {
skill *sv = u->skills; skill *sv = u->skills;
if (learn_chance < 1.0 && rng_int() % 10000 >= learn_chance * 10000) if (learn_chance < 1.0 && rng_int() % 10000 >= learn_chance * 10000)
if (!chance(learn_chance)) if (!chance(learn_chance))
return false; return false;
while (sv != u->skills + u->skill_size) { while (sv != u->skills + u->skill_size) {
assert(sv->weeks > 0); assert(sv->weeks > 0);
if (sv->id == sk) { if (sv->id == sk) {
@ -1280,7 +1282,8 @@ static int att_modification(const unit * u, skill_t sk)
bool allied = alliedunit(c->magician, u->faction, HELP_GUARD); bool allied = alliedunit(c->magician, u->faction, HELP_GUARD);
if (allied) { if (allied) {
if (effect > bonus) bonus = effect; if (effect > bonus) bonus = effect;
} else { }
else {
if (effect < malus) malus = effect; if (effect < malus) malus = effect;
} }
} }
@ -1329,7 +1332,7 @@ int eff_skill(const unit * u, const skill *sv, const region *r)
{ {
assert(u); assert(u);
if (!r) r = u->region; if (!r) r = u->region;
if (sv && sv->level>0) { if (sv && sv->level > 0) {
int mlevel = sv->level + get_modifier(u, sv->id, sv->level, r, false); int mlevel = sv->level + get_modifier(u, sv->id, sv->level, r, false);
if (mlevel > 0) { if (mlevel > 0) {
@ -1418,10 +1421,10 @@ void default_name(const unit *u, char name[], int len) {
static const char * prefix[MAXLOCALES]; static const char * prefix[MAXLOCALES];
int i = locale_index(lang); int i = locale_index(lang);
/*if (!prefix[i]) {*/ /*if (!prefix[i]) {*/
prefix[i] = LOC(lang, "unitdefault"); prefix[i] = LOC(lang, "unitdefault");
if (!prefix[i]) { if (!prefix[i]) {
prefix[i] = parameters[P_UNIT]; prefix[i] = parameters[P_UNIT];
} }
/*}*/ /*}*/
result = prefix[i]; result = prefix[i];
} }
@ -1733,7 +1736,7 @@ void scale_number(unit * u, int n)
} }
if (u->number > 0) { if (u->number > 0) {
for (a = a_find(u->attribs, &at_effect); a && a->type == &at_effect; for (a = a_find(u->attribs, &at_effect); a && a->type == &at_effect;
a = a->next) { a = a->next) {
effect_data *data = (effect_data *)a->data.v; effect_data *data = (effect_data *)a->data.v;
int snew = data->value / u->number * n; int snew = data->value / u->number * n;
if (n) { if (n) {
@ -1893,7 +1896,7 @@ static double produceexp_chance(void) {
return config_get_flt("study.from_use", 1.0 / 3); return config_get_flt("study.from_use", 1.0 / 3);
} }
void produceexp_ex(struct unit *u, skill_t sk, int n, bool (*learn)(unit *, skill_t, double)) void produceexp_ex(struct unit *u, skill_t sk, int n, bool(*learn)(unit *, skill_t, double))
{ {
if (n != 0 && (is_monsters(u->faction) || playerrace(u_race(u)))) { if (n != 0 && (is_monsters(u->faction) || playerrace(u_race(u)))) {
double chance = produceexp_chance(); double chance = produceexp_chance();

4
src/kernel/unit.h
View file

@ -30,7 +30,7 @@ extern "C" {
struct skill; struct skill;
struct item; struct item;
struct sc_mage; struct sc_mage;
struct gamedata;
#define UFL_DEAD (1<<0) #define UFL_DEAD (1<<0)
#define UFL_ISNEW (1<<1) /* 2 */ #define UFL_ISNEW (1<<1) /* 2 */
#define UFL_LONGACTION (1<<2) /* 4 */ #define UFL_LONGACTION (1<<2) /* 4 */
@ -186,7 +186,7 @@ extern "C" {
/* see resolve.h */ /* see resolve.h */
int resolve_unit(variant data, void *address); int resolve_unit(variant data, void *address);
void write_unit_reference(const struct unit *u, struct storage *store); void write_unit_reference(const struct unit *u, struct storage *store);
variant read_unit_reference(struct storage *store); variant read_unit_reference(struct gamedata *data);
bool leave(struct unit *u, bool force); bool leave(struct unit *u, bool force);
bool can_leave(struct unit *u); bool can_leave(struct unit *u);

8
src/kernel/version.h
View file

@ -35,10 +35,8 @@
#define ATTRIBOWNER_VERSION 350 /* all attrib_type functions know who owns the attribute */ #define ATTRIBOWNER_VERSION 350 /* all attrib_type functions know who owns the attribute */
#define BADCRYPT_VERSION 351 /* passwords are encrypted, poorly */ #define BADCRYPT_VERSION 351 /* passwords are encrypted, poorly */
#define ATHASH_VERSION 352 /* attribute-type hash, not name */ #define ATHASH_VERSION 352 /* attribute-type hash, not name */
#define CRYPT_VERSION 353 /* passwords are encrypted */ #define NOWATCH_VERSION 353 /* plane->watchers is gone */
#define NOWATCH_VERSION 354 /* plane->watchers is gone */ #define CRYPT_VERSION 354 /* passwords are encrypted */
#define RELEASE_VERSION ATHASH_VERSION /* current datafile */ #define RELEASE_VERSION NOWATCH_VERSION /* current datafile */
#define MIN_VERSION INTPAK_VERSION /* minimal datafile we support */ #define MIN_VERSION INTPAK_VERSION /* minimal datafile we support */
#define MAX_VERSION RELEASE_VERSION /* change this if we can need to read the future datafile, and we can do so */ #define MAX_VERSION RELEASE_VERSION /* change this if we can need to read the future datafile, and we can do so */
#define STREAM_VERSION 2 /* internal encoding of binary files */

38
src/magic.c
View file

@ -54,7 +54,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
/* util includes */ /* util includes */
#include <util/attrib.h> #include <util/attrib.h>
#include <critbit.h> #include <util/gamedata.h>
#include <util/language.h> #include <util/language.h>
#include <util/lists.h> #include <util/lists.h>
#include <util/log.h> #include <util/log.h>
@ -67,6 +67,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <util/base36.h> #include <util/base36.h>
#include <util/event.h> #include <util/event.h>
#include <critbit.h>
#include <storage.h> #include <storage.h>
/* libc includes */ /* libc includes */
@ -128,16 +129,17 @@ typedef struct icastle_data {
int time; int time;
} icastle_data; } icastle_data;
static int a_readicastle(attrib * a, void *owner, struct storage *store) static int a_readicastle(attrib * a, void *owner, struct gamedata *data)
{ {
icastle_data *data = (icastle_data *)a->data.v; storage *store = data->store;
icastle_data *idata = (icastle_data *)a->data.v;
char token[32]; char token[32];
READ_TOK(store, token, sizeof(token)); READ_TOK(store, token, sizeof(token));
if (global.data_version < ATTRIBOWNER_VERSION) { if (data->version < ATTRIBOWNER_VERSION) {
READ_INT(store, NULL); READ_INT(store, NULL);
} }
READ_INT(store, &data->time); READ_INT(store, &idata->time);
data->type = bt_find(token); idata->type = bt_find(token);
return AT_READ_OK; return AT_READ_OK;
} }
@ -254,8 +256,9 @@ int get_spell_level_mage(const spell * sp, void * cbdata)
return sbe ? sbe->level : 0; return sbe ? sbe->level : 0;
} }
static int read_mage(attrib * a, void *owner, struct storage *store) static int read_mage(attrib * a, void *owner, struct gamedata *data)
{ {
storage *store = data->store;
int i, mtype; int i, mtype;
sc_mage *mage = (sc_mage *)a->data.v; sc_mage *mage = (sc_mage *)a->data.v;
char spname[64]; char spname[64];
@ -291,10 +294,10 @@ static int read_mage(attrib * a, void *owner, struct storage *store)
} }
} }
if (mage->magietyp == M_GRAY) { if (mage->magietyp == M_GRAY) {
read_spellbook(&mage->spellbook, store, get_spell_level_mage, mage); read_spellbook(&mage->spellbook, data, get_spell_level_mage, mage);
} }
else { else {
read_spellbook(0, store, 0, mage); read_spellbook(0, data, 0, mage);
} }
return AT_READ_OK; return AT_READ_OK;
} }
@ -362,8 +365,9 @@ sc_mage *get_mage(const unit * u)
* Spruch zu seiner List-of-known-spells hinzugefügt werden. * Spruch zu seiner List-of-known-spells hinzugefügt werden.
*/ */
static int read_seenspell(attrib * a, void *owner, struct storage *store) static int read_seenspell(attrib * a, void *owner, struct gamedata *data)
{ {
storage *store = data->store;
int i; int i;
spell *sp = 0; spell *sp = 0;
char token[32]; char token[32];
@ -374,7 +378,7 @@ static int read_seenspell(attrib * a, void *owner, struct storage *store)
sp = find_spellbyid((unsigned int)i); sp = find_spellbyid((unsigned int)i);
} }
else { else {
if (global.data_version < UNIQUE_SPELLS_VERSION) { if (data->version < UNIQUE_SPELLS_VERSION) {
READ_INT(store, 0); /* ignore mtype */ READ_INT(store, 0); /* ignore mtype */
} }
sp = find_spell(token); sp = find_spell(token);
@ -2281,10 +2285,10 @@ static int resolve_familiar(variant data, void *addr)
return result; return result;
} }
static int read_familiar(attrib * a, void *owner, struct storage *store) static int read_familiar(attrib * a, void *owner, struct gamedata *data)
{ {
int result = int result =
read_reference(&a->data.v, store, read_unit_reference, resolve_familiar); read_reference(&a->data.v, data, read_unit_reference, resolve_familiar);
if (result == 0 && a->data.v == NULL) { if (result == 0 && a->data.v == NULL) {
return AT_READ_FAIL; return AT_READ_FAIL;
} }
@ -2365,10 +2369,10 @@ static int resolve_clone(variant data, void *addr)
return result; return result;
} }
static int read_clone(attrib * a, void *owner, struct storage *store) static int read_clone(attrib * a, void *owner, struct gamedata *data)
{ {
int result = int result =
read_reference(&a->data.v, store, read_unit_reference, resolve_clone); read_reference(&a->data.v, data, read_unit_reference, resolve_clone);
if (result == 0 && a->data.v == NULL) { if (result == 0 && a->data.v == NULL) {
return AT_READ_FAIL; return AT_READ_FAIL;
} }
@ -2392,10 +2396,10 @@ static int resolve_mage(variant data, void *addr)
return result; return result;
} }
static int read_magician(attrib * a, void *owner, struct storage *store) static int read_magician(attrib * a, void *owner, struct gamedata *data)
{ {
int result = int result =
read_reference(&a->data.v, store, read_unit_reference, resolve_mage); read_reference(&a->data.v, data, read_unit_reference, resolve_mage);
if (result == 0 && a->data.v == NULL) { if (result == 0 && a->data.v == NULL) {
return AT_READ_FAIL; return AT_READ_FAIL;
} }

9
src/modules/arena.c
View file

@ -48,6 +48,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <util/attrib.h> #include <util/attrib.h>
#include <util/base36.h> #include <util/base36.h>
#include <util/event.h> #include <util/event.h>
#include <util/gamedata.h>
#include <util/functions.h> #include <util/functions.h>
#include <util/strings.h> #include <util/strings.h>
#include <util/lists.h> #include <util/lists.h>
@ -248,10 +249,10 @@ write_hurting(const attrib * a, const void *owner, struct storage *store)
WRITE_INT(store, b->no); WRITE_INT(store, b->no);
} }
static int read_hurting(attrib * a, void *owner, struct storage *store) static int read_hurting(attrib * a, void *owner, struct gamedata *data)
{ {
int i; int i;
READ_INT(store, &i); READ_INT(data->store, &i);
a->data.v = (void *)findbuilding(i); a->data.v = (void *)findbuilding(i);
if (a->data.v == NULL) { if (a->data.v == NULL) {
log_error("temple of pain is broken\n"); log_error("temple of pain is broken\n");
@ -448,10 +449,10 @@ static void caldera_write(const trigger * t, struct storage *store)
write_building_reference(b, store); write_building_reference(b, store);
} }
static int caldera_read(trigger * t, struct storage *store) static int caldera_read(trigger * t, struct gamedata *data)
{ {
int rb = int rb =
read_reference(&t->data.v, store, read_building_reference, read_reference(&t->data.v, data, read_building_reference,
resolve_building); resolve_building);
if (rb == 0 && !t->data.v) { if (rb == 0 && !t->data.v) {
return AT_READ_FAIL; return AT_READ_FAIL;

10
src/modules/gmcmd.c
View file

@ -35,6 +35,8 @@
/* util includes */ /* util includes */
#include <util/attrib.h> #include <util/attrib.h>
#include <util/gamedata.h>
#include <storage.h> #include <storage.h>
/* libc includes */ /* libc includes */
@ -43,18 +45,18 @@
#include <limits.h> #include <limits.h>
#include <assert.h> #include <assert.h>
static int read_permissions(attrib * a, void *owner, struct storage *store) static int read_permissions(attrib * a, void *owner, struct gamedata *data)
{ {
assert(!a); assert(!a);
a_read(store, &a, owner); a_read(data, &a, owner);
a_remove(&a, a); a_remove(&a, a);
return AT_READ_OK; return AT_READ_OK;
} }
static int read_gmcreate(attrib * a, void *owner, struct storage *store) static int read_gmcreate(attrib * a, void *owner, struct gamedata *data)
{ {
char zText[32]; char zText[32];
READ_TOK(store, zText, sizeof(zText)); READ_TOK(data->store, zText, sizeof(zText));
return AT_READ_OK; return AT_READ_OK;
} }

13
src/modules/museum.c
View file

@ -43,6 +43,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <util/attrib.h> #include <util/attrib.h>
#include <util/base36.h> #include <util/base36.h>
#include <util/functions.h> #include <util/functions.h>
#include <util/gamedata.h>
#include <util/strings.h> #include <util/strings.h>
#include <util/language.h> #include <util/language.h>
@ -79,11 +80,11 @@ struct storage *store)
} }
static int static int
a_readmuseumgivebackcookie(attrib * a, void *owner, struct storage *store) a_readmuseumgivebackcookie(attrib * a, void *owner, gamedata *data)
{ {
museumgivebackcookie *gbc = (museumgivebackcookie *)a->data.v; museumgivebackcookie *gbc = (museumgivebackcookie *)a->data.v;
READ_INT(store, &gbc->warden_no); READ_INT(data->store, &gbc->warden_no);
READ_INT(store, &gbc->cookie); READ_INT(data->store, &gbc->cookie);
return AT_READ_OK; return AT_READ_OK;
} }
@ -121,11 +122,11 @@ struct storage *store)
write_items(store, gb->items); write_items(store, gb->items);
} }
static int a_readmuseumgiveback(attrib * a, void *owner, struct storage *store) static int a_readmuseumgiveback(attrib * a, void *owner, struct gamedata *data)
{ {
museumgiveback *gb = (museumgiveback *)a->data.v; museumgiveback *gb = (museumgiveback *)a->data.v;
READ_INT(store, &gb->cookie); READ_INT(data->store, &gb->cookie);
read_items(store, &gb->items); read_items(data->store, &gb->items);
return AT_READ_OK; return AT_READ_OK;
} }

5
src/modules/xmas.c
View file

@ -28,6 +28,7 @@
#include <util/attrib.h> #include <util/attrib.h>
#include <util/base36.h> #include <util/base36.h>
#include <util/event.h> #include <util/event.h>
#include <util/gamedata.h>
#include <util/goodies.h> #include <util/goodies.h>
#include <util/resolve.h> #include <util/resolve.h>
@ -47,10 +48,10 @@ static void xmasgate_write(const trigger * t, struct storage *store)
WRITE_TOK(store, itoa36(b->no)); WRITE_TOK(store, itoa36(b->no));
} }
static int xmasgate_read(trigger * t, struct storage *store) static int xmasgate_read(trigger * t, struct gamedata *data)
{ {
int bc = int bc =
read_reference(&t->data.v, store, read_building_reference, read_reference(&t->data.v, data, read_building_reference,
resolve_building); resolve_building);
if (bc == 0 && !t->data.v) { if (bc == 0 && !t->data.v) {
return AT_READ_FAIL; return AT_READ_FAIL;

4
src/move.c
View file

@ -59,6 +59,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <util/attrib.h> #include <util/attrib.h>
#include <util/base36.h> #include <util/base36.h>
#include <util/bsdstring.h> #include <util/bsdstring.h>
#include <util/gamedata.h>
#include <util/language.h> #include <util/language.h>
#include <util/lists.h> #include <util/lists.h>
#include <util/log.h> #include <util/log.h>
@ -154,8 +155,9 @@ static int shiptrail_age(attrib * a, void *owner)
return (t->age > 0) ? AT_AGE_KEEP : AT_AGE_REMOVE; return (t->age > 0) ? AT_AGE_KEEP : AT_AGE_REMOVE;
} }
static int shiptrail_read(attrib * a, void *owner, struct storage *store) static int shiptrail_read(attrib * a, void *owner, struct gamedata *data)
{ {
storage *store = data->store;
int n; int n;
traveldir *t = (traveldir *)(a->data.v); traveldir *t = (traveldir *)(a->data.v);

4
src/move.test.c
View file

@ -35,8 +35,6 @@ static void test_ship_not_allowed_in_coast(CuTest * tc)
ship_type *stype; ship_type *stype;
test_cleanup(); test_cleanup();
test_create_world();
ttype = test_create_terrain("glacier", LAND_REGION | ARCTIC_REGION | WALK_INTO | SAIL_INTO); ttype = test_create_terrain("glacier", LAND_REGION | ARCTIC_REGION | WALK_INTO | SAIL_INTO);
otype = test_create_terrain("ocean", SEA_REGION | SAIL_INTO); otype = test_create_terrain("ocean", SEA_REGION | SAIL_INTO);
stype = test_create_shiptype("derp"); stype = test_create_shiptype("derp");
@ -50,6 +48,7 @@ static void test_ship_not_allowed_in_coast(CuTest * tc)
CuAssertIntEquals(tc, SA_NO_COAST, check_ship_allowed(sh, r1)); CuAssertIntEquals(tc, SA_NO_COAST, check_ship_allowed(sh, r1));
stype->coasts[0] = ttype; stype->coasts[0] = ttype;
CuAssertIntEquals(tc, SA_COAST, check_ship_allowed(sh, r1)); CuAssertIntEquals(tc, SA_COAST, check_ship_allowed(sh, r1));
test_cleanup();
} }
typedef struct move_fixture { typedef struct move_fixture {
@ -68,7 +67,6 @@ static void setup_harbor(move_fixture *mf) {
unit *u; unit *u;
test_cleanup(); test_cleanup();
test_create_world();
ttype = test_create_terrain("glacier", LAND_REGION | ARCTIC_REGION | WALK_INTO | SAIL_INTO); ttype = test_create_terrain("glacier", LAND_REGION | ARCTIC_REGION | WALK_INTO | SAIL_INTO);
btype = test_create_buildingtype("harbour"); btype = test_create_buildingtype("harbour");

4
src/spells.c
View file

@ -62,6 +62,7 @@
#include <util/attrib.h> #include <util/attrib.h>
#include <util/base36.h> #include <util/base36.h>
#include <util/event.h> #include <util/event.h>
#include <util/gamedata.h>
#include <util/language.h> #include <util/language.h>
#include <util/message.h> #include <util/message.h>
#include <util/parser.h> #include <util/parser.h>
@ -2866,9 +2867,10 @@ static curse *mk_deathcloud(unit * mage, region * r, double force, int duration)
#define COMPAT_DEATHCLOUD #define COMPAT_DEATHCLOUD
#ifdef COMPAT_DEATHCLOUD #ifdef COMPAT_DEATHCLOUD
static int dc_read_compat(struct attrib *a, void *target, struct storage * store) static int dc_read_compat(struct attrib *a, void *target, gamedata *data)
/* return AT_READ_OK on success, AT_READ_FAIL if attrib needs removal */ /* return AT_READ_OK on success, AT_READ_FAIL if attrib needs removal */
{ {
struct storage *store = data->store;
region *r = NULL; region *r = NULL;
unit *u; unit *u;
variant var; variant var;

7
src/spells/alp.c
View file

@ -25,6 +25,7 @@
/* util includes */ /* util includes */
#include <util/attrib.h> #include <util/attrib.h>
#include <util/event.h> #include <util/event.h>
#include <util/gamedata.h>
#include <util/resolve.h> #include <util/resolve.h>
#include <util/umlaut.h> #include <util/umlaut.h>
@ -76,12 +77,12 @@ alp_write(const attrib * a, const void *owner, struct storage *store)
write_unit_reference(ad->target, store); write_unit_reference(ad->target, store);
} }
static int alp_read(attrib * a, void *owner, struct storage *store) static int alp_read(attrib * a, void *owner, struct gamedata *data)
{ {
alp_data *ad = (alp_data *)a->data.v; alp_data *ad = (alp_data *)a->data.v;
int rm = read_reference(&ad->mage, store, read_unit_reference, resolve_unit); int rm = read_reference(&ad->mage, data, read_unit_reference, resolve_unit);
int rt = int rt =
read_reference(&ad->target, store, read_unit_reference, resolve_unit); read_reference(&ad->target, data, read_unit_reference, resolve_unit);
if (rt == 0 && rm == 0 && (!ad->target || !ad->mage)) { if (rt == 0 && rm == 0 && (!ad->target || !ad->mage)) {
/* the target or mage disappeared. */ /* the target or mage disappeared. */
return AT_READ_FAIL; return AT_READ_FAIL;

14
src/spells/borders.c
View file

@ -14,6 +14,7 @@
#include <kernel/version.h> #include <kernel/version.h>
#include <util/attrib.h> #include <util/attrib.h>
#include <util/gamedata.h>
#include <util/language.h> #include <util/language.h>
#include <util/rand.h> #include <util/rand.h>
#include <util/rng.h> #include <util/rng.h>
@ -51,8 +52,9 @@ typedef struct bresolve {
static int resolve_buddy(variant data, void *addr); static int resolve_buddy(variant data, void *addr);
static int cw_read(attrib * a, void *target, storage * store) static int cw_read(attrib * a, void *target, gamedata *data)
{ {
storage *store = data->store;
bresolve *br = calloc(sizeof(bresolve), 1); bresolve *br = calloc(sizeof(bresolve), 1);
curse *c = (curse *)a->data.v; curse *c = (curse *)a->data.v;
wallcurse *wc = (wallcurse *)c->data.v; wallcurse *wc = (wallcurse *)c->data.v;
@ -172,15 +174,15 @@ static void wall_destroy(connection * b)
free(b->data.v); free(b->data.v);
} }
static void wall_read(connection * b, storage * store) static void wall_read(connection * b, gamedata * data)
{ {
static wall_data dummy; static wall_data dummy;
wall_data *fd = b->data.v ? (wall_data *)b->data.v : &dummy; wall_data *fd = b->data.v ? (wall_data *)b->data.v : &dummy;
read_reference(&fd->mage, store, read_unit_reference, resolve_unit); read_reference(&fd->mage, data, read_unit_reference, resolve_unit);
READ_INT(store, &fd->force); READ_INT(data->store, &fd->force);
if (global.data_version >= NOBORDERATTRIBS_VERSION) { if (data->version >= NOBORDERATTRIBS_VERSION) {
READ_INT(store, &fd->countdown); READ_INT(data->store, &fd->countdown);
} }
fd->active = true; fd->active = true;
} }

6
src/spells/flyingship.c
View file

@ -11,6 +11,8 @@
#include <kernel/unit.h> #include <kernel/unit.h>
#include <kernel/ship.h> #include <kernel/ship.h>
#include <util/gamedata.h>
#include <magic.h> #include <magic.h>
#include <spells/shipcurse.h> #include <spells/shipcurse.h>
@ -95,11 +97,11 @@ int sp_flying_ship(castorder * co)
return cast_level; return cast_level;
} }
static int flyingship_read(storage * store, curse * c, void *target) static int flyingship_read(gamedata * data, curse * c, void *target)
{ {
ship *sh = (ship *)target; ship *sh = (ship *)target;
c->data.v = sh; c->data.v = sh;
if (global.data_version < FOSS_VERSION) { if (data->version < FOSS_VERSION) {
sh->flags |= SF_FLYING; sh->flags |= SF_FLYING;
return 0; return 0;
} }

5
src/spells/unitcurse.c
View file

@ -25,6 +25,7 @@
#include <kernel/version.h> #include <kernel/version.h>
/* util includes */ /* util includes */
#include <util/gamedata.h>
#include <util/language.h> #include <util/language.h>
#include <util/nrmessage.h> #include <util/nrmessage.h>
#include <util/message.h> #include <util/message.h>
@ -307,10 +308,10 @@ static struct curse_type ct_oldrace = {
* C_SKILL * C_SKILL
*/ */
static int read_skill(struct storage *store, curse * c, void *target) static int read_skill(gamedata *data, curse * c, void *target)
{ {
int skill; int skill;
READ_INT(store, &skill); READ_INT(data->store, &skill);
c->data.i = skill; c->data.i = skill;
return 0; return 0;
} }

1
src/test_eressea.c
View file

@ -75,6 +75,7 @@ int RunAllTests(int argc, char *argv[])
ADD_SUITE(base36); ADD_SUITE(base36);
ADD_SUITE(bsdstring); ADD_SUITE(bsdstring);
ADD_SUITE(functions); ADD_SUITE(functions);
ADD_SUITE(gamedata);
ADD_SUITE(parser); ADD_SUITE(parser);
ADD_SUITE(password); ADD_SUITE(password);
ADD_SUITE(umlaut); ADD_SUITE(umlaut);

2
src/tests.c
View file

@ -156,7 +156,7 @@ ship_type * test_create_shiptype(const char * name)
stype->coasts = stype->coasts =
(terrain_type **)malloc(sizeof(terrain_type *)*2); (terrain_type **)malloc(sizeof(terrain_type *)*2);
stype->coasts[0] = get_or_create_terrain("plain"); stype->coasts[0] = test_create_terrain("plain", LAND_REGION | FOREST_REGION | WALK_INTO | CAVALRY_REGION | SAIL_INTO | FLY_INTO);
stype->coasts[1] = NULL; stype->coasts[1] = NULL;
if (default_locale) { if (default_locale) {

8
src/triggers/changefaction.c
View file

@ -28,6 +28,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
/* util includes */ /* util includes */
#include <util/attrib.h> #include <util/attrib.h>
#include <util/event.h> #include <util/event.h>
#include <util/gamedata.h>
#include <util/log.h> #include <util/log.h>
#include <util/resolve.h> #include <util/resolve.h>
#include <util/base36.h> #include <util/base36.h>
@ -82,12 +83,13 @@ static void changefaction_write(const trigger * t, struct storage *store)
write_faction_reference(td->faction->_alive ? td->faction : NULL, store); write_faction_reference(td->faction->_alive ? td->faction : NULL, store);
} }
static int changefaction_read(trigger * t, struct storage *store) static int changefaction_read(trigger * t, gamedata *data)
{ {
variant var; variant var;
changefaction_data *td = (changefaction_data *)t->data.v; changefaction_data *td = (changefaction_data *)t->data.v;
read_reference(&td->unit, store, read_unit_reference, resolve_unit);
var = read_faction_reference(store); read_reference(&td->unit, data, read_unit_reference, resolve_unit);
var = read_faction_reference(data);
if (var.i == 0) { if (var.i == 0) {
return AT_READ_FAIL; return AT_READ_FAIL;
} }

9
src/triggers/changerace.c
View file

@ -27,6 +27,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
/* util includes */ /* util includes */
#include <util/attrib.h> #include <util/attrib.h>
#include <util/event.h> #include <util/event.h>
#include <util/gamedata.h>
#include <util/log.h> #include <util/log.h>
#include <util/resolve.h> #include <util/resolve.h>
#include <util/base36.h> #include <util/base36.h>
@ -86,12 +87,12 @@ static void changerace_write(const trigger * t, struct storage *store)
write_race_reference(td->irace, store); write_race_reference(td->irace, store);
} }
static int changerace_read(trigger * t, struct storage *store) static int changerace_read(trigger * t, gamedata *data)
{ {
changerace_data *td = (changerace_data *)t->data.v; changerace_data *td = (changerace_data *)t->data.v;
read_reference(&td->u, store, read_unit_reference, resolve_unit); read_reference(&td->u, data, read_unit_reference, resolve_unit);
td->race = (const struct race *)read_race_reference(store).v; td->race = (const struct race *)read_race_reference(data->store).v;
td->irace = (const struct race *)read_race_reference(store).v; td->irace = (const struct race *)read_race_reference(data->store).v;
return AT_READ_OK; return AT_READ_OK;
} }

5
src/triggers/clonedied.c
View file

@ -29,6 +29,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
/* util includes */ /* util includes */
#include <util/attrib.h> #include <util/attrib.h>
#include <util/event.h> #include <util/event.h>
#include <util/gamedata.h>
#include <util/log.h> #include <util/log.h>
#include <util/resolve.h> #include <util/resolve.h>
#include <util/base36.h> #include <util/base36.h>
@ -68,10 +69,10 @@ static void clonedied_write(const trigger * t, struct storage *store)
write_unit_reference(u, store); write_unit_reference(u, store);
} }
static int clonedied_read(trigger * t, struct storage *store) static int clonedied_read(trigger * t, gamedata *data)
{ {
int result = int result =
read_reference(&t->data.v, store, read_unit_reference, resolve_unit); read_reference(&t->data.v, data, read_unit_reference, resolve_unit);
if (result == 0 && t->data.v == NULL) { if (result == 0 && t->data.v == NULL) {
return AT_READ_FAIL; return AT_READ_FAIL;
} }

21
src/triggers/createcurse.c
View file

@ -28,6 +28,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
/* util includes */ /* util includes */
#include <util/attrib.h> #include <util/attrib.h>
#include <util/event.h> #include <util/event.h>
#include <util/gamedata.h>
#include <util/log.h> #include <util/log.h>
#include <util/resolve.h> #include <util/resolve.h>
#include <util/base36.h> #include <util/base36.h>
@ -93,30 +94,30 @@ static void createcurse_write(const trigger * t, struct storage *store)
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, gamedata *data)
{ {
createcurse_data *td = (createcurse_data *)t->data.v; createcurse_data *td = (createcurse_data *)t->data.v;
char zText[128]; char zText[128];
float flt; float flt;
read_reference(&td->mage, store, read_unit_reference, resolve_unit); read_reference(&td->mage, data, read_unit_reference, resolve_unit);
read_reference(&td->target, store, read_unit_reference, resolve_unit); read_reference(&td->target, data, read_unit_reference, resolve_unit);
READ_TOK(store, zText, sizeof(zText)); READ_TOK(data->store, zText, sizeof(zText));
td->type = ct_find(zText); td->type = ct_find(zText);
READ_FLT(store, &flt); READ_FLT(data->store, &flt);
td->vigour = flt; td->vigour = flt;
READ_INT(store, &td->duration); READ_INT(data->store, &td->duration);
if (global.data_version < CURSEFLOAT_VERSION) { if (data->version < CURSEFLOAT_VERSION) {
int n; int n;
READ_INT(store, &n); READ_INT(data->store, &n);
td->effect = (float)n; td->effect = (float)n;
} }
else { else {
READ_FLT(store, &flt); READ_FLT(data->store, &flt);
td->effect = flt; td->effect = flt;
} }
READ_INT(store, &td->men); READ_INT(data->store, &td->men);
return AT_READ_OK; return AT_READ_OK;
} }

13
src/triggers/createunit.c
View file

@ -31,6 +31,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <util/attrib.h> #include <util/attrib.h>
#include <util/base36.h> #include <util/base36.h>
#include <util/event.h> #include <util/event.h>
#include <util/gamedata.h>
#include <util/log.h> #include <util/log.h>
#include <util/resolve.h> #include <util/resolve.h>
@ -88,12 +89,12 @@ static void createunit_write(const trigger * t, struct storage *store)
WRITE_INT(store, td->number); WRITE_INT(store, td->number);
} }
static int createunit_read(trigger * t, struct storage *store) static int createunit_read(trigger * t, gamedata *data)
{ {
createunit_data *td = (createunit_data *)t->data.v; createunit_data *td = (createunit_data *)t->data.v;
variant var; variant var;
int result = AT_READ_OK; int result = AT_READ_OK;
var = read_faction_reference(store); var = read_faction_reference(data);
if (var.i > 0) { if (var.i > 0) {
td->f = findfaction(var.i); td->f = findfaction(var.i);
if (!td->f) { if (!td->f) {
@ -105,13 +106,13 @@ static int createunit_read(trigger * t, struct storage *store)
} }
// read_reference(&td->f, store, read_faction_reference, resolve_faction); // read_reference(&td->f, store, read_faction_reference, resolve_faction);
read_reference(&td->r, store, read_region_reference, read_reference(&td->r, data, read_region_reference,
RESOLVE_REGION(global.data_version)); RESOLVE_REGION(data->version));
td->race = (const struct race *)read_race_reference(store).v; td->race = (const struct race *)read_race_reference(data->store).v;
if (!td->race) { if (!td->race) {
result = AT_READ_FAIL; result = AT_READ_FAIL;
} }
READ_INT(store, &td->number); READ_INT(data->store, &td->number);
return result; return result;
} }

11
src/triggers/gate.c
View file

@ -13,7 +13,7 @@
#include <kernel/config.h> #include <kernel/config.h>
#include "gate.h" #include "gate.h"
/* kernel includes */ /* kernel includes */
#include <kernel/building.h> #include <kernel/building.h>
#include <kernel/region.h> #include <kernel/region.h>
#include <kernel/unit.h> #include <kernel/unit.h>
@ -22,6 +22,7 @@
/* util includes */ /* util includes */
#include <util/attrib.h> #include <util/attrib.h>
#include <util/event.h> #include <util/event.h>
#include <util/gamedata.h>
#include <util/log.h> #include <util/log.h>
#include <util/resolve.h> #include <util/resolve.h>
@ -72,15 +73,15 @@ static void gate_write(const trigger * t, struct storage *store)
write_region_reference(r, store); write_region_reference(r, store);
} }
static int gate_read(trigger * t, struct storage *store) static int gate_read(trigger * t, gamedata *data)
{ {
gate_data *gd = (gate_data *)t->data.v; gate_data *gd = (gate_data *)t->data.v;
int bc = int bc =
read_reference(&gd->gate, store, read_building_reference, resolve_building); read_reference(&gd->gate, data, read_building_reference, resolve_building);
int rc = int rc =
read_reference(&gd->target, store, read_region_reference, read_reference(&gd->target, data, read_region_reference,
RESOLVE_REGION(global.data_version)); RESOLVE_REGION(data->version));
if (bc == 0 && rc == 0) { if (bc == 0 && rc == 0) {
if (!gd->gate || !gd->target) if (!gd->gate || !gd->target)

9
src/triggers/giveitem.c
View file

@ -28,6 +28,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <util/attrib.h> #include <util/attrib.h>
#include <util/base36.h> #include <util/base36.h>
#include <util/event.h> #include <util/event.h>
#include <util/gamedata.h>
#include <util/log.h> #include <util/log.h>
#include <util/resolve.h> #include <util/resolve.h>
@ -82,15 +83,15 @@ static void giveitem_write(const trigger * t, struct storage *store)
WRITE_TOK(store, td->itype->rtype->_name); WRITE_TOK(store, td->itype->rtype->_name);
} }
static int giveitem_read(trigger * t, struct storage *store) static int giveitem_read(trigger * t, gamedata *data)
{ {
giveitem_data *td = (giveitem_data *)t->data.v; giveitem_data *td = (giveitem_data *)t->data.v;
char zText[128]; char zText[128];
int result = read_reference(&td->u, store, read_unit_reference, resolve_unit); int result = read_reference(&td->u, data, read_unit_reference, resolve_unit);
READ_INT(store, &td->number); READ_INT(data->store, &td->number);
READ_TOK(store, zText, sizeof(zText)); READ_TOK(data->store, zText, sizeof(zText));
td->itype = it_find(zText); td->itype = it_find(zText);
assert(td->itype); assert(td->itype);

7
src/triggers/killunit.c
View file

@ -27,6 +27,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <util/attrib.h> #include <util/attrib.h>
#include <util/base36.h> #include <util/base36.h>
#include <util/event.h> #include <util/event.h>
#include <util/gamedata.h>
#include <util/log.h> #include <util/log.h>
#include <util/resolve.h> #include <util/resolve.h>
@ -58,10 +59,10 @@ static void killunit_write(const trigger * t, struct storage *store)
write_unit_reference(u, store); write_unit_reference(u, store);
} }
static int killunit_read(trigger * t, struct storage *store) static int killunit_read(trigger * t, gamedata *data)
{ {
int result = int result = read_reference(&t->data.v, data, read_unit_reference,
read_reference(&t->data.v, store, read_unit_reference, resolve_unit); resolve_unit);
if (result == 0 && t->data.v == NULL) { if (result == 0 && t->data.v == NULL) {
return AT_READ_FAIL; return AT_READ_FAIL;
} }

11
src/triggers/removecurse.c
View file

@ -28,6 +28,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <util/attrib.h> #include <util/attrib.h>
#include <util/base36.h> #include <util/base36.h>
#include <util/event.h> #include <util/event.h>
#include <util/gamedata.h>
#include <util/log.h> #include <util/log.h>
#include <util/resolve.h> #include <util/resolve.h>
@ -77,12 +78,16 @@ static void removecurse_write(const trigger * t, struct storage *store)
WRITE_INT(store, td->curse ? td->curse->no : 0); WRITE_INT(store, td->curse ? td->curse->no : 0);
} }
static int removecurse_read(trigger * t, struct storage *store) static variant read_curse_reference(struct gamedata *data) {
return read_int(data->store);
}
static int removecurse_read(trigger * t, gamedata *data)
{ {
removecurse_data *td = (removecurse_data *)t->data.v; removecurse_data *td = (removecurse_data *)t->data.v;
read_reference(&td->target, store, read_unit_reference, resolve_unit); read_reference(&td->target, data, read_unit_reference, resolve_unit);
read_reference(&td->curse, store, read_int, resolve_curse); read_reference(&td->curse, data, read_curse_reference, resolve_curse);
return AT_READ_OK; return AT_READ_OK;
} }

5
src/triggers/shock.c
View file

@ -33,6 +33,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <util/attrib.h> #include <util/attrib.h>
#include <util/base36.h> #include <util/base36.h>
#include <util/event.h> #include <util/event.h>
#include <util/gamedata.h>
#include <util/log.h> #include <util/log.h>
#include <util/resolve.h> #include <util/resolve.h>
#include <util/rng.h> #include <util/rng.h>
@ -125,10 +126,10 @@ static void shock_write(const trigger * t, struct storage *store)
} }
} }
static int shock_read(trigger * t, struct storage *store) static int shock_read(trigger * t, gamedata *data)
{ {
int result = int result =
read_reference(&t->data.v, store, read_unit_reference, resolve_unit); read_reference(&t->data.v, data, read_unit_reference, resolve_unit);
if (result == 0 && t->data.v == NULL) { if (result == 0 && t->data.v == NULL) {
return AT_READ_FAIL; return AT_READ_FAIL;
} }

7
src/triggers/timeout.c
View file

@ -23,6 +23,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
/* util includes */ /* util includes */
#include <util/attrib.h> #include <util/attrib.h>
#include <util/event.h> #include <util/event.h>
#include <util/gamedata.h>
#include <util/log.h> #include <util/log.h>
#include <storage.h> #include <storage.h>
@ -72,11 +73,11 @@ static void timeout_write(const trigger * t, struct storage *store)
write_triggers(store, td->triggers); write_triggers(store, td->triggers);
} }
static int timeout_read(trigger * t, struct storage *store) static int timeout_read(trigger * t, gamedata *data)
{ {
timeout_data *td = (timeout_data *)t->data.v; timeout_data *td = (timeout_data *)t->data.v;
READ_INT(store, &td->timer); READ_INT(data->store, &td->timer);
read_triggers(store, &td->triggers); read_triggers(data, &td->triggers);
if (td->timer > 20) { if (td->timer > 20) {
trigger *tr = td->triggers; trigger *tr = td->triggers;
log_warning("there is a timeout lasting for another %d turns\n", td->timer); log_warning("there is a timeout lasting for another %d turns\n", td->timer);

6
src/triggers/unguard.c
View file

@ -22,6 +22,7 @@
/* util includes */ /* util includes */
#include <util/attrib.h> #include <util/attrib.h>
#include <util/event.h> #include <util/event.h>
#include <util/gamedata.h>
#include <util/log.h> #include <util/log.h>
#include <util/resolve.h> #include <util/resolve.h>
@ -48,10 +49,9 @@ static void unguard_write(const trigger * t, struct storage *store)
write_building_reference((building *)t->data.v, store); write_building_reference((building *)t->data.v, store);
} }
static int unguard_read(trigger * t, struct storage *store) static int unguard_read(trigger * t, gamedata *data)
{ {
int rb = int rb = read_reference(&t->data.v, data, read_building_reference,
read_reference(&t->data.v, store, read_building_reference,
resolve_building); resolve_building);
if (rb == 0 && !t->data.v) { if (rb == 0 && !t->data.v) {
return AT_READ_FAIL; return AT_READ_FAIL;

13
src/triggers/unitmessage.c
View file

@ -20,6 +20,7 @@ without prior permission by the authors of Eressea.
#include <util/attrib.h> #include <util/attrib.h>
#include <util/base36.h> #include <util/base36.h>
#include <util/event.h> #include <util/event.h>
#include <util/gamedata.h>
#include <util/goodies.h> #include <util/goodies.h>
#include <util/language.h> #include <util/language.h>
#include <util/log.h> #include <util/log.h>
@ -84,17 +85,17 @@ static void unitmessage_write(const trigger * t, struct storage *store)
WRITE_INT(store, td->level); WRITE_INT(store, td->level);
} }
static int unitmessage_read(trigger * t, struct storage *store) static int unitmessage_read(trigger * t, gamedata *data)
{ {
unitmessage_data *td = (unitmessage_data *)t->data.v; unitmessage_data *td = (unitmessage_data *)t->data.v;
char zText[256]; char zText[256];
int result = int result = read_reference(&td->target, data, read_unit_reference,
read_reference(&td->target, store, read_unit_reference, resolve_unit); resolve_unit);
READ_TOK(store, zText, sizeof(zText)); READ_TOK(data->store, zText, sizeof(zText));
td->string = _strdup(zText); td->string = _strdup(zText);
READ_INT(store, &td->type); READ_INT(data->store, &td->type);
READ_INT(store, &td->level); READ_INT(data->store, &td->level);
if (result == 0 && td->target == NULL) { if (result == 0 && td->target == NULL) {
return AT_READ_FAIL; return AT_READ_FAIL;

3
src/util/CMakeLists.txt
View file

@ -2,6 +2,7 @@ project(util C)
SET(_TEST_FILES SET(_TEST_FILES
base36.test.c base36.test.c
gamedata.test.c
parser.test.c parser.test.c
password.test.c password.test.c
attrib.test.c attrib.test.c
@ -22,7 +23,9 @@ dice.c
event.c event.c
filereader.c filereader.c
functions.c functions.c
gamedata.c
goodies.c goodies.c
gamedata.c
language.c language.c
lists.c lists.c
log.c log.c

24
src/util/attrib.c
View file

@ -22,6 +22,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include "log.h" #include "log.h"
#include "storage.h" #include "storage.h"
#include <util/gamedata.h>
#include <critbit.h> #include <critbit.h>
#include <assert.h> #include <assert.h>
@ -279,10 +280,10 @@ static critbit_tree cb_deprecated = { 0 };
typedef struct deprecated_s { typedef struct deprecated_s {
unsigned int hash; unsigned int hash;
int(*reader)(attrib *, void *, struct storage *); int(*reader)(attrib *, void *, struct gamedata *);
} deprecated_t; } deprecated_t;
void at_deprecate(const char * name, int(*reader)(attrib *, void *, struct storage *)) void at_deprecate(const char * name, int(*reader)(attrib *, void *, struct gamedata *))
{ {
deprecated_t value; deprecated_t value;
@ -291,9 +292,9 @@ void at_deprecate(const char * name, int(*reader)(attrib *, void *, struct stora
cb_insert(&cb_deprecated, &value, sizeof(value)); cb_insert(&cb_deprecated, &value, sizeof(value));
} }
static int a_read_i(struct storage *store, attrib ** attribs, void *owner, unsigned int key) { static int a_read_i(gamedata *data, attrib ** attribs, void *owner, unsigned int key) {
int retval = AT_READ_OK; int retval = AT_READ_OK;
int(*reader)(attrib *, void *, struct storage *) = 0; int(*reader)(attrib *, void *, struct gamedata *) = 0;
attrib_type *at = at_find(key); attrib_type *at = at_find(key);
attrib * na = 0; attrib * na = 0;
@ -313,7 +314,7 @@ static int a_read_i(struct storage *store, attrib ** attribs, void *owner, unsig
} }
} }
if (reader) { if (reader) {
int ret = reader(na, owner, store); int ret = reader(na, owner, data);
if (na) { if (na) {
switch (ret) { switch (ret) {
case AT_READ_DEPR: case AT_READ_DEPR:
@ -336,13 +337,14 @@ static int a_read_i(struct storage *store, attrib ** attribs, void *owner, unsig
return retval; return retval;
} }
int a_read(struct storage *store, attrib ** attribs, void *owner) { int a_read(gamedata *data, attrib ** attribs, void *owner) {
struct storage *store = data->store;
int key, retval = AT_READ_OK; int key, retval = AT_READ_OK;
key = -1; key = -1;
READ_INT(store, &key); READ_INT(store, &key);
while (key > 0) { while (key > 0) {
int ret = a_read_i(store, attribs, owner, key); int ret = a_read_i(data, attribs, owner, key);
if (ret == AT_READ_DEPR) { if (ret == AT_READ_DEPR) {
retval = AT_READ_DEPR; retval = AT_READ_DEPR;
} }
@ -361,14 +363,14 @@ int a_read(struct storage *store, attrib ** attribs, void *owner) {
return AT_READ_OK; return AT_READ_OK;
} }
int a_read_orig(struct storage *store, attrib ** attribs, void *owner) int a_read_orig(gamedata *data, attrib ** attribs, void *owner)
{ {
int key, retval = AT_READ_OK; int key, retval = AT_READ_OK;
char zText[128]; char zText[128];
zText[0] = 0; zText[0] = 0;
key = -1; key = -1;
READ_TOK(store, zText, sizeof(zText)); READ_TOK(data->store, zText, sizeof(zText));
if (strcmp(zText, "end") == 0) { if (strcmp(zText, "end") == 0) {
return retval; return retval;
} }
@ -376,8 +378,8 @@ int a_read_orig(struct storage *store, attrib ** attribs, void *owner)
key = __at_hashkey(zText); key = __at_hashkey(zText);
} }
while (key > 0) { while (key > 0) {
retval = a_read_i(store, attribs, owner, key); retval = a_read_i(data, attribs, owner, key);
READ_TOK(store, zText, sizeof(zText)); READ_TOK(data->store, zText, sizeof(zText));
if (!strcmp(zText, "end")) if (!strcmp(zText, "end"))
break; break;
key = __at_hashkey(zText); key = __at_hashkey(zText);

8
src/util/attrib.h
View file

@ -55,7 +55,7 @@ extern "C" {
int(*age) (struct attrib *, void *owner); int(*age) (struct attrib *, void *owner);
/* age returns 0 if the attribute needs to be removed, !=0 otherwise */ /* age returns 0 if the attribute needs to be removed, !=0 otherwise */
void(*write) (const struct attrib *, const void *owner, struct storage *); void(*write) (const struct attrib *, const void *owner, struct storage *);
int(*read) (struct attrib *, void *owner, struct storage *); /* return AT_READ_OK on success, AT_READ_FAIL if attrib needs removal */ int(*read) (struct attrib *, void *owner, struct gamedata *); /* return AT_READ_OK on success, AT_READ_FAIL if attrib needs removal */
void(*upgrade) (struct attrib **alist, struct attrib *a); void(*upgrade) (struct attrib **alist, struct attrib *a);
unsigned int flags; unsigned int flags;
/* ---- internal data, do not modify: ---- */ /* ---- internal data, do not modify: ---- */
@ -64,7 +64,7 @@ extern "C" {
} attrib_type; } attrib_type;
extern void at_register(attrib_type * at); extern void at_register(attrib_type * at);
extern void at_deprecate(const char * name, int(*reader)(attrib *, void *, struct storage *)); extern void at_deprecate(const char * name, int(*reader)(attrib *, void *, struct gamedata *));
extern attrib *a_select(attrib * a, const void *data, extern attrib *a_select(attrib * a, const void *data,
bool(*compare) (const attrib *, const void *)); bool(*compare) (const attrib *, const void *));
@ -75,10 +75,10 @@ extern "C" {
extern attrib *a_new(const attrib_type * at); extern attrib *a_new(const attrib_type * at);
int a_age(attrib ** attribs, void *owner); int a_age(attrib ** attribs, void *owner);
int a_read_orig(struct storage *store, attrib ** attribs, void *owner); int a_read_orig(struct gamedata *data, attrib ** attribs, void *owner);
void a_write_orig(struct storage *store, const attrib * attribs, const void *owner); void a_write_orig(struct storage *store, const attrib * attribs, const void *owner);
int a_read(struct storage *store, attrib ** attribs, void *owner); int a_read(struct gamedata *data, attrib ** attribs, void *owner);
void a_write(struct storage *store, const attrib * attribs, const void *owner); void a_write(struct storage *store, const attrib * attribs, const void *owner);
void free_attribs(void); void free_attribs(void);

12
src/util/event.c
View file

@ -21,6 +21,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
/* util includes */ /* util includes */
#include "attrib.h" #include "attrib.h"
#include "gamedata.h"
#include "log.h" #include "log.h"
#include "storage.h" #include "storage.h"
@ -42,20 +43,20 @@ void write_triggers(struct storage *store, const trigger * t)
WRITE_TOK(store, "end"); WRITE_TOK(store, "end");
} }
int read_triggers(struct storage *store, trigger ** tp) int read_triggers(struct gamedata *data, trigger ** tp)
{ {
for (;;) { for (;;) {
trigger_type *ttype; trigger_type *ttype;
char zText[128]; char zText[128];
READ_TOK(store, zText, sizeof(zText)); READ_TOK(data->store, zText, sizeof(zText));
if (!strcmp(zText, "end")) if (!strcmp(zText, "end"))
break; break;
ttype = tt_find(zText); ttype = tt_find(zText);
assert(ttype || !"unknown trigger-type"); assert(ttype || !"unknown trigger-type");
*tp = t_new(ttype); *tp = t_new(ttype);
if (ttype->read) { if (ttype->read) {
int i = ttype->read(*tp, store); int i = ttype->read(*tp, data);
switch (i) { switch (i) {
case AT_READ_OK: case AT_READ_OK:
tp = &(*tp)->next; tp = &(*tp)->next;
@ -143,14 +144,15 @@ write_handler(const attrib * a, const void *owner, struct storage *store)
write_triggers(store, hi->triggers); write_triggers(store, hi->triggers);
} }
static int read_handler(attrib * a, void *owner, struct storage *store) static int read_handler(attrib * a, void *owner, gamedata *data)
{ {
struct storage *store = data->store;
char zText[128]; char zText[128];
handler_info *hi = (handler_info *)a->data.v; handler_info *hi = (handler_info *)a->data.v;
READ_TOK(store, zText, sizeof(zText)); READ_TOK(store, zText, sizeof(zText));
hi->event = _strdup(zText); hi->event = _strdup(zText);
read_triggers(store, &hi->triggers); read_triggers(data, &hi->triggers);
if (hi->triggers != NULL) { if (hi->triggers != NULL) {
return AT_READ_OK; return AT_READ_OK;
} }

5
src/util/event.h
View file

@ -27,6 +27,7 @@ extern "C" {
struct attrib; struct attrib;
struct trigger; struct trigger;
struct storage; struct storage;
struct gamedata;
typedef struct trigger_type { typedef struct trigger_type {
const char *name; const char *name;
@ -34,7 +35,7 @@ extern "C" {
void(*finalize) (struct trigger *); void(*finalize) (struct trigger *);
int(*handle) (struct trigger *, void *); int(*handle) (struct trigger *, void *);
void(*write) (const struct trigger *, struct storage * store); void(*write) (const struct trigger *, struct storage * store);
int(*read) (struct trigger *, struct storage * store); int(*read) (struct trigger *, struct gamedata * store);
struct trigger_type *next; struct trigger_type *next;
} trigger_type; } trigger_type;
@ -73,7 +74,7 @@ extern "C" {
/* functions for making complex triggers: */ /* functions for making complex triggers: */
void free_triggers(trigger * triggers); /* release all these triggers */ void free_triggers(trigger * triggers); /* release all these triggers */
void write_triggers(struct storage *store, const trigger * t); void write_triggers(struct storage *store, const trigger * t);
int read_triggers(struct storage *store, trigger ** tp); int read_triggers(struct gamedata *data, trigger ** tp);
int handle_triggers(trigger ** triggers, void *data); int handle_triggers(trigger ** triggers, void *data);
extern struct attrib_type at_eventhandler; extern struct attrib_type at_eventhandler;

72
src/util/gamedata.c Normal file
View file

@ -0,0 +1,72 @@
#include <platform.h>
#include "gamedata.h"
#include "log.h"
#include <storage.h>
#include <filestream.h>
#include <memstream.h>
#include <binarystore.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
void gamedata_done(gamedata *data) {
binstore_done(data->store);
}
void gamedata_init(gamedata *data, storage *store, int version) {
data->version = version;
data->store = store;
binstore_init(data->store, &data->strm);
}
void gamedata_close(gamedata *data) {
gamedata_done(data);
fstream_done(&data->strm);
}
int gamedata_openfile(gamedata *data, const char *filename, const char *mode, int version) {
FILE *F = fopen(filename, mode);
if (F) {
int err = 0;
if (strchr(mode, 'r')) {
size_t sz;
sz = fread(&version, 1, sizeof(int), F);
if (sz != sizeof(int)) {
err = ferror(F);
}
else {
err = fseek(F, sizeof(int), SEEK_CUR);
}
}
else if (strchr(mode, 'w')) {
int n = STREAM_VERSION;
fwrite(&version, sizeof(int), 1, F);
fwrite(&n, sizeof(int), 1, F);
}
if (err) {
log_error("could not open %s: %s", filename, strerror(errno));
fclose(F);
}
else {
storage *store = malloc(sizeof(storage));
fstream_init(&data->strm, F);
gamedata_init(data, store, version);
}
return err;
}
return errno;
}
gamedata *gamedata_open(const char *filename, const char *mode, int version) {
gamedata *data = (gamedata *)calloc(1, sizeof(gamedata));
if (gamedata_openfile(data, filename, mode, version) != 0) {
free(data);
return NULL;
}
return data;
}

25
src/util/gamedata.h Normal file
View file

@ -0,0 +1,25 @@
#pragma once
#ifndef _GAMEDATA_H
#define _GAMEDATA_H
#include <stream.h>
struct storage;
typedef struct gamedata {
struct storage *store;
stream strm;
int version;
} gamedata;
void gamedata_init(gamedata *data, struct storage *store, int version);
void gamedata_done(gamedata *data);
void gamedata_close(gamedata *data);
gamedata *gamedata_open(const char *filename, const char *mode, int version);
int gamedata_openfile(gamedata *data, const char *filename, const char *mode, int version);
#define STREAM_VERSION 2 /* internal encoding of binary files */
#endif

2
src/util/password.c
View file

@ -82,7 +82,7 @@ static const char * password_hash_i(const char * passwd, const char *input, int
memcpy(salt, input, salt_len); memcpy(salt, input, salt_len);
salt[salt_len] = 0; salt[salt_len] = 0;
} else { } else {
input = password_gensalt(salt, sizeof(salt)); input = password_gensalt(salt, SALTLEN);
} }
if (algo == PASSWORD_MD5) { if (algo == PASSWORD_MD5) {
return md5_crypt_r(passwd, input, result, len); return md5_crypt_r(passwd, input, result, len);

6
src/util/resolve.c
View file

@ -45,10 +45,10 @@ variant read_int(struct storage *store)
} }
int int
read_reference(void *address, storage * store, read_fun reader, read_reference(void *address, struct gamedata * data, read_fun reader,
resolve_fun resolver) resolve_fun resolver)
{ {
variant var = reader(store); variant var = reader(data);
int result = resolver(var, address); int result = resolver(var, address);
if (result != 0) { if (result != 0) {
ur_add(var, address, resolver); ur_add(var, address, resolver);

5
src/util/resolve.h
View file

@ -21,14 +21,15 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include "variant.h" #include "variant.h"
struct storage; struct storage;
struct gamedata;
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
typedef int(*resolve_fun) (variant data, void *address); typedef int(*resolve_fun) (variant data, void *address);
typedef variant(*read_fun) (struct storage * store); typedef variant(*read_fun) (struct gamedata * data);
extern int read_reference(void *address, struct storage *store, extern int read_reference(void *address, struct gamedata *data,
read_fun reader, resolve_fun resolver); read_fun reader, resolve_fun resolver);
extern void ur_add(variant data, void *address, resolve_fun fun); extern void ur_add(variant data, void *address, resolve_fun fun);

4
src/vortex.c
View file

@ -6,6 +6,7 @@
#include <kernel/region.h> #include <kernel/region.h>
#include <util/attrib.h> #include <util/attrib.h>
#include <util/gamedata.h>
#include <util/language.h> #include <util/language.h>
#include <util/log.h> #include <util/log.h>
#include <util/umlaut.h> #include <util/umlaut.h>
@ -74,8 +75,9 @@ static int a_agedirection(attrib * a, void *owner)
return (d->duration > 0) ? AT_AGE_KEEP : AT_AGE_REMOVE; return (d->duration > 0) ? AT_AGE_KEEP : AT_AGE_REMOVE;
} }
static int a_readdirection(attrib * a, void *owner, struct storage *store) static int a_readdirection(attrib * a, void *owner, struct gamedata *data)
{ {
struct storage *store = data->store;
spec_direction *d = (spec_direction *)(a->data.v); spec_direction *d = (spec_direction *)(a->data.v);
char lbuf[32]; char lbuf[32];

12
src/wormhole.c
View file

@ -27,6 +27,7 @@
/* util includes */ /* util includes */
#include <util/attrib.h> #include <util/attrib.h>
#include <util/gamedata.h>
#include <util/language.h> #include <util/language.h>
#include <util/resolve.h> #include <util/resolve.h>
#include <util/rng.h> #include <util/rng.h>
@ -109,17 +110,18 @@ static int resolve_exit(variant id, void *address)
return -1; return -1;
} }
static int wormhole_read(struct attrib *a, void *owner, struct storage *store) static int wormhole_read(struct attrib *a, void *owner, struct gamedata *data)
{ {
resolve_fun resolver = (global.data_version < UIDHASH_VERSION) storage *store = data->store;
resolve_fun resolver = (data->version < UIDHASH_VERSION)
? resolve_exit : resolve_region_id; ? resolve_exit : resolve_region_id;
read_fun reader = (global.data_version < UIDHASH_VERSION) read_fun reader = (data->version < UIDHASH_VERSION)
? read_building_reference : read_region_reference; ? read_building_reference : read_region_reference;
if (global.data_version < ATTRIBOWNER_VERSION) { if (data->version < ATTRIBOWNER_VERSION) {
READ_INT(store, NULL); READ_INT(store, NULL);
} }
if (read_reference(&a->data.v, store, reader, resolver) == 0) { if (read_reference(&a->data.v, data, reader, resolver) == 0) {
if (!a->data.v) { if (!a->data.v) {
return AT_READ_FAIL; return AT_READ_FAIL;
} }