phantasia

mapc.c (5062B)

---

 #include "engine/world.h"
 #include "game/content.h"
 #include "config.h"
 
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #define LEN(a) (sizeof(a) / sizeof(0[a]))
 
 enum {
 	PH_MAP_LINE_MAX = 512,
 };
 
 typedef struct {
 	uint32_t magic;
 	uint32_t version;
 	uint32_t width;
 	uint32_t height;
 	uint32_t marker_count;
 	char name[PH_AREA_NAME_MAX];
 } PhMapHeader;
 
 typedef struct {
 	uint32_t symbol;
 	uint32_t tile_x;
 	uint32_t tile_y;
 } PhMapMarker;
 
 static int
 ph_tile_index(unsigned char symbol)
 {
 	size_t i;
 
 	for (i = 0; i < LEN(ph_tile_defs); ++i)
 		if (ph_tile_defs[i].symbol == symbol) return (int)i;
 	return -1;
 }
 
 static const PhMarkerDef *
 ph_marker_def(int area_id, unsigned char symbol)
 {
 	size_t i;
 
 	for (i = 0; i < LEN(ph_marker_defs); ++i)
 		if (ph_marker_defs[i].area_id == area_id &&
 				ph_marker_defs[i].symbol == symbol) return &ph_marker_defs[i];
 	return NULL;
 }
 
 static int
 ph_area_id(const char *path)
 {
 	size_t i;
 
 	for (i = 0; i < LEN(ph_area_defs); ++i)
 		if (strcmp(ph_area_defs[i].path, path) == 0) return ph_area_defs[i].id;
 	return 0;
 }
 
 static void
 ph_strip_newline(char *line)
 {
 	size_t len = strlen(line);
 
 	while (len > 0 && (line[len - 1] == '\n' || line[len - 1] == '\r')) {
 		line[--len] = '\0';
 	}
 }
 
 static int
 ph_compile_map(const char *src_path, const char *dst_path)
 {
 	FILE *src;
 	FILE *dst;
 	PhMapHeader header = {
 		.magic = PH_MAP_MAGIC,
 		.version = PH_MAP_VERSION,
 	};
 	char line[PH_MAP_LINE_MAX];
 	unsigned char *tiles = NULL;
 	PhMapMarker *markers = NULL;
 	size_t tile_cap = 0;
 	size_t tile_count = 0;
 	size_t marker_cap = 0;
 	int in_tiles = 0;
 	int area_id = ph_area_id(dst_path);
 
 	if (!area_id) {
 		fprintf(stderr, "%s: output path has no area definition\n", dst_path);
 		return 1;
 	}
 
 	if (LEN(ph_tile_defs) > 256) {
 		fprintf(stderr, "too many configured tile types\n");
 		return 1;
 	}
 
 	src = fopen(src_path, "r");
 	if (!src) {
 		perror(src_path);
 		return 1;
 	}
 
 	while (fgets(line, sizeof(line), src)) {
 		size_t len;
 		size_t x;
 
 		ph_strip_newline(line);
 		if (!in_tiles && strncmp(line, "name:", 5) == 0) {
 			const char *name = line + 5;
 			size_t name_len;
 
 			while (*name == ' ' || *name == '\t') {
 				++name;
 			}
 			name_len = strlen(name);
 			if (name_len >= sizeof(header.name)) {
 				fprintf(stderr, "%s: map name too long\n", src_path);
 				free(markers);
 				free(tiles);
 				fclose(src);
 				return 1;
 			}
 			memcpy(header.name, name, name_len + 1);
 			continue;
 		}
 		if (!in_tiles && line[0] == '\0') {
 			in_tiles = 1;
 			continue;
 		}
 		if (line[0] == '\0') {
 			continue;
 		}
 
 		len = strlen(line);
 		for (x = 0; x < len; ++x) {
 			const PhMarkerDef *marker = ph_marker_def(area_id,
 				(unsigned char)line[x]);
 			int tile = ph_tile_index(marker ? marker->tile_symbol :
 				(unsigned char)line[x]);
 
 			if (tile < 0) {
 				fprintf(stderr, "%s: unknown tile or marker '%c' in row %u\n",
 					src_path, line[x], header.height + 1);
 				free(markers);
 				free(tiles);
 				fclose(src);
 				return 1;
 			}
 			if (marker) {
 				PhMapMarker *new_markers;
 
 				if (header.marker_count == marker_cap) {
 					marker_cap = marker_cap ? marker_cap * 2 : 16;
 					new_markers = realloc(markers,
 						marker_cap * sizeof(*markers));
 					if (!new_markers) {
 						free(markers);
 						free(tiles);
 						fclose(src);
 						return 1;
 					}
 					markers = new_markers;
 				}
 				markers[header.marker_count++] = (PhMapMarker){
 					(unsigned char)line[x], (uint32_t)x, header.height };
 			}
 			line[x] = (char)tile;
 		}
 		if (header.width == 0) {
 			header.width = (uint32_t)len;
 		} else if (len != header.width) {
 			fprintf(stderr, "%s: inconsistent row width: got %zu, expected %u\n",
 				src_path, len, header.width);
 			free(markers);
 			free(tiles);
 			fclose(src);
 			return 1;
 		}
 
 		if (tile_count + len > tile_cap) {
 			size_t new_cap = tile_cap ? tile_cap * 2 : 256;
 			unsigned char *new_tiles;
 
 			while (new_cap < tile_count + len) {
 				new_cap *= 2;
 			}
 			new_tiles = realloc(tiles, new_cap);
 			if (!new_tiles) {
 				free(markers);
 				free(tiles);
 				fclose(src);
 				return 1;
 			}
 			tiles = new_tiles;
 			tile_cap = new_cap;
 		}
 
 		memcpy(tiles + tile_count, line, len);
 		tile_count += len;
 		++header.height;
 	}
 	fclose(src);
 
 	if (header.width == 0 || header.height == 0 || header.name[0] == '\0') {
 		fprintf(stderr, "%s: missing name or tile data\n", src_path);
 		free(markers);
 		free(tiles);
 		return 1;
 	}
 
 	dst = fopen(dst_path, "wb");
 	if (!dst) {
 		perror(dst_path);
 		free(markers);
 		free(tiles);
 		return 1;
 	}
 
 	if (fwrite(&header, sizeof(header), 1, dst) != 1 ||
 			fwrite(tiles, 1, tile_count, dst) != tile_count ||
 			fwrite(markers, sizeof(*markers), header.marker_count, dst) !=
 				header.marker_count) {
 		perror(dst_path);
 		free(markers);
 		free(tiles);
 		fclose(dst);
 		return 1;
 	}
 
 	free(markers);
 	free(tiles);
 	fclose(dst);
 	return 0;
 }
 
 int
 main(int argc, char **argv)
 {
 	if (argc != 3) {
 		fprintf(stderr, "usage: %s <map.txt> <map.phmap>\n", argv[0]);
 		return 1;
 	}
 	return ph_compile_map(argv[1], argv[2]);
 }