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

Comparing deliantra/server/common/compat.C (file contents):
Revision 1.8 by root, Sun Apr 4 04:59:20 2010 UTC vs.
Revision 1.11 by root, Thu Apr 29 15:59:09 2010 UTC

… …
34 34
35#include <global.h> 35#include <global.h>
36#include "define.h" 36#include "define.h"
37#include "path.h" 37#include "path.h"
38 38
39
40/* buf_overflow() - we don't want to exceed the buffer size of 39/* buf_overflow() - we don't want to exceed the buffer size of
41 * buf1 by adding on buf2! Returns true if overflow will occur. 40 * buf1 by adding on buf2! Returns true if overflow will occur.
42 */ 41 */
43int 42int
44buf_overflow (const char *buf1, const char *buf2, int bufsize) 43buf_overflow (const char *buf1, const char *buf2, int bufsize)
… …
53 52
54 if ((len1 + len2) >= bufsize) 53 if ((len1 + len2) >= bufsize)
55 return 1; 54 return 1;
56 55
57 return 0; 56 return 0;
58}
59
60/////////////////////////////////////////////////////////////////////////////
61
62/*
63 * fatal() is meant to be called whenever a fatal signal is intercepted.
64 * It will call the emergency_save and the clean_tmp_files functions.
65 */
66//TODO: only one caller left
67void
68fatal (const char *msg)
69{
70 LOG (llevError, "FATAL: %s\n", msg);
71 cleanup (msg, 1);
72} 57}
73 58
74///////////////////////////////////////////////////////////////////////////// 59/////////////////////////////////////////////////////////////////////////////
75 60
76/* 61/*
… …
87 * and if goodbad is non-zero, luck increases the roll, if zero, it decreases. 72 * and if goodbad is non-zero, luck increases the roll, if zero, it decreases.
88 * Generally, op should be the player/caster/hitter requesting the roll, 73 * Generally, op should be the player/caster/hitter requesting the roll,
89 * not the recipient (ie, the poor slob getting hit). [garbled 20010916] 74 * not the recipient (ie, the poor slob getting hit). [garbled 20010916]
90 */ 75 */
91int 76int
92random_roll (int r_min, int r_max, const object *op, int goodbad) 77random_roll (int r_min, int r_max, const object *op, bool prefer_high)
93{ 78{
94 r_max = max (r_min, r_max); 79 r_max = max (r_min, r_max);
95 80
96 int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */ 81 int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */
97 82
… …
111/* 96/*
112 * This is a 64 bit version of random_roll above. This is needed 97 * This is a 64 bit version of random_roll above. This is needed
113 * for exp loss calculations for players changing religions. 98 * for exp loss calculations for players changing religions.
114 */ 99 */
115sint64 100sint64
116random_roll64 (sint64 r_min, sint64 r_max, const object *op, int goodbad) 101random_roll64 (sint64 r_min, sint64 r_max, const object *op, bool prefer_high)
117{ 102{
118 sint64 omin = r_min; 103 sint64 omin = r_min;
119 sint64 range = max (0, r_max - r_min + 1); 104 sint64 range = max (0, r_max - r_min + 1);
120 int base = range > 2 ? 20 : 50; /* d2 and d3 are corner cases */ 105 int base = range > 2 ? 20 : 50; /* d2 and d3 are corner cases */
121 106
122 /* 107 /*
123 * Make a call to get two 32 bit unsigned random numbers, and just to 108 * Make a call to get two 32 bit unsigned random numbers, and just do
124 * a little bitshifting. 109 * a little bitshifting.
125 */ 110 */
126 sint64 ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31); 111 sint64 ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31);
127 112
128 if (op->type != PLAYER) 113 if (op->stats.luck)
129 return ((ran % range) + r_min); 114 {
130
131 int luck = op->stats.luck; 115 int luck = op->stats.luck;
132 116
133 if (rndm (base) < min (10, abs (luck))) 117 if (rndm (base) < min (10, abs (luck)))
134 { 118 {
135 /* we have a winner */ 119 /* we have a winner */
136 ((luck > 0) ? (luck = 1) : (luck = -1)); 120 luck = luck > 0 ? 1 : -1;
121
137 range -= luck; 122 range -= luck;
138 if (range < 1) 123 if (range < 1)
139 return (omin); /*check again */ 124 return omin; /*check again */
140 125
141 ((goodbad) ? (r_min += luck) : (range)); 126 if (prefer_high)
127 r_min += luck;
142 128
143 return (max (omin, min (r_max, (ran % range) + r_min))); 129 return clamp (ran % range + r_min, omin, r_max);
130 }
144 } 131 }
145 132
146 return ran % range + r_min; 133 return ran % range + r_min;
147} 134}
148 135
… …
152 * Generally, op should be the player/caster/hitter requesting the roll, 139 * Generally, op should be the player/caster/hitter requesting the roll,
153 * not the recipient (ie, the poor slob getting hit). 140 * not the recipient (ie, the poor slob getting hit).
154 * The args are num D size (ie 4d6) [garbled 20010916] 141 * The args are num D size (ie 4d6) [garbled 20010916]
155 */ 142 */
156int 143int
157die_roll (int num, int size, const object *op, int goodbad) 144die_roll (int num, int size, const object *op, bool prefer_high)
158{ 145{
159 int min_roll, luck, total, i, gotlucky; 146 int min_roll, luck, total, i, gotlucky;
160 147
161 int diff = size; 148 int diff = size;
162 min_roll = 1; 149 min_roll = 1;
… …
180 gotlucky++; 167 gotlucky++;
181 ((luck > 0) ? (luck = 1) : (luck = -1)); 168 ((luck > 0) ? (luck = 1) : (luck = -1));
182 diff -= luck; 169 diff -= luck;
183 if (diff < 1) 170 if (diff < 1)
184 return (num); /*check again */ 171 return (num); /*check again */
185 ((goodbad) ? (min_roll += luck) : (diff)); 172 ((prefer_high) ? (min_roll += luck) : (diff));
186 total += max (1, min (size, rndm (diff) + min_roll)); 173 total += max (1, min (size, rndm (diff) + min_roll));
187 } 174 }
188 else 175 else
189 total += rndm (size) + 1; 176 total += rndm (size) + 1;
190 } 177 }
… …
308 path = path_combine (src, dst); 295 path = path_combine (src, dst);
309 path_normalize (path); 296 path_normalize (path);
310 return (path); 297 return (path);
311} 298}
312 299
313/**
314 * open_and_uncompress() first searches for the original filename. If it exist,
315 * then it opens it and returns the file-pointer.
316 */
317FILE *
318open_and_uncompress (const char *name, int flag, int *compressed)
319{
320 *compressed = 0;
321 return fopen (name, "r");
322}
323
324/*
325 * See open_and_uncompress().
326 */
327
328void
329close_and_delete (FILE * fp, int compressed)
330{
331 fclose (fp);
332}
333
334/*
335 * Strip out the media tags from a String.
336 * Warning the input string will contain the result string
337 */
338void
339strip_media_tag (char *message)
340{
341 int in_tag = 0;
342 char *dest;
343 char *src;
344
345 src = dest = message;
346 while (*src != '\0')
347 {
348 if (*src == '[')
349 {
350 in_tag = 1;
351 }
352 else if (in_tag && (*src == ']'))
353 in_tag = 0;
354 else if (!in_tag)
355 {
356 *dest = *src;
357 dest++;
358 }
359 src++;
360 }
361 *dest = '\0';
362}
363
364#define EOL_SIZE (sizeof("\n")-1) 300#define EOL_SIZE (sizeof("\n")-1)
365void 301void
366strip_endline (char *buf) 302strip_endline (char *buf)
367{ 303{
368 if (strlen (buf) < sizeof ("\n")) 304 if (*buf && buf [strlen (buf) - 1] == '\n')
369 {
370 return;
371 }
372 if (!strcmp (buf + strlen (buf) - EOL_SIZE, "\n"))
373 buf[strlen (buf) - EOL_SIZE] = '\0'; 305 buf [strlen (buf) - 1] = '\0';
374} 306}
375 307
376/** 308/**
377 * Replace in string src all occurrences of key by replacement. The resulting 309 * Replace in string src all occurrences of key by replacement. The resulting
378 * string is put into result; at most resultsize characters (including the 310 * string is put into result; at most resultsize characters (including the

Diff Legend

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