/EQEmuServer/utils/apathing/load_db.cpp

http://projecteqemu.googlecode.com/ · C++ · 276 lines · 208 code · 51 blank · 17 comment · 53 complexity · 4882220a8ff43b53bf242add8a32f4c9 MD5 · raw file 

    

  1. /*

    2. 

  2. 

    3. 

  3. Fear Pathing generation utility.

    4. 

  4. (c) 2005 Father Nitwit

    5. 

  5. 

    6. 

  6. */

    7. 

  7. #include "../common/types.h"

    8. 

  8. #include "../zone/map.h"

    9. 

  9. #include "../common/rdtsc.h"

    10. 

  10. #include "quadtree.h"

    11. 

  11. #include "apathing.h"

    12. 

  12. #include <stdio.h>

    13. 

  13. #include <mysql.h>

    14. 

  14. #include <stdlib.h>

    15. 

  15. #include <string.h>

    16. 

  16. #include <gd.h>

    17. 

  17. 

    18. 

  18. 

    19. 

  19. 

    20. 

  20. bool load_paths_from_db(MYSQL *m, Map *map, const char *zone, list<PathGraph*> &db_paths, list<PathNode*> &end_points) {

    21. 

  21. 	char query[512];

    22. 

  22. 	

    23. 

  23. 	sprintf(query, 

    24. 

  24. 		"SELECT x,y,z,gridid FROM grid_entries,zone "

    25. 

  25. 		"WHERE zone.zoneidnumber=zoneid AND short_name='%s' "

    26. 

  26. 		"ORDER BY gridid,number", zone);

    27. 

  27. 	if(mysql_query(m, query) != 0) {

    28. 

  28. 		printf("Unable to query: %s\n", mysql_error(m));

    29. 

  29. 		return(false);

    30. 

  30. 	}

    31. 

  31. 	

    32. 

  32. 	MYSQL_RES *res = mysql_store_result(m);

    33. 

  33. 	if(res == NULL) {

    34. 

  34. 		printf("Unable to store res: %s\n", mysql_error(m));

    35. 

  35. 		return(false);

    36. 

  36. 	}

    37. 

  37. 	

    38. 

  38. 	MYSQL_ROW row;

    39. 

  39. 	

    40. 

  40. 	PathNode *cur = NULL, *last = NULL, *first = NULL;

    41. 

  41. 	PathGraph *g = NULL;

    42. 

  42. 	int cur_g = -1,last_g = -1;

    43. 

  43. 	

    44. 

  44. //	int lid = 0;

    45. 

  45. 	

    46. 

  46. 	while((row = mysql_fetch_row(res))) {

    47. 

  47. 		last = cur;

    48. 

  48. 		cur = new PathNode;

    49. 

  49. //		cur->load_id = lid++;

    50. 

  50. 		cur->x = atof(row[0]);

    51. 

  51. 		cur->y = atof(row[1]);

    52. 

  52. 		cur->z = atof(row[2]);

    53. 

  53. 		cur_g = atoi(row[3]);

    54. 

  54. 		if(cur_g != last_g) {

    55. 

  55. 			if(g != NULL) {

    56. 

  56. 				//if we have a first and last node for this path

    57. 

  57. 				//and they are not the same node, try to connect them.

    58. 

  58. 				if(first != NULL && last != NULL && first != last && last->Dist2(first) < ENDPOINT_CONNECT_MAX_DISTANCE*ENDPOINT_CONNECT_MAX_DISTANCE) {

    59. 

  59. 					if(CheckLOS(map, last, first))

    60. 

  60. 						g->add_edge(last, first);

    61. 

  61. 				}

    62. 

  62. #ifdef LINK_PATH_ENDPOINTS

    63. 

  63. 				if(first != last && last != NULL)

    64. 

  64. 					end_points.push_back(last);

    65. 

  65. #endif

    66. 

  66. 				db_paths.push_back(g);

    67. 

  67. 			}

    68. 

  68. 			g = new PathGraph();

    69. 

  69. 			first = cur;

    70. 

  70. 			last_g = cur_g;

    71. 

  71. 			last = NULL;

    72. 

  72. 		}

    73. 

  73. 		

    74. 

  74. 		g->nodes.push_back(cur);

    75. 

  75. 		

    76. 

  76. #ifdef LINK_PATH_ENDPOINTS

    77. 

  77. 		//this is a begining point

    78. 

  78. 		if(last == NULL)

    79. 

  79. 			end_points.push_back(cur);

    80. 

  80. #endif

    81. 

  81. 		

    82. 

  82. 		if(last != NULL) {

    83. 

  83. #ifdef SPLIT_INVALID_PATHS

    84. 

  84. 			if(CheckLOS(map, last, cur)) {

    85. 

  85. 				g->edges.push_back(new PathEdge(last, cur));

    86. 

  86. 			} else {

    87. 

  87. 				//no LOS, split the path into two

    88. 

  88. 				load_split_paths++;

    89. 

  89. 				last_g = -1;	//tell this thing to start over

    90. 

  90. 			}

    91. 

  91. #else

    92. 

  92. 			g->edges.push_back(new PathEdge(last, cur));

    93. 

  93. #endif

    94. 

  94. 		}

    95. 

  95. 	}

    96. 

  96. 	

    97. 

  97. 	//handle the last active path

    98. 

  98. 	if(g != NULL) {

    99. 

  99. 		if(first != NULL && cur->Dist2(first) < ENDPOINT_CONNECT_MAX_DISTANCE*ENDPOINT_CONNECT_MAX_DISTANCE) {

    100. 

  100. 			if(CheckLOS(map, cur, first))

    101. 

  101. 				g->add_edge(cur, first);

    102. 

  102. 		}

    103. 

  103. 		db_paths.push_back(g);

    104. 

  104. 	}

    105. 

  105. 	

    106. 

  106. 	mysql_free_result(res);

    107. 

  107. 	return(true);

    108. 

  108. }

    109. 

  109. 

    110. 

  110. 

    111. 

  111. bool load_spawns_from_db(MYSQL *m, const char *zone, list<PathNode*> &db_spawns) {

    112. 

  112. 	char query[512];

    113. 

  113. 	

    114. 

  114. 	sprintf(query, 

    115. 

  115. 		"SELECT x,y,z FROM spawn2 "

    116. 

  116. 		"WHERE  zone='%s'", zone);

    117. 

  117. 	if(mysql_query(m, query) != 0) {

    118. 

  118. 		printf("Unable to query: %s\n", mysql_error(m));

    119. 

  119. 		return(false);

    120. 

  120. 	}

    121. 

  121. 	

    122. 

  122. 	MYSQL_RES *res = mysql_store_result(m);

    123. 

  123. 	if(res == NULL) {

    124. 

  124. 		printf("Unable to store res: %s\n", mysql_error(m));

    125. 

  125. 		return(false);

    126. 

  126. 	}

    127. 

  127. 	

    128. 

  128. 	MYSQL_ROW row;

    129. 

  129. 	

    130. 

  130. 	PathNode *cur = NULL;

    131. 

  131. 	

    132. 

  132. 	while((row = mysql_fetch_row(res))) {

    133. 

  133. 		cur = new PathNode;

    134. 

  134. 		cur->x = atof(row[0]);

    135. 

  135. 		cur->y = atof(row[1]);

    136. 

  136. 		cur->z = atof(row[2]);

    137. 

  137. 		db_spawns.push_back(cur);

    138. 

  138. 	}

    139. 

  139. 	

    140. 

  140. 	mysql_free_result(res);

    141. 

  141. 	

    142. 

  142. 	return(true);

    143. 

  143. }

    144. 

  144. 

    145. 

  145. 

    146. 

  146. bool load_doors_from_db(MYSQL *m, const char *zone, list<PathNode*> &db_spawns) {

    147. 

  147. 	char query[512];

    148. 

  148. 	

    149. 

  149. 	sprintf(query, 

    150. 

  150. 		"SELECT pos_x,pos_y,pos_z FROM doors "

    151. 

  151. 		"WHERE  zone='%s'", zone);

    152. 

  152. 	if(mysql_query(m, query) != 0) {

    153. 

  153. 		printf("Unable to query: %s\n", mysql_error(m));

    154. 

  154. 		return(false);

    155. 

  155. 	}

    156. 

  156. 	

    157. 

  157. 	MYSQL_RES *res = mysql_store_result(m);

    158. 

  158. 	if(res == NULL) {

    159. 

  159. 		printf("Unable to store res: %s\n", mysql_error(m));

    160. 

  160. 		return(false);

    161. 

  161. 	}

    162. 

  162. 	

    163. 

  163. 	MYSQL_ROW row;

    164. 

  164. 	

    165. 

  165. 	PathNode *cur = NULL;

    166. 

  166. 	

    167. 

  167. 	while((row = mysql_fetch_row(res))) {

    168. 

  168. 		cur = new PathNode;

    169. 

  169. 		cur->x = atof(row[0]);

    170. 

  170. 		cur->y = atof(row[1]);

    171. 

  171. 		cur->z = atof(row[2]);

    172. 

  172. 		//TODO: it would be nice if we could get to the middle of these

    173. 

  173. 		//doors, not the edge of them which I assume these points are

    174. 

  174. 		db_spawns.push_back(cur);

    175. 

  175. 	}

    176. 

  176. 	

    177. 

  177. 	mysql_free_result(res);

    178. 

  178. 	

    179. 

  179. 	return(true);

    180. 

  180. }

    181. 

  181. 

    182. 

  182. 

    183. 

  183. bool load_hints_from_db(MYSQL *m, const char *zone, list<PathNode*> &db_spawns) {

    184. 

  184. 	char query[512];

    185. 

  185. 	

    186. 

  186. 	sprintf(query, 

    187. 

  187. 		"SELECT x,y,z,forced,disjoint FROM fear_hints "

    188. 

  188. 		"WHERE  zone='%s'", zone);

    189. 

  189. 	if(mysql_query(m, query) != 0) {

    190. 

  190. 		printf("Unable to query: %s\n", mysql_error(m));

    191. 

  191. 		return(false);

    192. 

  192. 	}

    193. 

  193. 	

    194. 

  194. 	MYSQL_RES *res = mysql_store_result(m);

    195. 

  195. 	if(res == NULL) {

    196. 

  196. 		printf("Unable to store res: %s\n", mysql_error(m));

    197. 

  197. 		return(false);

    198. 

  198. 	}

    199. 

  199. 	

    200. 

  200. 	MYSQL_ROW row;

    201. 

  201. 	

    202. 

  202. 	PathNode *cur = NULL;

    203. 

  203. 	

    204. 

  204. 	while((row = mysql_fetch_row(res))) {

    205. 

  205. 		cur = new PathNode;

    206. 

  206. 		cur->x = atof(row[0]);

    207. 

  207. 		cur->y = atof(row[1]);

    208. 

  208. 		cur->z = atof(row[2]);

    209. 

  209. 		cur->forced = atoi(row[3])?true:false;

    210. 

  210. 		cur->disjoint = atoi(row[4])?true:false;

    211. 

  211. 		db_spawns.push_back(cur);

    212. 

  212. 	}

    213. 

  213. 	

    214. 

  214. 	mysql_free_result(res);

    215. 

  215. 	

    216. 

  216. 	return(true);

    217. 

  217. }

    218. 

  218. 

    219. 

  219. 

    220. 

  220. bool load_settings_from_db(MYSQL *m, const char *zone) {

    221. 

  221. 	char query[512];

    222. 

  222. 	

    223. 

  223. 	sprintf(query, 

    224. 

  224. 		"SELECT use_doors, min_fix_z, max_fear_distance, image_scale, split_invalid_paths,"

    225. 

  225. 		" link_path_endpoints, end_distance, split_long_min, split_long_step, same_dist, node_combine_dist,"

    226. 

  226. 		" grid_combine_dist, close_all_los, cross_count, cross_min_length, cross_max_z_diff, cross_combine_dist,"

    227. 

  227. 		" second_link_dist, link_max_dist, link_count"

    228. 

  228. 		" FROM fear_settings"

    229. 

  229. 		" WHERE zone='%s'", zone);

    230. 

  230. 	if(mysql_query(m, query) != 0) {

    231. 

  231. //		printf("Unable to query: %s\n", mysql_error(m));

    232. 

  232. 		return(false);

    233. 

  233. 	}

    234. 

  234. 	

    235. 

  235. 	MYSQL_RES *res = mysql_store_result(m);

    236. 

  236. 	if(res == NULL) {

    237. 

  237. //		printf("Unable to store res: %s\n", mysql_error(m));

    238. 

  238. 		return(false);

    239. 

  239. 	}

    240. 

  240. 	

    241. 

  241. 	MYSQL_ROW row;

    242. 

  242. 		

    243. 

  243. 	int r = 0;

    244. 

  244. 	if((row = mysql_fetch_row(res))) {

    245. 

  245. 		INCLUDE_DOORS = atoi(row[r++])?true:false;

    246. 

  246. 		MIN_FIX_Z = atof(row[r++]);

    247. 

  247. 		FEAR_MAXIMUM_DISTANCE = atof(row[r++]);

    248. 

  248. 		IMAGE_SCALE = atoi(row[r++]);

    249. 

  249. 		SPLIT_INVALID_PATHS = atoi(row[r++])?true:false;

    250. 

  250. 		LINK_PATH_ENDPOINTS = atoi(row[r++])?true:false;

    251. 

  251. 		ENDPOINT_CONNECT_MAX_DISTANCE = atof(row[r++]);

    252. 

  252. 		SPLIT_LINE_LENGTH = atof(row[r++]);

    253. 

  253. 		SPLIT_LINE_INTERVAL = atof(row[r++]);

    254. 

  254. 		CLOSE_ENOUGH = atof(row[r++]);

    255. 

  255. 		CLOSE_ENOUGH_COMBINE = atof(row[r++]);

    256. 

  256. 		MERGE_MIN_SECOND_DIST = atof(row[r++]);

    257. 

  257. 		COMBINE_CHECK_ALL_LOS = atoi(row[r++])?true:false;

    258. 

  258. 		CROSS_REDUCE_COUNT = atoi(row[r++]);

    259. 

  259. 		CROSS_MIN_LENGTH = atof(row[r++]);

    260. 

  260. 		CROSS_MAX_Z_DIFF = atof(row[r++]);

    261. 

  261. 		CLOSE_ENOUGH_CROSS = atof(row[r++]);

    262. 

  262. 		

    263. 

  263. 		SPAWN_MIN_SECOND_DIST = atof(row[r++]);

    264. 

  264. 		MAX_LINK_SPAWN_DIST = atof(row[r++]);

    265. 

  265. 		int sc = atoi(row[r++]);

    266. 

  266. 		SPAWN_LINK_TWICE = sc >= 2?true:false;

    267. 

  267. 		SPAWN_LINK_THRICE = sc >= 3?true:false;

    268. 

  268. 		mysql_free_result(res);

    269. 

  269. 		return(true);

    270. 

  270. 	}

    271. 

  271. 	

    272. 

  272. 	mysql_free_result(res);

    273. 

  273. 	

    274. 

  274. 	return(false);

    275. 

  275. }
    276.