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.1 by elmex, Sun Aug 13 17:16:01 2006 UTC vs.
Revision 1.16 by root, Sat Sep 16 22:24:12 2006 UTC

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

Diff Legend

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