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.4 by root, Mon Sep 4 11:07:59 2006 UTC vs.
Revision 1.36 by pippijn, Sat Jan 6 14:42:29 2007 UTC

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

Diff Legend

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