map_parser.c 8.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302
  1. /* $Id: map_parser.c,v 1.15 2001/04/23 16:57:55 kilobug Exp $ */
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <errno.h>
  6. #include <fcntl.h>
  7. #include <unistd.h>
  8. #include <server.h>
  9. #include <private.h>
  10. #include <ipc.h>
  11. /* TODO: This is going to be painful to remove GLIB */
  12. /*
  13. ** Map parser
  14. */
  15. #define MAP_SCOPE_NONE 0
  16. #define MAP_SCOPE_SPEED 1
  17. #define MAP_SCOPE_TURN 2
  18. #define MAP_SCOPE_SEE 3
  19. #define MAP_SCOPE_SAND 4
  20. #define MAP_SCOPE_ITEM 10
  21. #define MAP_SCOPE_TEAM 11
  22. #define CONF_OFFS(ID) G_STRUCT_OFFSET(conf_t, ID)
  23. /* TODO: Change that */
  24. typedef int GScanner;
  25. #if 0
  26. typedef struct _map_hdr_t
  27. {
  28. const char *name;
  29. GTokenType type;
  30. int scope;
  31. int offs;
  32. } map_hdr_t;
  33. static map_hdr_t map_hdr[] =
  34. {{ "take_akx", G_TOKEN_INT, MAP_SCOPE_TURN, CONF_OFFS(turn_take_akx) },
  35. { "take_r4d2", G_TOKEN_INT, MAP_SCOPE_TURN, CONF_OFFS(turn_take_r4d2) },
  36. { "untake_akx", G_TOKEN_INT, MAP_SCOPE_TURN, CONF_OFFS(turn_untake_akx) },
  37. { "untake_r4d2", G_TOKEN_INT, MAP_SCOPE_TURN, CONF_OFFS(turn_untake_r4d2) },
  38. { "size_x", G_TOKEN_FLOAT, MAP_SCOPE_NONE, CONF_OFFS(size_x) },
  39. { "size_y", G_TOKEN_FLOAT, MAP_SCOPE_NONE, CONF_OFFS(size_y) },
  40. { "akx_speed", G_TOKEN_FLOAT, MAP_SCOPE_SPEED, CONF_OFFS(akx_speed) },
  41. { "r4d2_speed", G_TOKEN_FLOAT, MAP_SCOPE_SPEED, CONF_OFFS(r4d2_speed) },
  42. { "pulse_power", G_TOKEN_FLOAT, MAP_SCOPE_NONE, CONF_OFFS(pulse_power) },
  43. { "nb_objects", G_TOKEN_INT, MAP_SCOPE_NONE, CONF_OFFS(nb_objects) },
  44. { "see", G_TOKEN_FLOAT, MAP_SCOPE_SEE, CONF_OFFS(see_power) },
  45. { "see_power", G_TOKEN_FLOAT, MAP_SCOPE_SEE, CONF_OFFS(see_power) },
  46. { "destroy", G_TOKEN_FLOAT, MAP_SCOPE_SPEED, CONF_OFFS(destroy_speed) },
  47. { "destroy_speed", G_TOKEN_FLOAT, MAP_SCOPE_SPEED,
  48. CONF_OFFS(destroy_speed) },
  49. { "pulse_coef", G_TOKEN_FLOAT, MAP_SCOPE_SPEED, CONF_OFFS(pulse_coef) },
  50. { "sand", G_TOKEN_STRING, MAP_SCOPE_SAND, CONF_OFFS(sand_file) },
  51. { "sand_file", G_TOKEN_STRING, MAP_SCOPE_SAND, CONF_OFFS(sand_file) },
  52. { NULL, 0, 0, 0 }};
  53. #endif
  54. /* Load a value: (x, y) keyword [param]; */
  55. static void map_load_value(GScanner *scan, conf_t *conf, int id)
  56. {
  57. #if 0
  58. GTokenType type;
  59. float x, y;
  60. if (id >= conf->nb_objects)
  61. {
  62. g_scanner_error(scan,
  63. "Le champ nb_objects ne correspond pas au nombre d'objets.");
  64. abort();
  65. }
  66. scan->config->int_2_float = TRUE;
  67. x = parser_get_float(scan);
  68. parser_check_type(scan, g_scanner_get_next_token(scan), G_TOKEN_COMMA);
  69. y = parser_get_float(scan);
  70. parser_check_type(scan, g_scanner_get_next_token(scan), G_TOKEN_RIGHT_PAREN);
  71. scan->config->int_2_float = FALSE;
  72. if (x > conf->size_x)
  73. {
  74. conf->size_x = x;
  75. }
  76. if (y > conf->size_y)
  77. {
  78. conf->size_y = y;
  79. }
  80. g_scanner_set_scope(scan, MAP_SCOPE_ITEM);
  81. parser_check_type(scan, g_scanner_get_next_token(scan), G_TOKEN_SYMBOL);
  82. switch (parser_get_symbol_as_int(scan))
  83. {
  84. case obj_akx:
  85. conf->nb_akx++;
  86. new_akx(x, y, id);
  87. break;
  88. case obj_r4d2:
  89. conf->nb_r4d2++;
  90. new_r4d2(x, y, id);
  91. break;
  92. }
  93. g_scanner_set_scope(scan, MAP_SCOPE_TEAM);
  94. type = g_scanner_get_next_token(scan);
  95. g_scanner_set_scope(scan, MAP_SCOPE_NONE);
  96. switch (type)
  97. {
  98. case G_TOKEN_SYMBOL:
  99. gl_objects[id].obj.team_id = parser_get_symbol_as_int(scan);
  100. parser_check_type(scan, g_scanner_get_next_token(scan),
  101. G_TOKEN_SEMICOLON);
  102. break;
  103. case G_TOKEN_INT:
  104. gl_objects[id].obj.team_id = g_scanner_cur_value(scan).v_int;
  105. parser_check_type(scan, g_scanner_get_next_token(scan),
  106. G_TOKEN_SEMICOLON);
  107. break;
  108. case G_TOKEN_SEMICOLON:
  109. break;
  110. default:
  111. g_scanner_unexp_token(scan, G_TOKEN_INT, NULL, NULL, NULL, NULL,
  112. TRUE);
  113. abort();
  114. }
  115. if (gl_objects[id].obj.team_id > conf->nb_players)
  116. {
  117. gl_objects[id].obj.team_id = 0;
  118. }
  119. #endif
  120. }
  121. static void map_load_data(GScanner *scan, conf_t *conf)
  122. {
  123. #if 0
  124. GTokenType type;
  125. int id = 0;
  126. while ((type = g_scanner_get_next_token(scan)) != G_TOKEN_EOF)
  127. {
  128. if (type == G_TOKEN_LEFT_PAREN)
  129. {
  130. map_load_value(scan, conf, id++);
  131. }
  132. else
  133. {
  134. g_scanner_unexp_token(scan, G_TOKEN_LEFT_PAREN, NULL, NULL, NULL,
  135. NULL, TRUE);
  136. abort();
  137. }
  138. }
  139. if (id != conf->nb_objects)
  140. {
  141. g_scanner_unexp_token(scan, G_TOKEN_LEFT_PAREN, NULL, NULL, NULL,
  142. NULL, TRUE);
  143. abort();
  144. }
  145. #endif
  146. }
  147. static void map_load_header_value(GScanner *scan, conf_t *conf)
  148. {
  149. #if 0
  150. int i, scope;
  151. char *s;
  152. parser_check_type(scan, g_scanner_cur_token(scan), G_TOKEN_IDENTIFIER);
  153. s = g_scanner_cur_value(scan).v_identifier;
  154. for (i = 0 ; map_hdr[i].name != NULL ; i++)
  155. {
  156. if (!g_strcasecmp(map_hdr[i].name, s))
  157. {
  158. break;
  159. }
  160. }
  161. if (map_hdr[i].name == NULL)
  162. {
  163. g_scanner_error(scan, "Mot clef invalide: %s.\n", s);
  164. abort();
  165. }
  166. parser_check_type(scan, g_scanner_get_next_token(scan), G_TOKEN_EQUAL_SIGN);
  167. scope = scan->scope_id;
  168. g_scanner_set_scope(scan, map_hdr[i].scope);
  169. switch (map_hdr[i].type)
  170. {
  171. case G_TOKEN_INT:
  172. G_STRUCT_MEMBER(
  173. int, conf, map_hdr[i].offs) = parser_get_int(scan);
  174. break;
  175. case G_TOKEN_FLOAT:
  176. G_STRUCT_MEMBER(
  177. float, conf, map_hdr[i].offs) = parser_get_float(scan);
  178. break;
  179. case G_TOKEN_STRING:
  180. G_STRUCT_MEMBER(
  181. char *, conf, map_hdr[i].offs) = parser_get_string(scan);
  182. break;
  183. default:
  184. g_scanner_error(scan, "Fonction non implement�e.\n");
  185. abort();
  186. };
  187. g_scanner_set_scope(scan, scope);
  188. parser_check_type(scan, g_scanner_get_next_token(scan), G_TOKEN_SEMICOLON);
  189. #endif
  190. }
  191. static void map_load_header(GScanner *scan, conf_t *conf)
  192. {
  193. #if 0
  194. parser_check_type(scan, g_scanner_get_next_token(scan), G_TOKEN_LEFT_BRACE);
  195. parser_check_type(scan, g_scanner_get_next_token(scan), G_TOKEN_IDENTIFIER);
  196. if (strcmp(g_scanner_cur_value(scan).v_identifier, "header"))
  197. {
  198. g_scanner_error(scan, "Section [header] non trouv�e.\n");
  199. abort();
  200. }
  201. parser_check_type(scan, g_scanner_get_next_token(scan), G_TOKEN_RIGHT_BRACE);
  202. while (g_scanner_get_next_token(scan) != G_TOKEN_LEFT_BRACE)
  203. {
  204. map_load_header_value(scan, conf);
  205. }
  206. if (conf->nb_objects <= 0)
  207. {
  208. g_scanner_error(scan, "Nombre d'objets invalide.\n");
  209. abort();
  210. }
  211. parser_check_type(scan, g_scanner_get_next_token(scan), G_TOKEN_IDENTIFIER);
  212. if (strcmp(g_scanner_cur_value(scan).v_identifier, "objects"))
  213. {
  214. g_scanner_error(scan, "Section [objects] non trouv�e.\n");
  215. abort();
  216. }
  217. parser_check_type(scan, g_scanner_get_next_token(scan), G_TOKEN_RIGHT_BRACE);
  218. #endif
  219. }
  220. static void map_init_scopes(GScanner *scan)
  221. {
  222. #if 0
  223. static obj_type_t akx = obj_akx;
  224. static obj_type_t r4d2 = obj_r4d2;
  225. static double fnone = 0.0;
  226. static int inone = 0;
  227. static char *sand = NULL;
  228. g_scanner_scope_add_symbol(scan, MAP_SCOPE_ITEM, "r4d2", &r4d2);
  229. g_scanner_scope_add_symbol(scan, MAP_SCOPE_ITEM, "akx", &akx);
  230. g_scanner_scope_add_symbol(scan, MAP_SCOPE_ITEM, "anakronox", &akx);
  231. g_scanner_scope_add_symbol(scan, MAP_SCOPE_TEAM, "none", &inone);
  232. g_scanner_scope_add_symbol(scan, MAP_SCOPE_TURN, "none", &inone);
  233. g_scanner_scope_add_symbol(scan, MAP_SCOPE_SPEED, "none", &fnone);
  234. g_scanner_scope_add_symbol(scan, MAP_SCOPE_SEE, "all", &fnone);
  235. g_scanner_scope_add_symbol(scan, MAP_SCOPE_SAND, "default", &sand);
  236. #endif
  237. }
  238. void load_map(conf_t *conf)
  239. {
  240. GScanner *scan;
  241. int fd;
  242. fd = open(conf->map_name, O_RDONLY);
  243. if (fd == -1)
  244. {
  245. fprintf(stderr, "Erreur: impossible d'ouvrir la carte (%s): %s\n",
  246. conf->map_name, strerror(errno));
  247. abort();
  248. }
  249. #if 0
  250. scan = g_scanner_new(NULL);
  251. scan->config->int_2_float = FALSE;
  252. scan->config->case_sensitive = FALSE;
  253. scan->input_name = conf->map_name;
  254. #else
  255. scan = NULL;
  256. #endif
  257. map_init_scopes(scan);
  258. #if 0
  259. g_scanner_set_scope(scan, MAP_SCOPE_NONE);
  260. g_scanner_input_file(scan, fd);
  261. #endif
  262. map_load_header(scan, conf);
  263. gl_objects = shm_alloc(sizeof(*gl_objects) * conf->nb_objects,
  264. get_shm_world_id());
  265. map_load_data(scan, conf);
  266. #if 0
  267. g_scanner_destroy(scan);
  268. #endif
  269. close(fd);
  270. }