X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=src%2Fmap_objects.c;h=7e2472d0da521abe19b873088e7cb96f36571563;hb=9d35a239f47714198b942deca3171334409a27bb;hp=731d830df716864932571d14a245e8e52f7bbfe3;hpb=00a66e3c7cbcad13b5c29162e6c1c33235be9f07;p=plomrogue diff --git a/src/map_objects.c b/src/map_objects.c index 731d830..7e2472d 100644 --- a/src/map_objects.c +++ b/src/map_objects.c @@ -1,96 +1,148 @@ +/* map_objects.c */ + #include "map_objects.h" -#include -#include -#include "readwrite.h" -#include "misc.h" -#include "main.h" - -static struct MapObj * get_next_map_obj (void *, char *, size_t, struct MapObj *); - -extern void readwrite_map_objects_dummy (void * dummy, FILE * file) { -// Dummy function for calls of (write|read)_map_objects on map objects without specific attributes. - ; } - -extern void write_map_objects_monsterdata (void * start, FILE * file) { -// Write to file data specific to map objects of type monster. - struct Monster * m = (struct Monster *) start; - fputc(m->hitpoints, file); } - -extern void write_map_objects (void * start, FILE * file, void (* w_typedata) (void *, FILE *) ) { -// Write into file the map object chain starting at start, use write_type() for object-type specific data. - struct MapObj * map_obj; - for (map_obj = start; map_obj != 0; map_obj = map_obj->next) { - write_uint16_bigendian(map_obj->pos.y + 1, file); - write_uint16_bigendian(map_obj->pos.x + 1, file); - fputc(map_obj->type, file); - w_typedata (map_obj, file); } - write_uint16_bigendian(0, file); } - -extern void read_map_objects_monsterdata (void * start, FILE * file) { -// Read from file data speciifc to map objects of type monster. - struct Monster * m = (struct Monster *) start; - m->hitpoints = fgetc(file); } - -static struct MapObj * get_next_map_obj (void * start, char * first, size_t size, struct MapObj * map_obj) { -// Return pointer to map object of "size". If first in chain ("first" pointing to !0), point "start" to it. - if (* first) { - struct MapObj * * z = start; - map_obj = malloc(size); - * z = map_obj; - * first = 0; } - else { - map_obj->next = malloc(size); - map_obj = map_obj->next; } - return map_obj; } - -extern void read_map_objects (void * start, FILE * file, size_t size, void (* r_typedata) (void *, FILE *) ) { -// Read from file chain of map objects starting at start, use r_typedata() for object-type specific data. - struct MapObj * map_obj; - uint16_t test; - char first = 1; - while (1) { - test = read_uint16_bigendian(file); - if (0 == test) - break; - map_obj = get_next_map_obj(start, &first, size, map_obj); - map_obj->pos.y = test - 1; - map_obj->pos.x = read_uint16_bigendian(file) - 1; - map_obj->type = fgetc(file); - r_typedata (map_obj, file); } - if (!first) - map_obj->next = 0; } - -extern void build_map_objects_monsterdata (struct MapObjDef * map_obj_def, void * start) { -// Build data specific to map objects of type monster. - struct Monster * m = (struct Monster *) start; - m->map_obj.type = map_obj_def->id; - struct MonsterDef * md = (struct MonsterDef *) map_obj_def; - m->hitpoints = md->hitpoints_start; } - -extern void build_map_objects_itemdata (struct MapObjDef * map_obj_def, void * start) { -// Build data speciifc to map objects of type data. - struct Item * i = (struct Item *) start; - i->map_obj.type = map_obj_def->id; } - -extern void * build_map_objects (struct World * world, void * start, char def_id, unsigned char n, - size_t size, void (* b_typedata) (struct MapObjDef *, void *)) { -// Build chain of n map objects starting at start, use f() for object-specific data. - unsigned char i; - struct MapObj * mo; - char first = 1; - struct MapObjDef * mod = get_map_obj_def (world, def_id); - for (i = 0; i < n; i++) { - mo = get_next_map_obj(start, &first, size, mo); +#include /* for free(), atoi() */ +#include /* for uint8_t */ +#include /* for FILE typedef */ +#include /* for strchr(), strlen(), memcpy(), strtok() */ +#include "readwrite.h" /* for get_linemax(), try_fopen(), try_fclose() + * [read/write]_uint[8/16/23][_bigendian]() + */ +#include "misc.h" /* for try_malloc(), try_calloc(), find_passable_pos() */ +#include "main.h" /* for World struct */ +#include "rexit.h" /* for err_exit() */ + + + +extern void init_map_object_defs(struct World * world, char * filename) +{ + char * f_name = "init_map_object_defs()"; + FILE * file = try_fopen(filename, "r", world, f_name); + uint16_t linemax = get_linemax(file, world, f_name); + struct MapObjDef ** last_mod_ptr_ptr = &world->map_obj_defs; + char * delim = " "; + char line[linemax + 1]; + while (try_fgets(line, linemax + 1, file, world, f_name)) + { + struct MapObjDef * mod; + mod = try_malloc(sizeof(struct MapObjDef), world, f_name); + mod->next = NULL; + mod->id = atoi(strtok(line, delim)); + mod->corpse_id = atoi(strtok(NULL, delim)); + mod->char_on_map = * strtok(NULL, delim); + mod->lifepoints = atoi(strtok(NULL, delim)); + char * name = strtok(NULL, "\n"); + mod->name = try_malloc(strlen(name) + 1, world, f_name); + memcpy(mod->name, name, strlen(name) + 1); + * last_mod_ptr_ptr = mod; + last_mod_ptr_ptr = &mod->next; + } + try_fclose(file, world, f_name); +} + + + +extern void free_map_object_defs(struct MapObjDef * mod_start) +{ + if (NULL == mod_start) + { + return; + } + free_map_object_defs(mod_start->next); + free(mod_start->name); + free(mod_start); +} + + + +extern void write_map_objects(struct World * world, FILE * file) +{ + char * f_name = "write_map_objects()"; + struct MapObj * mo = world->map_objs; + uint8_t size = 3 + 1 + 3 + 1 + 3 + 1 + 5 + 1 + 5 + 1; + char line[size]; + while (NULL != mo) + { + sprintf(line, "%d %d %d %d %d\n", + mo->id, mo->type, mo->lifepoints, mo->pos.y, mo->pos.x); + try_fwrite(line, strlen(line), 1, file, world, f_name); + mo = mo->next; + } +} + + + +extern void read_map_objects(struct World * world, FILE * file, char * line, + int linemax) +{ + char * f_name = "read_map_objects()"; + struct MapObj ** mo_ptr_ptr = &world->map_objs; + char * delim = " "; + while (try_fgets(line, linemax + 1, file, world, f_name)) + { + struct MapObj * mo = malloc(sizeof(struct MapObj)); + mo->next = NULL; + mo->id = atoi(strtok(line, delim)); + if (mo->id > world->map_obj_count) + { + world->map_obj_count = mo->id; + } + mo->type = atoi(strtok(NULL, delim)); + mo->lifepoints = atoi(strtok(NULL, delim)); + mo->pos.y = atoi(strtok(NULL, delim)); + mo->pos.x = atoi(strtok(NULL, delim)); + * mo_ptr_ptr = mo; + mo_ptr_ptr = &mo->next; + } +} + + + +extern void add_map_object(struct World * world, uint8_t type) +{ + char * f_name = "add_map_object"; + struct MapObjDef * mod = get_map_object_def(world, type); + struct MapObj * mo = try_malloc(sizeof(struct MapObj), world, f_name); + mo->id = world->map_obj_count; + world->map_obj_count++; + mo->type = mod->id; + mo->lifepoints = mod->lifepoints; mo->pos = find_passable_pos(world->map); - b_typedata (mod, mo); } - if (!first) - mo->next = 0; - return &mo->next; } - -extern struct MapObjDef * get_map_obj_def (struct World * world, char def_id) { -// Get pointer to the map object definition with id "def_id". - struct MapObjDef * d = NULL; - for (d = (struct MapObjDef *) world->monster_def; d->id != def_id && 0 != d->next; d = d->next); - if (d->id != def_id) - for (d = (struct MapObjDef *) world->item_def; d->id != def_id && 0 != d->next; d = d->next); - return d; } + mo->next = world->map_objs; + world->map_objs = mo; +} + + + +extern void add_map_objects(struct World * world, uint8_t type, uint8_t n) +{ + uint8_t i; + for (i = 0; i < n; i++) + { + add_map_object(world, type); + } +} + + + +extern void free_map_objects(struct MapObj * mo_start) +{ + if (NULL == mo_start) + { + return; + } + free_map_objects(mo_start->next); + free(mo_start); +} + + + +extern struct MapObjDef * get_map_object_def(struct World * w, uint8_t id) +{ + struct MapObjDef * mod = w->map_obj_defs; + while (id != mod->id) + { + mod = mod->next; + } + return mod; +}