1 #include "map_objects.h"
10 static struct MapObj * get_next_map_obj (void *, char *, size_t, struct MapObj *);
12 extern void readwrite_map_objects_dummy (void * dummy, FILE * file) {
13 // Dummy function for calls of (write|read)_map_objects on map objects without specific attributes.
16 extern void write_map_objects_monsterdata (void * start, FILE * file) {
17 // Write to file data specific to map objects of type monster.
18 struct Monster * m = (struct Monster *) start;
19 fputc(m->hitpoints, file); }
21 extern void write_map_objects (void * start, FILE * file, void (* w_typedata) (void *, FILE *) ) {
22 // Write into file the map object chain starting at start, use write_type() for object-type specific data.
23 struct MapObj * map_obj;
24 for (map_obj = start; map_obj != 0; map_obj = map_obj->next) {
25 write_uint16_bigendian(map_obj->pos.y + 1, file);
26 write_uint16_bigendian(map_obj->pos.x + 1, file);
27 fputc(map_obj->type, file);
28 w_typedata (map_obj, file); }
29 write_uint16_bigendian(0, file); }
31 extern void read_map_objects_monsterdata (void * start, FILE * file) {
32 // Read from file data speciifc to map objects of type monster.
33 struct Monster * m = (struct Monster *) start;
34 m->hitpoints = fgetc(file); }
36 static struct MapObj * get_next_map_obj (void * start, char * first, size_t size, struct MapObj * map_obj) {
37 // Return pointer to map object of "size". If first in chain ("first" pointing to !0), point "start" to it.
39 struct MapObj * * z = start;
40 map_obj = malloc(size);
44 map_obj->next = malloc(size);
45 map_obj = map_obj->next; }
48 extern void read_map_objects (void * start, FILE * file, size_t size, void (* r_typedata) (void *, FILE *) ) {
49 // Read from file chain of map objects starting at start, use r_typedata() for object-type specific data.
50 struct MapObj * map_obj;
54 test = read_uint16_bigendian(file);
57 map_obj = get_next_map_obj(start, &first, size, map_obj);
58 map_obj->pos.y = test - 1;
59 map_obj->pos.x = read_uint16_bigendian(file) - 1;
60 map_obj->type = fgetc(file);
61 r_typedata (map_obj, file); }
65 extern void build_map_objects_monsterdata (struct MapObjDef * map_obj_def, void * start) {
66 // Build data specific to map objects of type monster.
67 struct Monster * m = (struct Monster *) start;
68 m->map_obj.type = map_obj_def->id;
69 struct MonsterDef * md = (struct MonsterDef *) map_obj_def;
70 m->hitpoints = md->hitpoints_start; }
72 extern void build_map_objects_itemdata (struct MapObjDef * map_obj_def, void * start) {
73 // Build data speciifc to map objects of type data.
74 struct Item * i = (struct Item *) start;
75 i->map_obj.type = map_obj_def->id; }
77 extern void * build_map_objects (struct World * world, void * start, char def_id, unsigned char n,
78 size_t size, void (* b_typedata) (struct MapObjDef *, void *)) {
79 // Build chain of n map objects starting at start, use f() for object-specific data.
83 struct MapObjDef * mod = get_map_obj_def (world, def_id);
84 for (i = 0; i < n; i++) {
85 mo = get_next_map_obj(start, &first, size, mo);
86 mo->pos = find_passable_pos(world->map);
87 b_typedata (mod, mo); }
92 extern struct MapObjDef * get_map_obj_def (struct World * world, char def_id) {
93 // Get pointer to the map object definition with id "def_id".
94 struct MapObjDef * d = NULL;
95 for (d = (struct MapObjDef *) world->monster_def; d->id != def_id && 0 != d->next; d = d->next);
97 for (d = (struct MapObjDef *) world->item_def; d->id != def_id && 0 != d->next; d = d->next);
100 extern struct yx_uint16 find_passable_pos (struct Map * map) {
101 // Return a random passable position on map.
102 struct yx_uint16 pos;
103 for (pos.y = pos.x = 0; 0 == is_passable(map, pos);) {
104 pos.y = rrand(0, 0) % map->size.y;
105 pos.x = rrand(0, 0) % map->size.x; }
108 extern char is_passable (struct Map * map, struct yx_uint16 pos) {
109 // Check if coordinate on (or beyond) map is accessible to actor movement.
111 if (0 <= pos.x && pos.x < map->size.x && 0 <= pos.y && pos.y < map->size.y)
112 if ('.' == map->cells[pos.y * map->size.x + pos.x])
116 extern void move_monster (struct World * world, struct Monster * monster) {
117 // Move monster in random direction, trigger fighting when hindered by player/monster.
118 char d = rrand(0, 0) % 5;
119 struct yx_uint16 t = mv_yx_in_dir (d, monster->map_obj.pos);
120 char * msg = malloc(100);
121 struct MapObjDef * mod = get_map_obj_def (world, monster->map_obj.type);
122 char * desc = mod->desc;
124 if (yx_uint16_cmp (t, world->player->pos)) {
125 sprintf(msg, "\nThe %s hits you.", desc);
126 update_log (world, msg);
127 world->player->hitpoints--;
128 if (0 == world->player->hitpoints)
129 update_log (world, "\nYou are dead.");
131 struct Monster * other_monster;
132 for (other_monster = world->monster; other_monster != 0; other_monster = other_monster->map_obj.next) {
133 if (other_monster == monster)
135 if (yx_uint16_cmp (t, other_monster->map_obj.pos)) {
136 mod = get_map_obj_def (world, monster->map_obj.type);
137 desc_other = mod->desc;
138 sprintf(msg, "\n%s bumps into %s.", desc, desc_other);
139 update_log (world, msg);
142 if (is_passable(world->map, t))
143 monster->map_obj.pos = t; }
145 extern void move_player (struct World * world, char d) {
146 // Move player in direction d, update log and turn over to the enemy.
147 struct yx_uint16 t = mv_yx_in_dir (d, world->player->pos);
148 struct Monster * monster;
149 struct MapObjDef * mod;
150 char * msg = calloc(100, sizeof(char));
152 for (monster = world->monster; monster != 0; monster = monster->map_obj.next)
153 if (yx_uint16_cmp (t, monster->map_obj.pos)) {
154 mod = get_map_obj_def (world, monster->map_obj.type);
156 sprintf (msg, "\nYou hit the %s.", desc);
157 update_log (world, msg);
158 monster->hitpoints--;
159 if (0 == monster->hitpoints) {
160 sprintf (msg, "\nYou kill the %s.", desc);
161 update_log (world, msg);
162 if (world->monster == monster)
163 world->monster = world->monster->map_obj.next;
165 struct Monster * m_prev;
166 for (m_prev = world->monster; m_prev->map_obj.next != monster; m_prev = m_prev->map_obj.next);
167 m_prev->map_obj.next = monster->map_obj.next; }
169 turn_over (world, d);
171 char * msg_content = "You fail to move";
173 if (NORTH == d) dir = "north";
174 else if (EAST == d) dir = "east" ;
175 else if (SOUTH == d) dir = "south";
176 else if (WEST == d) dir = "west" ;
177 if (is_passable(world->map, t)) {
178 msg_content = "You move";
179 world->player->pos = t; }
180 sprintf(msg, "\n%s %s.", msg_content, dir);
181 update_log (world, msg);
183 turn_over (world, d); }
185 extern void player_wait (struct World * world) {
186 // Make player wait one turn.
187 update_log (world, "\nYou wait.");
188 turn_over (world, 0); }