1 #include "objects_on_map.h"
9 static struct ChainMapObject * get_next_cmo (void *, char *, size_t, struct ChainMapObject *);
11 extern void readwrite_map_objects_dummy (void * dummy, FILE * file) {
12 // Dummy function for calls of (write|read)_map_objects on map objects without specific attributes.
15 extern void write_map_objects_monsterdata (void * start, FILE * file) {
16 // Write to file data specific tto map objects of type monster.
17 struct Monster * monster = (struct Monster *) start;
18 fputc(monster->hitpoints, file); }
20 extern void write_map_objects (void * start, FILE * file, void (* f) (void *, FILE *) ) {
21 // Write into file the map object chain starting at start, use f() for object-type specific data.
22 struct ChainMapObject * cmo;
23 for (cmo = start; cmo != 0; cmo = cmo->next) {
24 write_uint16_bigendian(cmo->pos.y + 1, file);
25 write_uint16_bigendian(cmo->pos.x + 1, file);
26 fputc(cmo->name, file);
28 write_uint16_bigendian(0, file); }
30 extern void read_map_objects_monsterdata (void * start, FILE * file) {
31 // Read from file data speciifc to map objects of type monster.
32 struct Monster * monster = (struct Monster *) start;
33 monster->hitpoints = fgetc(file); }
35 static struct ChainMapObject * get_next_cmo (void * start, char * still_at_start, size_t size, struct ChainMapObject * cmo) {
36 // Return pointer to map object of size "size". If first in chain ("still_at_start"), make "start" point to it.
37 if (*still_at_start) {
38 struct ChainMapObject * * z = start;
41 *still_at_start = 0; }
43 cmo->next = malloc(size);
47 extern void read_map_objects (void * start, FILE * file, size_t size, void (* f) (void *, FILE *) ) {
48 // Read from file chain of map objects starting at start, use f() for object-type specific data.
49 struct ChainMapObject * cmo;
51 char still_at_start = 1;
53 test = read_uint16_bigendian(file);
56 cmo = get_next_cmo(start, &still_at_start, size, cmo);
57 cmo->pos.y = test - 1;
58 cmo->pos.x = read_uint16_bigendian(file) - 1;
59 cmo->name = fgetc(file);
64 extern void build_map_objects_monsterdata (void * start) {
65 // Build data specific to map objects of type monster.
66 struct Monster * monster = (struct Monster *) start;
67 monster->cmo.name = 'A' + (rrand(0, 0) % 8);
68 monster->hitpoints = 5; }
70 extern void build_map_objects_itemdata (void * start) {
71 // Build data speciifc to map objects of type data.
72 struct Item * item = (struct Item *) start;
73 item->cmo.name = '#' + (rrand(0, 0) % 4); }
75 extern void build_map_objects (void * start, unsigned char n, size_t size, void (* f) (void *), struct Map * map) {
76 // Build chain of n map objects starting at start, use f() for object-specific data.
78 struct ChainMapObject * cmo;
79 char still_at_start = 1;
80 for (i = 0; i < n; i++) {
81 cmo = get_next_cmo(start, &still_at_start, size, cmo);
82 cmo->pos = find_passable_pos(map);
87 extern struct yx_uint16 find_passable_pos (struct Map * map) {
88 // Return a random passable position on map.
90 for (pos.y = pos.x = 0; 0 == is_passable(map, pos);) {
91 pos.y = rrand(0, 0) % map->size.y;
92 pos.x = rrand(0, 0) % map->size.x; }
95 extern char is_passable (struct Map * map, struct yx_uint16 pos) {
96 // Check if coordinate on (or beyond) map is accessible to actor movement.
98 if (0 <= pos.x && pos.x < map->size.x && 0 <= pos.y && pos.y < map->size.y)
99 if ('.' == map->cells[pos.y * map->size.x + pos.x])
103 extern void move_monster (struct World * world, struct Monster * monster) {
104 // Move monster in random direction, trigger fighting when hindered by player/monster.
105 char d = rrand(0, 0) % 5;
106 struct yx_uint16 t = mv_yx_in_dir (d, monster->cmo.pos);
107 if (yx_uint16_cmp (t, world->player->pos)) {
108 update_log (world, "\nThe monster hits you.");
109 world->player->hitpoints--;
110 if (0 == world->player->hitpoints)
111 update_log (world, "\nYou are dead.");
113 struct Monster * other_monster;
114 for (other_monster = world->monster; other_monster != 0; other_monster = other_monster->cmo.next) {
115 if (other_monster == monster)
117 if (yx_uint16_cmp (t, other_monster->cmo.pos)) {
118 update_log (world, "\nMonster bumps into monster.");
120 if (is_passable(world->map, t))
121 monster->cmo.pos = t; }
123 extern void move_player (struct World * world, char d) {
124 // Move player in direction d, update log and turn over to the enemy.
125 struct yx_uint16 t = mv_yx_in_dir (d, world->player->pos);
126 struct Monster * monster;
127 for (monster = world->monster; monster != 0; monster = monster->cmo.next)
128 if (yx_uint16_cmp (t, monster->cmo.pos)) {
129 update_log (world, "\nYou hit the monster.");
130 monster->hitpoints--;
131 if (0 == monster->hitpoints) {
132 update_log (world, "\nYou kill the monster.");
133 if (world->monster == monster)
134 world->monster = world->monster->cmo.next;
136 struct Monster * m_prev;
137 for (m_prev = world->monster; m_prev->cmo.next != monster; m_prev = m_prev->cmo.next);
138 m_prev->cmo.next = monster->cmo.next; }
140 turn_over (world, d);
142 char * msg = calloc(25, sizeof(char));
143 char * msg_content = "You fail to move";
145 if (NORTH == d) dir = "north";
146 else if (EAST == d) dir = "east" ;
147 else if (SOUTH == d) dir = "south";
148 else if (WEST == d) dir = "west" ;
149 if (is_passable(world->map, t)) {
150 msg_content = "You move";
151 world->player->pos = t; }
152 sprintf(msg, "\n%s %s.", msg_content, dir);
153 update_log (world, msg);
155 turn_over (world, d); }
157 extern void player_wait (struct World * world) {
158 // Make player wait one turn.
159 update_log (world, "\nYou wait.");
160 turn_over (world, 0); }