Branch data Line data Source code
1 : : /* Copyright 2000 William D. Tanksley Jr., licensed under the terms of the
2 : : * Omega license as part of Omega. */
3 : : #include "glob.h"
4 : : #include <stdio.h>
5 : : #include <stdarg.h>
6 : : #include <stdlib.h>
7 : : #include <assert.h>
8 : :
9 : : #define MAP_VERSION 2
10 : : #define MAP_HEADER_SIZE 3
11 : : #define MAP_ITEM_SIZE 9
12 : :
13 : : /* I plan to eventually make this code handle ALL map loading, since map
14 : : * loading is largely similar. However, to keep from biting off more than
15 : : * I can chew, I'm going to start by doing just a little bit at a time.
16 : : *
17 : : * For starters, I'm just going to have this load the map, and that's all. */
18 : : struct symbolMapping
19 : : {
20 : : /* Which L_* to assign this character to. */
21 : : int locationFunction;
22 : : /* What argument (if any) to give to the function which constructs that
23 : : * location. */
24 : : int argument;
25 : : };
26 : :
27 : : struct map_type
28 : : {
29 : : int length, width, depth, offset;
30 : : char *sites;
31 : : #if 0
32 : : struct symbolMapping symbols[128-32]; /* Only printable characters.
33 : : * This does assume ASCII. */
34 : : #endif
35 : : };
36 : :
37 : 0 : void error(char *explanation, ...)
38 : : {
39 : : va_list ap;
40 : :
41 : 0 : va_start (ap, explanation);
42 : 0 : vfprintf (stderr, explanation, ap);
43 : 0 : va_end (ap);
44 : 0 : abort();
45 : : }
46 : :
47 : 17 : int fgetint(FILE *f)
48 : : {
49 : : int x;
50 : : assert(sizeof(int) == 4); /* This assumption is explicit here, but it's
51 : : * also elsewhere. */
52 : 17 : x = fgetc(f) &0x000000FF;
53 : 17 : x|= (fgetc(f) << 8) &0x0000FF00;
54 : 17 : x|= (fgetc(f) <<16) &0x00FF0000;
55 : 17 : x|= (fgetc(f) <<24) &0xFF000000;
56 : :
57 [ - + ]: 17 : if ( feof(f) )
58 : 0 : error("Unexpected end of file while parsing binary file.");
59 : :
60 : 17 : return x;
61 : : }
62 : :
63 : 24 : int fgetshort(FILE *f)
64 : : {
65 : : int x;
66 : : assert(sizeof(int) == 4); /* This assumption is explicit here, but it's
67 : : * also elsewhere. */
68 : 24 : x = fgetc(f) &0x000000FF;
69 : 24 : x|= (fgetc(f) << 8) &0x0000FF00;
70 : :
71 [ - + ]: 24 : if ( feof(f) )
72 : 0 : error("Unexpected end of file while parsing binary file.");
73 : :
74 : 24 : return x;
75 : : }
76 : :
77 : 3 : void decode(char **data, int *length)
78 : : {
79 : : /* just testing... Place a sophisticated BWT here. */
80 : 3 : }
81 : :
82 : 1 : int map_getWidth(map *m)
83 : : {
84 : 1 : return m->width;
85 : : }
86 : :
87 : 1 : int map_getLength(map *m)
88 : : {
89 : 1 : return m->length;
90 : : }
91 : :
92 : 1 : int map_getDepth(map *m)
93 : : {
94 : 1 : return m->depth;
95 : : }
96 : :
97 : : /* Read in the indicated sublevel of the current map. Called from
98 : : * map_setLevel. */
99 : 3 : void map_read(map *m, FILE *in, int subLevel)
100 : : {
101 : : int size;
102 : :
103 [ + - ][ - + ]: 3 : if ( subLevel > m->depth || subLevel < 0 )
104 : 0 : error("map has only %d levels; game requested level %d.\n",
105 : : m->depth, subLevel);
106 : :
107 : : /* Seek to the location of the data (as previously calculated). */
108 : 3 : fseek(in,m->offset,SEEK_SET);
109 : :
110 : : do {
111 : : /* Read in the size of the next submap, and if it wasn't the one
112 : : * we're looking for, skip past it. */
113 : 4 : size = fgetshort(in);
114 [ + + ]: 4 : if ( subLevel )
115 : 1 : fseek(in, size, SEEK_CUR);
116 [ + + ]: 4 : } while ( subLevel-- );
117 : :
118 : : /* We now know that we're looking at the right map, and we know its size. */
119 : : /* Read the encoding of the level into a buffer. */
120 : 3 : m->sites = malloc(size);
121 : 3 : fread(m->sites,size,1,in);
122 : :
123 : : /* Decode the level. */
124 : 3 : decode(&m->sites,&size);
125 : :
126 [ - + ]: 3 : if ( size != m->length*m->width )
127 : 0 : error("Map had invalid size: expected %d, got %d.\n",
128 : 0 : m->length*m->width, size);
129 : 3 : }
130 : :
131 : : /* Read the map info out of the header of the mapfile, and load it into
132 : : * the map. */
133 : 3 : void map_readDimensions(map *m, FILE *in, enum map_identifier map)
134 : : {
135 : : int version, maps, items, this_map;
136 : :
137 : 3 : version = fgetc(in); /* The file version */
138 [ - + ]: 3 : if ( version != MAP_VERSION )
139 : 0 : error("Mapfile version mismatch: expected %d, got %d.\n",
140 : : MAP_VERSION, version);
141 : :
142 : 3 : maps = fgetshort(in); /* The number of maps it's supposed to contain */
143 : :
144 : 3 : items = 0;
145 : : do {
146 : 17 : this_map = fgetshort(in);
147 : 17 : m->width = fgetc(in); m->length = fgetc(in); m->depth = fgetc(in);
148 : 17 : m->offset = fgetint(in);
149 : 17 : items++;
150 [ + + ][ + - ]: 17 : } while (this_map != map && items < maps);
151 : :
152 [ - + ][ # # ]: 3 : if ( (items == maps) && (this_map != map) )
153 : 0 : error("Map #%d was not found in mapfile.\n", map );
154 : :
155 : : /* The offset stored in the file was the offset from the end of the table of
156 : : * contents. Fix that to be an absolute offset. */
157 : 3 : m->offset += MAP_HEADER_SIZE + maps*MAP_ITEM_SIZE;
158 : 3 : }
159 : :
160 : 3 : map *map_open(enum map_identifier mapNumber)
161 : : {
162 : 3 : map *m = malloc( sizeof(map) );
163 : : FILE *fd;
164 : :
165 : 3 : strcpy(Str3,Omegalib);
166 : 3 : strcat(Str3,"maps.dat");
167 : 3 : fd = checkfopen(Str3,"rb");
168 : :
169 : 3 : map_readDimensions(m,fd,mapNumber);
170 : :
171 : 3 : fclose(fd);
172 : 3 : return m;
173 : : }
174 : :
175 : 3 : void map_setLevel(map *m, int levelNumber)
176 : : {
177 : : FILE *fd;
178 : :
179 : 3 : strcpy(Str3,Omegalib);
180 : 3 : strcat(Str3,"maps.dat");
181 : 3 : fd = checkfopen(Str3,"rb");
182 : :
183 : 3 : map_read(m,fd,levelNumber);
184 : :
185 : 3 : fclose(fd);
186 : 3 : }
187 : :
188 : 3 : void map_close(map *m)
189 : : {
190 : 3 : free(m->sites);
191 : 3 : free(m);
192 : 3 : }
193 : :
194 : : #if 0
195 : : /* Using the mappings given in this map structure, build an Omega
196 : : * level, using appropriate terrain. */
197 : : void map_buildLevel(map *m, Level *lev)
198 : : {
199 : :
200 : : }
201 : : #endif
202 : :
203 : 8478 : char map_getSiteChar(map *m, int i, int j)
204 : : {
205 [ - + ]: 8478 : assert(i < m->width);
206 [ - + ]: 8478 : assert(j < m->length);
207 [ - + ]: 8478 : assert(m->sites[j*m->width + i]);
208 : 8478 : return m->sites[j*m->width + i];
209 : : }
210 : :
|
