ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/common/utils.C
(Generate patch)

Comparing deliantra/server/common/utils.C (file contents):
Revision 1.8 by root, Sat Sep 9 21:48:28 2006 UTC vs.
Revision 1.35 by root, Mon Jan 1 13:31:46 2007 UTC

1/*
2 * static char *rcsid_utils_c =
3 * "$Id: utils.C,v 1.8 2006/09/09 21:48:28 root Exp $";
4 */
5
6/* 1/*
7 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
8 3
9 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 4 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
10 Copyright (C) 1992 Frank Tore Johansen 5 Copyright (C) 1992 Frank Tore Johansen
… …
21 16
22 You should have received a copy of the GNU General Public License 17 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software 18 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 20
26 The authors can be reached via e-mail at crossfire-devel@real-time.com 21 The authors can be reached via e-mail at <crossfire@schmorp.de>
27*/ 22*/
28 23
29/* 24/*
30 * General convenience functions for crossfire. 25 * General convenience functions for crossfire.
31 */ 26 */
32 27
33#include <global.h> 28#include <global.h>
34#include <funcpoint.h> 29#include <funcpoint.h>
35#include <material.h> 30#include <material.h>
36 31
32#include <sys/time.h>
33#include <time.h>
37#include <glib.h> 34#include <glib.h>
38 35
39/* 36/*
40 * The random functions here take luck into account when rolling random 37 * The random functions here take luck into account when rolling random
41 * dice or numbers. This function has less of an impact the larger the 38 * dice or numbers. This function has less of an impact the larger the
… …
50 * and if goodbad is non-zero, luck increases the roll, if zero, it decreases. 47 * and if goodbad is non-zero, luck increases the roll, if zero, it decreases.
51 * Generally, op should be the player/caster/hitter requesting the roll, 48 * Generally, op should be the player/caster/hitter requesting the roll,
52 * not the recipient (ie, the poor slob getting hit). [garbled 20010916] 49 * not the recipient (ie, the poor slob getting hit). [garbled 20010916]
53 */ 50 */
54 51
52int
55int random_roll(int min, int max, const object *op, int goodbad) { 53random_roll (int min, int max, const object *op, int goodbad)
54{
56 int omin, diff, luck, base, ran; 55 int omin, diff, luck, base, ran;
57 56
58 omin = min; 57 omin = min;
59 diff = max - min + 1; 58 diff = max - min + 1;
60 ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */ 59 ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
61 60
62 if (max < 1 || diff < 1) { 61 if (max < 1 || diff < 1)
62 {
63 LOG(llevError, "Calling random_roll with min=%d max=%d\n", min, max); 63 LOG (llevError, "Calling random_roll with min=%d max=%d\n", min, max);
64 return(min); /* avoids a float exception */ 64 return (min); /* avoids a float exception */
65 } 65 }
66 66
67 ran = RANDOM(); 67 ran = RANDOM ();
68 68
69 if (op->type != PLAYER) 69 if (op->type != PLAYER)
70 return((ran%diff)+min); 70 return ((ran % diff) + min);
71 71
72 luck = op->stats.luck; 72 luck = op->stats.luck;
73 if (RANDOM()%base < MIN(10, abs(luck))) { 73 if (RANDOM () % base < MIN (10, abs (luck)))
74 {
74 /* we have a winner */ 75 /* we have a winner */
75 ((luck > 0) ? (luck = 1) : (luck = -1)); 76 ((luck > 0) ? (luck = 1) : (luck = -1));
76 diff -= luck; 77 diff -= luck;
77 if (diff < 1) 78 if (diff < 1)
78 return(omin); /*check again*/ 79 return (omin); /*check again */
79 ((goodbad) ? (min += luck) : (diff)); 80 ((goodbad) ? (min += luck) : (diff));
80 81
81 return(MAX(omin, MIN(max, (ran%diff)+min))); 82 return (MAX (omin, MIN (max, (ran % diff) + min)));
82 } 83 }
83 return((ran%diff)+min); 84 return ((ran % diff) + min);
84} 85}
85 86
86/* 87/*
87 * This is a 64 bit version of random_roll above. This is needed 88 * This is a 64 bit version of random_roll above. This is needed
88 * for exp loss calculations for players changing religions. 89 * for exp loss calculations for players changing religions.
89 */ 90 */
90 91
92sint64
91sint64 random_roll64(sint64 min, sint64 max, const object *op, int goodbad) { 93random_roll64 (sint64 min, sint64 max, const object *op, int goodbad)
94{
92 sint64 omin, diff, luck, ran; 95 sint64 omin, diff, luck, ran;
93 int base; 96 int base;
94 97
95 omin = min; 98 omin = min;
96 diff = max - min + 1; 99 diff = max - min + 1;
97 ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */ 100 ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
98 101
99 if (max < 1 || diff < 1) { 102 if (max < 1 || diff < 1)
100#ifndef WIN32 103 {
101 LOG(llevError, "Calling random_roll with min=%lld max=%lld\n", min, max);
102#else
103 LOG(llevError, "Calling random_roll with min=%I64d max=%I64d\n", min, max); 104 LOG (llevError, "Calling random_roll with min=%" PRId64 " max=%" PRId64 "\n", min, max);
104#endif
105 return(min); /* avoids a float exception */ 105 return (min); /* avoids a float exception */
106 } 106 }
107 107
108 /* Don't know of a portable call to get 64 bit random values. 108 /* Don't know of a portable call to get 64 bit random values.
109 * So make a call to get two 32 bit random numbers, and just to 109 * So make a call to get two 32 bit random numbers, and just to
110 * a little byteshifting. Do make sure the first one is only 110 * a little byteshifting. Do make sure the first one is only
111 * 32 bit, so we don't get skewed results 111 * 32 bit, so we don't get skewed results
112 */ 112 */
113 ran = (RANDOM() & 0xffffffff) | ((sint64)RANDOM() << 32); 113 ran = (RANDOM () & 0xffffffff) | ((sint64) RANDOM () << 32);
114 114
115 if (op->type != PLAYER) 115 if (op->type != PLAYER)
116 return((ran%diff)+min); 116 return ((ran % diff) + min);
117 117
118 luck = op->stats.luck; 118 luck = op->stats.luck;
119 if (RANDOM()%base < MIN(10, abs(luck))) { 119 if (RANDOM () % base < MIN (10, abs (luck)))
120 {
120 /* we have a winner */ 121 /* we have a winner */
121 ((luck > 0) ? (luck = 1) : (luck = -1)); 122 ((luck > 0) ? (luck = 1) : (luck = -1));
122 diff -= luck; 123 diff -= luck;
123 if (diff < 1) 124 if (diff < 1)
124 return(omin); /*check again*/ 125 return (omin); /*check again */
125 ((goodbad) ? (min += luck) : (diff)); 126 ((goodbad) ? (min += luck) : (diff));
126 127
127 return(MAX(omin, MIN(max, (ran%diff)+min))); 128 return (MAX (omin, MIN (max, (ran % diff) + min)));
128 } 129 }
129 return((ran%diff)+min); 130 return ((ran % diff) + min);
130} 131}
131 132
132/* 133/*
133 * Roll a number of dice (2d3, 4d6). Uses op to determine luck, 134 * Roll a number of dice (2d3, 4d6). Uses op to determine luck,
134 * If goodbad is non-zero, luck increases the roll, if zero, it decreases. 135 * If goodbad is non-zero, luck increases the roll, if zero, it decreases.
135 * Generally, op should be the player/caster/hitter requesting the roll, 136 * Generally, op should be the player/caster/hitter requesting the roll,
136 * not the recipient (ie, the poor slob getting hit). 137 * not the recipient (ie, the poor slob getting hit).
137 * The args are num D size (ie 4d6) [garbled 20010916] 138 * The args are num D size (ie 4d6) [garbled 20010916]
138 */ 139 */
139 140
141int
140int die_roll(int num, int size, const object *op, int goodbad) { 142die_roll (int num, int size, const object *op, int goodbad)
143{
141 int min, diff, luck, total, i, gotlucky, base, ran; 144 int min, diff, luck, total, i, gotlucky, base, ran;
142 145
143 diff = size; 146 diff = size;
144 min = 1; 147 min = 1;
145 luck = total = gotlucky = 0; 148 luck = total = gotlucky = 0;
146 ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */ 149 ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
147 if (size < 2 || diff < 1) { 150 if (size < 2 || diff < 1)
151 {
148 LOG(llevError, "Calling die_roll with num=%d size=%d\n", num, size); 152 LOG (llevError, "Calling die_roll with num=%d size=%d\n", num, size);
149 return(num); /* avoids a float exception */ 153 return (num); /* avoids a float exception */
150 } 154 }
151 155
152 if (op->type == PLAYER) 156 if (op->type == PLAYER)
153 luck = op->stats.luck; 157 luck = op->stats.luck;
154 158
155 for (i = 0; i < num; i++) { 159 for (i = 0; i < num; i++)
160 {
156 if (RANDOM()%base < MIN(10, abs(luck)) && !gotlucky) { 161 if (RANDOM () % base < MIN (10, abs (luck)) && !gotlucky)
162 {
157 /* we have a winner */ 163 /* we have a winner */
158 gotlucky++; 164 gotlucky++;
159 ((luck > 0) ? (luck = 1) : (luck = -1)); 165 ((luck > 0) ? (luck = 1) : (luck = -1));
160 diff -= luck; 166 diff -= luck;
161 if (diff < 1) 167 if (diff < 1)
162 return(num); /*check again*/ 168 return (num); /*check again */
163 ((goodbad) ? (min += luck) : (diff)); 169 ((goodbad) ? (min += luck) : (diff));
164 ran = RANDOM(); 170 ran = RANDOM ();
165 total += MAX(1, MIN(size, (ran%diff)+min)); 171 total += MAX (1, MIN (size, (ran % diff) + min));
172 }
166 } else { 173 else
174 {
167 total += RANDOM()%size+1; 175 total += RANDOM () % size + 1;
168 } 176 }
169 } 177 }
170 return(total); 178 return (total);
171} 179}
172 180
173/* 181/*
174 * Another convenience function. Returns a number between min and max. 182 * Another convenience function. Returns a number between min and max.
175 * It is suggested one use these functions rather than RANDOM()%, as it 183 * It is suggested one use these functions rather than RANDOM()%, as it
176 * would appear that a number of off-by-one-errors exist due to improper 184 * would appear that a number of off-by-one-errors exist due to improper
177 * use of %. This should also prevent SIGFPE. 185 * use of %. This should also prevent SIGFPE.
178 */ 186 */
179 187
188int
180int rndm(int min, int max) 189rndm (int min, int max)
181{ 190{
182 int diff; 191 int diff;
183 192
184 diff = max - min + 1; 193 diff = max - min + 1;
185 if (max < 1 || diff < 1) 194 if (max < 1 || diff < 1)
186 return(min); 195 return (min);
187 196
188 return(RANDOM()%diff+min); 197 return (RANDOM () % diff + min);
189} 198}
190 199
191/* decay and destroy persihable items in a map */ 200/* decay and destroy perishable items in a map */
192 201void
193void decay_objects(mapstruct *m) 202maptile::decay_objects ()
194{ 203{
195 int x, y, destroy; 204 if (!spaces)
196 object *op, *otmp;
197
198 if (m->unique)
199 return; 205 return;
200 206
201 for (x=0; x < MAP_WIDTH(m); x++) 207 for (mapspace *ms = spaces + size (); ms-- > spaces; )
202 for (y=0; y < MAP_HEIGHT(m); y++) 208 for (object *above, *op = ms->bot; op; op = above)
203 for (op = get_map_ob(m, x, y); op; op = otmp) { 209 {
210 above = op->above;
211
204 destroy = 0; 212 bool destroy = 0;
205 otmp = op->above; 213
214 // do not decay anything above unique floor tiles (yet :)
206 if (QUERY_FLAG(op,FLAG_IS_FLOOR) && QUERY_FLAG(op, FLAG_UNIQUE)) 215 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
207 break; 216 break;
217
208 if (QUERY_FLAG(op, FLAG_IS_FLOOR) || 218 if (QUERY_FLAG (op, FLAG_IS_FLOOR)
209 QUERY_FLAG(op, FLAG_OBJ_ORIGINAL) || 219 || QUERY_FLAG (op, FLAG_OBJ_ORIGINAL)
210 QUERY_FLAG(op, FLAG_OBJ_SAVE_ON_OVL) || 220 || QUERY_FLAG (op, FLAG_OBJ_SAVE_ON_OVL)
211 QUERY_FLAG(op, FLAG_UNIQUE) || 221 || QUERY_FLAG (op, FLAG_UNIQUE)
212 QUERY_FLAG(op, FLAG_OVERLAY_FLOOR) || 222 || QUERY_FLAG (op, FLAG_OVERLAY_FLOOR)
213 QUERY_FLAG(op, FLAG_UNPAID) || IS_LIVE(op)) 223 || QUERY_FLAG (op, FLAG_UNPAID)
214 continue; 224 || op->is_alive ())
215 /* otherwise, we decay and destroy */ 225 ; // do not decay
216 if (IS_WEAPON(op)) { 226 else if (op->is_weapon ())
227 {
217 op->stats.dam--; 228 op->stats.dam--;
218 if (op->stats.dam < 0) 229 if (op->stats.dam < 0)
219 destroy = 1; 230 destroy = 1;
220 } else if (IS_ARMOR(op)) {
221 op->stats.ac--;
222 if (op->stats.ac < 0)
223 destroy = 1;
224 } else if (op->type == FOOD) {
225 op->stats.food -= rndm(5,20);
226 if (op->stats.food < 0)
227 destroy = 1;
228 } else {
229 if (op->material & M_PAPER || op->material & M_LEATHER ||
230 op->material & M_WOOD || op->material & M_ORGANIC ||
231 op->material & M_CLOTH || op->material & M_LIQUID)
232 destroy = 1;
233 if (op->material & M_IRON && rndm(1,5) == 1)
234 destroy = 1;
235 if (op->material & M_GLASS && rndm(1,2) == 1)
236 destroy = 1;
237 if ((op->material & M_STONE || op->material & M_ADAMANT) &&
238 rndm(1,10) == 1)
239 destroy = 1;
240 if ((op->material & M_SOFT_METAL || op->material & M_BONE) &&
241 rndm(1,3) == 1)
242 destroy = 1;
243 if (op->material & M_ICE && MAP_TEMP(m) > 32)
244 destroy = 1;
245 }
246 /* adjust overall chance below */
247 if (destroy && rndm(0, 1)) {
248 remove_ob(op);
249 free_object(op);
250 }
251 } 231 }
232 else if (op->is_armor ())
233 {
234 op->stats.ac--;
235 if (op->stats.ac < 0)
236 destroy = 1;
237 }
238 else if (op->type == FOOD)
239 {
240 op->stats.food -= rndm (5, 20);
241 if (op->stats.food < 0)
242 destroy = 1;
243 }
244 else
245 {
246 int mat = op->material;
247
248 if (mat & M_PAPER
249 || mat & M_LEATHER
250 || mat & M_WOOD
251 || mat & M_ORGANIC
252 || mat & M_CLOTH
253 || mat & M_LIQUID
254 || (mat & M_IRON && rndm (1, 5) == 1)
255 || (mat & M_GLASS && rndm (1, 2) == 1)
256 || ((mat & M_STONE || mat & M_ADAMANT) && rndm (1, 10) == 1)
257 || ((mat & M_SOFT_METAL || mat & M_BONE) && rndm (1, 3) == 1)
258 || (mat & M_ICE && temp > 32))
259 destroy = 1;
260 }
261
262 /* adjust overall chance below */
263 if (destroy && rndm (0, 1))
264 op->destroy ();
265 }
252} 266}
253 267
254/* convert materialname to materialtype_t */ 268/* convert materialname to materialtype_t */
255 269
270materialtype_t *
256materialtype_t *name_to_material(const char *name) 271name_to_material (const char *name)
257{ 272{
258 materialtype_t *mt, *nmt; 273 materialtype_t *mt, *nmt;
259 274
260 mt = NULL; 275 mt = NULL;
261 for (nmt = materialt; nmt != NULL && nmt->next != NULL; nmt=nmt->next) { 276 for (nmt = materialt; nmt != NULL && nmt->next != NULL; nmt = nmt->next)
277 {
262 if (strcmp(name, nmt->name) == 0) { 278 if (strcmp (name, nmt->name) == 0)
279 {
263 mt = nmt; 280 mt = nmt;
264 break; 281 break;
265 } 282 }
266 } 283 }
267 return mt; 284 return mt;
268} 285}
269 286
270/* when doing transmutation of objects, we have to recheck the resistances, 287/* when doing transmutation of objects, we have to recheck the resistances,
271 * as some that did not apply previously, may apply now. 288 * as some that did not apply previously, may apply now.
272 */ 289 */
273 290
291void
274void transmute_materialname(object *op, const object *change) 292transmute_materialname (object *op, const object *change)
275{ 293{
276 materialtype_t *mt; 294 materialtype_t *mt;
277 int j; 295 int j;
278 296
279 if (op->materialname == NULL) 297 if (op->materialname == NULL)
280 return; 298 return;
281 299
282 if (change->materialname != NULL && 300 if (change->materialname != NULL && strcmp (op->materialname, change->materialname))
283 strcmp(op->materialname, change->materialname))
284 return; 301 return;
285 302
286 if (!IS_ARMOR(op)) 303 if (!op->is_armor ())
287 return; 304 return;
288 305
289 mt = name_to_material(op->materialname); 306 mt = name_to_material (op->materialname);
290 if (!mt) { 307 if (!mt)
308 {
291 LOG(llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->name, &op->name, &op->materialname); 309 LOG (llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->name, &op->name, &op->materialname);
292 return; 310 return;
293 } 311 }
294 312
295 for (j=0; j < NROFATTACKS; j++) 313 for (j = 0; j < NROFATTACKS; j++)
296 if (op->resist[j] == 0 && change->resist[j] != 0) { 314 if (op->resist[j] == 0 && change->resist[j] != 0)
315 {
297 op->resist[j] += mt->mod[j]; 316 op->resist[j] += mt->mod[j];
298 if (op->resist[j] > 100) 317 if (op->resist[j] > 100)
299 op->resist[j] = 100; 318 op->resist[j] = 100;
300 if (op->resist[j] < -100) 319 if (op->resist[j] < -100)
301 op->resist[j] = -100; 320 op->resist[j] = -100;
302 } 321 }
303} 322}
304 323
305/* set the materialname and type for an item */ 324/* set the materialname and type for an item */
325void
306void set_materialname(object *op, int difficulty, materialtype_t *nmt) 326set_materialname (object *op, int difficulty, materialtype_t *nmt)
307{ 327{
308 materialtype_t *mt, *lmt; 328 materialtype_t *mt, *lmt;
329
309#ifdef NEW_MATERIAL_CODE 330#ifdef NEW_MATERIAL_CODE
310 int j; 331 int j;
311#endif 332#endif
312 333
313 if (op->materialname != NULL) 334 if (op->materialname != NULL)
314 return; 335 return;
315 336
316 337
317 338
318 if (nmt == NULL) { 339 if (nmt == NULL)
340 {
319 lmt = NULL; 341 lmt = NULL;
320#ifndef NEW_MATERIAL_CODE 342#ifndef NEW_MATERIAL_CODE
321 for (mt = materialt; mt != NULL && mt->next != NULL; mt=mt->next) { 343 for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next)
344 {
322 if (op->material & mt->material) { 345 if (op->material & mt->material)
346 {
323 lmt = mt; 347 lmt = mt;
348 break;
349 }
350 }
351
352#else
353 for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next)
354 {
355 if (op->material & mt->material && rndm (1, 100) <= mt->chance &&
356 difficulty >= mt->difficulty && (op->magic >= mt->magic || mt->magic == 0))
357 {
358 lmt = mt;
359 if (!(op->is_weapon () || op->is_armor ()))
324 break; 360 break;
325 } 361 }
326 } 362 }
363#endif
364 }
365 else
366 {
367 lmt = nmt;
368 }
327 369
370 if (lmt != NULL)
371 {
372#ifndef NEW_MATERIAL_CODE
373 op->materialname = lmt->name;
374 return;
328#else 375#else
329 for (mt = materialt; mt != NULL && mt->next != NULL; mt=mt->next) { 376
330 if (op->material & mt->material && rndm(1, 100) <= mt->chance && 377 if (op->stats.dam && op->is_weapon ())
331 difficulty >= mt->difficulty &&
332 (op->magic >= mt->magic || mt->magic == 0)) {
333 lmt = mt;
334 if (!(IS_WEAPON(op) || IS_ARMOR(op)))
335 break;
336 }
337 } 378 {
338#endif
339 } else {
340 lmt = nmt;
341 }
342
343 if (lmt != NULL) {
344#ifndef NEW_MATERIAL_CODE
345 op->materialname = lmt->name;
346 return;
347#else
348
349 if (op->stats.dam && IS_WEAPON(op)) {
350 op->stats.dam += lmt->damage; 379 op->stats.dam += lmt->damage;
351 if (op->stats.dam < 1) 380 if (op->stats.dam < 1)
352 op->stats.dam = 1; 381 op->stats.dam = 1;
353 } 382 }
354 if (op->stats.sp && op->type == BOW) 383 if (op->stats.sp && op->type == BOW)
355 op->stats.sp += lmt->sp; 384 op->stats.sp += lmt->sp;
356 if (op->stats.wc && IS_WEAPON(op)) 385 if (op->stats.wc && op->is_weapon ())
357 op->stats.wc += lmt->wc; 386 op->stats.wc += lmt->wc;
358 if (IS_ARMOR(op)) { 387 if (op->is_armor ())
388 {
359 if (op->stats.ac) 389 if (op->stats.ac)
360 op->stats.ac += lmt->ac; 390 op->stats.ac += lmt->ac;
361 for (j=0; j < NROFATTACKS; j++) 391 for (j = 0; j < NROFATTACKS; j++)
362 if (op->resist[j] != 0) { 392 if (op->resist[j] != 0)
393 {
363 op->resist[j] += lmt->mod[j]; 394 op->resist[j] += lmt->mod[j];
364 if (op->resist[j] > 100) 395 if (op->resist[j] > 100)
365 op->resist[j] = 100; 396 op->resist[j] = 100;
366 if (op->resist[j] < -100) 397 if (op->resist[j] < -100)
367 op->resist[j] = -100; 398 op->resist[j] = -100;
368 } 399 }
369 } 400 }
370 op->materialname = add_string(lmt->name); 401 op->materialname = add_string (lmt->name);
371 /* dont make it unstackable if it doesn't need to be */ 402 /* dont make it unstackable if it doesn't need to be */
372 if (IS_WEAPON(op) || IS_ARMOR(op)) { 403 if (op->is_weapon () || op->is_armor ())
404 {
373 op->weight = (op->weight * lmt->weight)/100; 405 op->weight = (op->weight * lmt->weight) / 100;
374 op->value = (op->value * lmt->value)/100; 406 op->value = (op->value * lmt->value) / 100;
375 } 407 }
376#endif 408#endif
377 } 409 }
378} 410}
379 411
380/* 412/*
381 * Strip out the media tags from a String. 413 * Strip out the media tags from a String.
382 * Warning the input string will contain the result string 414 * Warning the input string will contain the result string
383 */ 415 */
416void
384void strip_media_tag(char *message){ 417strip_media_tag (char *message)
418{
385 int in_tag=0; 419 int in_tag = 0;
386 char* dest; 420 char *dest;
387 char* src; 421 char *src;
422
388 src=dest=message; 423 src = dest = message;
389 while (*src!='\0'){ 424 while (*src != '\0')
425 {
390 if (*src=='['){ 426 if (*src == '[')
427 {
391 in_tag=1; 428 in_tag = 1;
429 }
392 } else if (in_tag && (*src==']')) 430 else if (in_tag && (*src == ']'))
393 in_tag=0; 431 in_tag = 0;
394 else if (!in_tag){ 432 else if (!in_tag)
433 {
395 *dest=*src; 434 *dest = *src;
396 dest++; 435 dest++;
397 } 436 }
398 src++; 437 src++;
399 } 438 }
400 *dest='\0'; 439 *dest = '\0';
401} 440}
402 441
442const char *
403const char* strrstr(const char* haystack, const char* needle){ 443strrstr (const char *haystack, const char *needle)
444{
404 const char* lastneedle; 445 const char *lastneedle;
446
405 lastneedle=NULL; 447 lastneedle = NULL;
406 while((haystack=strstr(haystack,needle))!=NULL){ 448 while ((haystack = strstr (haystack, needle)) != NULL)
449 {
407 lastneedle=haystack; 450 lastneedle = haystack;
408 haystack++; 451 haystack++;
409 } 452 }
410 return lastneedle; 453 return lastneedle;
411 454
412} 455}
456
413#define EOL_SIZE (sizeof("\n")-1) 457#define EOL_SIZE (sizeof("\n")-1)
458void
414void strip_endline(char* buf){ 459strip_endline (char *buf)
460{
415 if (strlen(buf)<sizeof("\n")){ 461 if (strlen (buf) < sizeof ("\n"))
462 {
416 return; 463 return;
417 } 464 }
418 if (!strcmp(buf+strlen(buf)-EOL_SIZE,"\n")) 465 if (!strcmp (buf + strlen (buf) - EOL_SIZE, "\n"))
419 buf[strlen(buf)-EOL_SIZE]='\0'; 466 buf[strlen (buf) - EOL_SIZE] = '\0';
420} 467}
421 468
422/** 469/**
423 * Replace in string src all occurrences of key by replacement. The resulting 470 * Replace in string src all occurrences of key by replacement. The resulting
424 * string is put into result; at most resultsize characters (including the 471 * string is put into result; at most resultsize characters (including the
425 * terminating null character) will be written to result. 472 * terminating null character) will be written to result.
426 */ 473 */
474void
427void replace(const char *src, const char *key, const char *replacement, char *result, size_t resultsize) 475replace (const char *src, const char *key, const char *replacement, char *result, size_t resultsize)
428{ 476{
429 size_t resultlen; 477 size_t resultlen;
430 size_t keylen; 478 size_t keylen;
431 479
432 /* special case to prevent infinite loop if key==replacement=="" */ 480 /* special case to prevent infinite loop if key==replacement=="" */
433 if(strcmp(key, replacement) == 0) 481 if (strcmp (key, replacement) == 0)
434 { 482 {
435 snprintf(result, resultsize, "%s", src); 483 snprintf (result, resultsize, "%s", src);
436 return; 484 return;
437 } 485 }
438 486
439 keylen = strlen(key); 487 keylen = strlen (key);
440 488
441 resultlen = 0; 489 resultlen = 0;
442 while(*src != '\0' && resultlen+1 < resultsize) 490 while (*src != '\0' && resultlen + 1 < resultsize)
443 { 491 {
444 if(strncmp(src, key, keylen) == 0) 492 if (strncmp (src, key, keylen) == 0)
445 { 493 {
446 snprintf(result+resultlen, resultsize-resultlen, "%s", replacement); 494 snprintf (result + resultlen, resultsize - resultlen, "%s", replacement);
447 resultlen += strlen(result+resultlen); 495 resultlen += strlen (result + resultlen);
448 src += keylen; 496 src += keylen;
449 } 497 }
450 else 498 else
451 {
452 result[resultlen++] = *src++;
453 }
454 } 499 {
500 result[resultlen++] = *src++;
501 }
502 }
455 result[resultlen] = '\0'; 503 result[resultlen] = '\0';
456} 504}
457 505
458/** 506/**
459 * Taking a string as an argument, mutate it into a string that looks like a list. 507 * Taking a string as an argument, mutate it into a string that looks like a list.
460 * a 'list' for the purposes here, is a string of items, seperated by commas, except 508 * a 'list' for the purposes here, is a string of items, seperated by commas, except
461 * for the last entry, which has an 'and' before it, and a full stop (period) after it. 509 * for the last entry, which has an 'and' before it, and a full stop (period) after it.
462 * This function will also strip all trailing non alphanumeric characters. 510 * This function will also strip all trailing non alphanumeric characters.
463 * It does not insert an oxford comma. 511 * It does not insert an oxford comma.
464 */ 512 */
465 513
514void
466void make_list_like(char *input) { 515make_list_like (char *input)
516{
467 char *p, tmp[MAX_BUF]; 517 char *p, tmp[MAX_BUF];
468 int i; 518 int i;
519
469 if (!input || strlen(input) > MAX_BUF-5) return; 520 if (!input || strlen (input) > MAX_BUF - 5)
470 /* bad stuff would happen if we continued here, the -5 is to make space for ' and ' */
471
472 strncpy(tmp, input, MAX_BUF-5);
473 /*trim all trailing commas, spaces etc.*/
474 for (i=strlen(tmp); !isalnum(tmp[i]) && i >= 0; i--)
475 tmp[i]='\0';
476 strcat(tmp, ".");
477
478 p=strrchr(tmp, ',');
479 if (p) {
480 *p='\0';
481 strcpy(input, tmp);
482 p++;
483 strcat(input, " and");
484 strcat(input, p);
485 }
486 else strcpy(input, tmp);
487 return; 521 return;
488} 522 /* bad stuff would happen if we continued here, the -5 is to make space for ' and ' */
489 523
490void * 524 strncpy (tmp, input, MAX_BUF - 5);
491zero_initialised::operator new (size_t s) 525 /*trim all trailing commas, spaces etc. */
492{ 526 for (i = strlen (tmp); !isalnum (tmp[i]) && i >= 0; i--)
493 //return calloc (1, s); 527 tmp[i] = '\0';
494 return g_slice_alloc0 (s);
495}
496 528
497void * 529 strcat (tmp, ".");
498zero_initialised::operator new [] (size_t s)
499{
500 //return calloc (1, s);
501 return g_slice_alloc0 (s);
502}
503 530
504void 531 p = strrchr (tmp, ',');
505zero_initialised::operator delete (void *p, size_t s) 532 if (p)
506{ 533 {
507 //free (p); return; 534 *p = '\0';
508 g_slice_free1 (s, p); 535 strcpy (input, tmp);
509} 536 p++;
537 strcat (input, " and");
538 strcat (input, p);
539 }
540 else
541 strcpy (input, tmp);
510 542
511void 543 return;
512zero_initialised::operator delete [] (void *p, size_t s)
513{
514 //free (p); return;
515 g_slice_free1 (s, p);
516} 544}
517 545
546/////////////////////////////////////////////////////////////////////////////
547
548void *salloc_ (int n) throw (std::bad_alloc)
549{
550 void *ptr = g_slice_alloc (n);
551
552 if (!ptr)
553 throw std::bad_alloc ();
554
555 return ptr;
556}
557
558void *salloc_ (int n, void *src) throw (std::bad_alloc)
559{
560 void *ptr = salloc_ (n);
561
562 if (src)
563 memcpy (ptr, src, n);
564 else
565 memset (ptr, 0, n);
566
567 return ptr;
568}
569
570void assign (char *dst, const char *src, int maxlen)
571{
572 if (!src)
573 src = "";
574
575 int len = strlen (src);
576
577 if (len >= maxlen - 1)
578 {
579 if (maxlen <= 4)
580 {
581 memset (dst, '.', maxlen - 1);
582 dst [maxlen - 1] = 0;
583 }
584 else
585 {
586 memcpy (dst, src, maxlen - 4);
587 memcpy (dst + maxlen - 4, "...", 4);
588 }
589 }
590 else
591 memcpy (dst, src, len + 1);
592}
593
594tstamp now ()
595{
596 struct timeval tv;
597
598 gettimeofday (&tv, 0);
599 return tstamp (tv.tv_sec) + tstamp (tv.tv_usec) * tstamp (1e-6);
600}
601
602int
603similar_direction (int a, int b)
604{
605 if (!a || !b)
606 return 0;
607
608 int diff = (b - a) & 7;
609 return diff <= 1 || diff >= 7;
610}
611

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines