X-Git-Url: https://plomlompom.com/repos/?a=blobdiff_plain;f=src%2Fmap_objects.c;h=fd4bd16859aaab8708d476203565ae915f39a95d;hb=e9ee94eeb27e1121f8383cb6fc3775f18261df75;hp=2fb6b80ca5dc777d6873924a5920ea5a41f8fe05;hpb=566ddf894142085e3f0208a08fa36ccce6d6a6ea;p=plomrogue diff --git a/src/map_objects.c b/src/map_objects.c index 2fb6b80..fd4bd16 100644 --- a/src/map_objects.c +++ b/src/map_objects.c @@ -1,216 +1,286 @@ /* map_objects.c */ #include "map_objects.h" -#include /* for malloc(), calloc(), free(), atoi() */ +#include /* for free(), atoi() */ +#include /* for uint8_t, uint16_t */ #include /* for FILE typedef */ -#include /* for strchr(), strlen(), memcpy() */ -#include "readwrite.h" /* for all the map object (def) loading/saving */ -#include "misc.h" /* for textfile_sizes(), find_passable_pos() */ -#include "main.h" /* for World struct */ +#include /* for strlen(), memcpy(), strtok() */ +#include "readwrite.h" /* for textfile_sizes(), try_fopen(), try_fclose(), + * try_fgets() + */ +#include "misc.h" /* for try_malloc(), find_passable_pos() */ +#include "main.h" /* for world global */ +#include "rexit.h" /* for exit_err() */ +#include "yx_uint16.h" /* for yx_uint16 struct, yx_uint16_cmp() */ -/* Return pointer to newly allocated map object struct of size "size". If first - * in map object chain ("first" pointing to !0), point "start" to it. - */ -static struct MapObj * get_next_map_obj(void * start, char * first, - size_t size, struct MapObj * map_obj); +/* Write representation of "mo" and all of the map objects it owns to "file". */ +static void write_map_object(FILE * file, struct MapObj * mo); +/* Return pointer to map object of "id" in chain starting at "ptr". */ +static struct MapObj * get_map_object(struct MapObj * ptr, uint8_t id); -static struct MapObj * get_next_map_obj(void * start, char * first, - size_t size, struct MapObj * map_obj) + +static void write_map_object(FILE * file, struct MapObj * mo) { - if (* first) + char * f_name = "write_map_object()"; + struct MapObj * mo_ptr = mo->owns; + uint8_t i = 0; + for (; NULL != mo_ptr; mo_ptr = mo_ptr->next, i++); + uint8_t size = 3+1 + 3+1 + 3+1 + 5+1 + 5 + ((1+3)*i) + 1 + 1; + char line[size]; + sprintf(line, "%d %d %d %d %d %d %d %d", + mo->id, mo->type, mo->lifepoints, mo->pos.y, mo->pos.x, + mo->command, mo->arg, mo->progress); + for (mo_ptr = mo->owns; NULL != mo_ptr; mo_ptr = mo_ptr->next) { - struct MapObj * * z = start; - map_obj = malloc(size); - * z = map_obj; - * first = 0; + sprintf(line + strlen(line), " %d", mo_ptr->id); } - else + line[strlen(line) + 1] = '\0'; + line[strlen(line)] = '\n'; + try_fwrite(line, strlen(line), 1, file, f_name); + for (mo_ptr = mo->owns; NULL != mo_ptr; mo_ptr = mo_ptr->next) { - map_obj->next = malloc(size); - map_obj = map_obj->next; + write_map_object(file, mo_ptr); } - return map_obj; } -extern void init_map_object_defs(struct World * world, char * filename) +static struct MapObj * get_map_object(struct MapObj * ptr, uint8_t id) { - world->item_def = 0; - world->monster_def = 0; - FILE * file = fopen(filename, "r"); - uint16_t linemax; - textfile_sizes (file, &linemax, NULL); - struct MapObjDef mod; - struct ItemDef id; - struct MonsterDef md; - struct ItemDef * * p_p_id = &world->item_def; - struct MonsterDef * * p_p_md = &world->monster_def; - char * defline = malloc(linemax); - char * line_p; - char m_or_i; - while (fgets(defline, linemax, file)) + while (1) { - mod.next = 0; - mod.id = atoi(defline); - line_p = strchr(defline, ' ') + 1; - m_or_i = * line_p; - mod.mapchar = * (line_p + 2); - if ('i' == m_or_i) - { - line_p = line_p + 5; - } - else - { - md.hitpoints_start = atoi (line_p + 4); - line_p = strchr (line_p + 4, ' ') + 1; - } - mod.desc = calloc (strlen (line_p), sizeof(char)); - memcpy (mod.desc, line_p, strlen(line_p) - 1); - if ('i' == m_or_i) + if (NULL == ptr || id == ptr->id) { - id.map_obj_def = mod; - * p_p_id = malloc(sizeof(struct ItemDef)); - * * p_p_id = id; - p_p_id = (struct ItemDef * *) * p_p_id; + return ptr; } - else + struct MapObj * owned_object = get_map_object(ptr->owns, id); + if (NULL != owned_object) { - md.map_obj_def = mod; - * p_p_md = malloc(sizeof(struct MonsterDef)); - * * p_p_md = md; - p_p_md = (struct MonsterDef * *) * p_p_md; + return ptr; } + ptr = ptr->next; + } +} + + + +extern void init_map_object_defs(char * filename) +{ + char * f_name = "init_map_object_defs()"; + FILE * file = try_fopen(filename, "r", f_name); + uint16_t linemax = textfile_sizes(file, NULL); + struct MapObjDef ** last_mod_ptr_ptr = &world.map_obj_defs; + char * delim = " "; + char line[linemax + 1]; + while (try_fgets(line, linemax + 1, file, f_name)) + { + struct MapObjDef * mod = try_malloc(sizeof(struct MapObjDef), 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, f_name); + memcpy(mod->name, name, strlen(name) + 1); + * last_mod_ptr_ptr = mod; + last_mod_ptr_ptr = &mod->next; + } + try_fclose(file, 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(FILE * file) +{ + struct MapObj * mo = world.map_objs; + while (NULL != mo) + { + write_map_object(file, mo); + mo = mo->next; } - free(defline); - fclose(file); -}; +} -extern void write_map_objects(void * start, FILE * file, - void (* w_typedata) (void *, FILE *) ) +extern void read_map_objects(FILE * file, char * line, int linemax) { - struct MapObj * map_obj; - for (map_obj = start; map_obj != 0; map_obj = map_obj->next) + char * f_name = "read_map_objects()"; + struct MapObj ** mo_ptr_ptr = &world.map_objs; + char * delim = " "; + struct MapObj * mo; + fpos_t pos; + exit_err(-1 == fgetpos(file, &pos), f_name); + while (try_fgets(line, linemax + 1, file, f_name)) { - write_uint16_bigendian(map_obj->pos.y + 1, file); - write_uint16_bigendian(map_obj->pos.x + 1, file); - fputc(map_obj->type, file); - if (w_typedata) + mo = try_malloc(sizeof(struct MapObj), f_name); + mo->next = NULL; + mo->id = atoi(strtok(line, delim)); + 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->command = atoi(strtok(NULL, delim));; + mo->arg = atoi(strtok(NULL, delim));; + mo->progress = atoi(strtok(NULL, delim));; + mo->owns = NULL; + * mo_ptr_ptr = mo; + mo_ptr_ptr = &mo->next; + } + exit_err(-1 == fsetpos(file, &pos), f_name); + while (try_fgets(line, linemax + 1, file, f_name)) + { + uint8_t id = atoi(strtok(line, delim)); + uint8_t i; + for (i = 0; i < 7; i++, strtok(NULL, delim)); + char * owned = strtok(NULL, "\n"); + if (NULL != owned) { - w_typedata (map_obj, file); + mo = get_map_object(world.map_objs, id); + char * owned_id = ""; + owned_id = strtok(owned, delim); + while (NULL != owned_id) + { + own_map_object(&mo->owns, &world.map_objs, atoi(owned_id)); + owned_id = strtok(NULL, delim); + } } } - write_uint16_bigendian(0, file); } -extern void read_map_objects(void * start, FILE * file, size_t size, - void (* r_typedata) (void *, FILE *) ) +extern void add_map_object(uint8_t type) { - struct MapObj * map_obj; - uint16_t test; - char first = 1; + char * f_name = "add_map_object()"; + struct MapObjDef * mod = get_map_object_def(type); + struct MapObj * mo = try_malloc(sizeof(struct MapObj), f_name); + mo->id = world.map_obj_count++; + mo->type = mod->id; + mo->lifepoints = mod->lifepoints; while (1) { - test = read_uint16_bigendian(file); - if (0 == test) + struct yx_uint16 pos = find_passable_pos(world.map); + struct MapObj * mo_ptr; + uint8_t clear = 1; + for (mo_ptr = world.map_objs; mo_ptr != NULL; mo_ptr = mo_ptr->next) { - break; + if (yx_uint16_cmp(&pos, &mo_ptr->pos) && 0 != mo_ptr->lifepoints) + { + clear = 0; + 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); - if (r_typedata) + if (1 == clear) { - r_typedata(map_obj, file); + mo->pos = pos; + break; } } - if (!first) - { - map_obj->next = 0; - } + mo->progress = 0; + mo->command = 0; + mo->arg = 0; + mo->owns = NULL; + mo->next = NULL; + struct MapObj ** mo_ptr_ptr = &world.map_objs; + for (; NULL != * mo_ptr_ptr; mo_ptr_ptr = &(*mo_ptr_ptr)->next); + * mo_ptr_ptr = mo; } -extern void write_map_objects_monsterdata(void * start, FILE * file) +extern void add_map_objects(uint8_t type, uint8_t n) { - struct Monster * m = (struct Monster *) start; - fputc(m->hitpoints, file); + uint8_t i; + for (i = 0; i < n; i++) + { + add_map_object(type); + } } -extern void read_map_objects_monsterdata (void * start, FILE * file) +extern void free_map_objects(struct MapObj * mo_start) { - struct Monster * m = (struct Monster *) start; - m->hitpoints = fgetc(file); + if (NULL == mo_start) + { + return; + } + free_map_objects(mo_start->owns); + free_map_objects(mo_start->next); + free(mo_start); } -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 *)) +extern void own_map_object(struct MapObj ** target, struct MapObj ** source, + uint8_t id) { - 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++) + if (id == (*source)->id) { - mo = get_next_map_obj(start, &first, size, mo); - mo->pos = find_passable_pos(world->map); - b_typedata(mod, mo); + mo = * source; + * source = mo->next; } - if (!first) + else { - mo->next = 0; + struct MapObj * penult = * source; + while (1) + { + if (id == penult->next->id) + { + break; + } + penult = penult->next; + } + mo = penult->next; + penult->next = mo->next; } - return &mo->next; + struct MapObj ** mo_ptr_ptr = target; + for (; NULL != * mo_ptr_ptr; mo_ptr_ptr = &(*mo_ptr_ptr)->next); + * mo_ptr_ptr = mo; + mo->next = NULL; } -extern void build_map_objects_itemdata(struct MapObjDef * map_obj_def, - void * start) +extern struct MapObj * get_player() { - struct Item * i = (struct Item *) start; - i->map_obj.type = map_obj_def->id; + return get_map_object(world.map_objs, 0); } -extern void build_map_objects_monsterdata(struct MapObjDef * map_obj_def, - void * start) +extern struct MapObjDef * get_map_object_def(uint8_t id) { - 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; + struct MapObjDef * mod = world.map_obj_defs; + for (; id != mod->id; mod = mod->next); + return mod; } -extern struct MapObjDef * get_map_obj_def (struct World * world, char def_id) +extern void set_object_position(struct MapObj * mo, struct yx_uint16 pos) { - 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->pos = pos; + struct MapObj * owned = mo->owns; + for (; owned != NULL; set_object_position(owned, pos), owned = owned->next); } +