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.5 by root, Fri Mar 26 00:59:20 2010 UTC vs.
Revision 1.16 by root, Mon Oct 29 23:55:52 2012 UTC

1/* 1/*
2 * This file is part of Deliantra, the Roguelike Realtime MMORPG. 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (©) 2005,2006,2007,2008,2009 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 4 * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2002 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992 Frank Tore Johansen 6 * Copyright (©) 1992 Frank Tore Johansen
7 * 7 *
8 * Deliantra is free software: you can redistribute it and/or modify it under 8 * Deliantra is free software: you can redistribute it and/or modify it under
9 * the terms of the Affero GNU General Public License as published by the 9 * the terms of the Affero GNU General Public License as published by the
10 * Free Software Foundation, either version 3 of the License, or (at your 10 * Free Software Foundation, either version 3 of the License, or (at your
11 * option) any later version. 11 * option) any later version.
12 * 12 *
13 * This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details. 16 * GNU General Public License for more details.
17 * 17 *
18 * You should have received a copy of the Affero GNU General Public License 18 * You should have received a copy of the Affero GNU General Public License
19 * and the GNU General Public License along with this program. If not, see 19 * and the GNU General Public License along with this program. If not, see
20 * <http://www.gnu.org/licenses/>. 20 * <http://www.gnu.org/licenses/>.
21 * 21 *
22 * The authors can be reached via e-mail to <support@deliantra.net> 22 * The authors can be reached via e-mail to <support@deliantra.net>
23 */ 23 */
24 24
25/* 25/*
26 * compatibility functions for older (GPL) source code parts 26 * compatibility functions for older (GPL) source code parts
… …
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
62static const char *const fatalmsgs[80] = {
63 "Failed to allocate memory",
64 "Failed repeatedly to load maps",
65 "Hashtable for archetypes is too small",
66 "Too many errors"
67};
68
69/*
70 * fatal() is meant to be called whenever a fatal signal is intercepted.
71 * It will call the emergency_save and the clean_tmp_files functions.
72 */
73void
74fatal (int err)
75{
76 LOG (llevError, "Fatal: %s\n", fatalmsgs [err]);
77 cleanup (fatalmsgs[err], 1);
78} 57}
79 58
80///////////////////////////////////////////////////////////////////////////// 59/////////////////////////////////////////////////////////////////////////////
81 60
82/* 61/*
… …
93 * 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.
94 * Generally, op should be the player/caster/hitter requesting the roll, 73 * Generally, op should be the player/caster/hitter requesting the roll,
95 * not the recipient (ie, the poor slob getting hit). [garbled 20010916] 74 * not the recipient (ie, the poor slob getting hit). [garbled 20010916]
96 */ 75 */
97int 76int
98random_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)
99{ 78{
100 r_max = max (r_min, r_max); 79 if (r_min > r_max)
80 swap (r_min, r_max);
101 81
82 int range = r_max - r_min + 1;
83 int num = rndm (r_min, r_max);
84
85 if (op->stats.luck)
86 {
102 int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */ 87 int base = range > 2 ? 20 : 50; /* d2 and d3 are corner cases */
103 88
104 if (op->type == PLAYER)
105 {
106 int luck = op->stats.luck;
107
108 if (rndm (base) < min (10, abs (luck))) 89 if (rndm (base) < min (10, abs (op->stats.luck)))
109 {
110 //TODO: take luck into account
111 } 90 {
112 } 91 // we have a winner, increase/decrease number by one accordingly
92 int adjust = sign (op->stats.luck);
113 93
114 return rndm (r_min, r_max); 94 if (!prefer_high)
95 adjust = -adjust;
96
97 num = clamp (num + adjust, r_min, r_max);
98 }
99 }
100
101 return num;
115} 102}
116 103
117/* 104/*
118 * This is a 64 bit version of random_roll above. This is needed 105 * This is a 64 bit version of random_roll above. This is needed
119 * for exp loss calculations for players changing religions. 106 * for exp loss calculations for players changing religions.
120 */ 107 */
121sint64 108sint64
122random_roll64 (sint64 r_min, sint64 r_max, const object *op, int goodbad) 109random_roll64 (sint64 r_min, sint64 r_max, const object *op, bool prefer_high)
123{ 110{
124 sint64 omin = r_min; 111 if (r_min > r_max)
112 swap (r_min, r_max);
113
125 sint64 range = max (0, r_max - r_min + 1); 114 sint64 range = r_max - r_min + 1;
126 int base = range > 2 ? 20 : 50; /* d2 and d3 are corner cases */
127
128 /* 115 /*
129 * Make a call to get two 32 bit unsigned random numbers, and just to 116 * Make a call to get two 32 bit unsigned random numbers, and just do
130 * a little bitshifting. 117 * a little bitshifting.
131 */ 118 */
132 sint64 ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31); 119 sint64 num = rndm.next () ^ (sint64 (rndm.next ()) << 31);
133 120
134 if (op->type != PLAYER) 121 num = num % range + r_min;
135 return ((ran % range) + r_min);
136 122
137 int luck = op->stats.luck; 123 if (op->stats.luck)
124 {
125 int base = range > 2 ? 20 : 50; /* d2 and d3 are corner cases */
138 126
139 if (rndm (base) < min (10, abs (luck))) 127 if (rndm (base) < min (10, abs (op->stats.luck)))
128 {
129 // we have a winner, increase/decrease number by one accordingly
130 int adjust = sign (op->stats.luck);
131
132 if (!prefer_high)
133 adjust = -adjust;
134
135 num = clamp (num + adjust, r_min, r_max);
136 }
140 { 137 }
141 /* we have a winner */
142 ((luck > 0) ? (luck = 1) : (luck = -1));
143 range -= luck;
144 if (range < 1)
145 return (omin); /*check again */
146 138
147 ((goodbad) ? (r_min += luck) : (range)); 139 return num;
148
149 return (max (omin, min (r_max, (ran % range) + r_min)));
150 }
151
152 return ran % range + r_min;
153} 140}
154 141
155/* 142/*
156 * Roll a number of dice (2d3, 4d6). Uses op to determine luck, 143 * Roll a number of dice (2d3, 4d6). Uses op to determine luck,
157 * If goodbad is non-zero, luck increases the roll, if zero, it decreases. 144 * If goodbad is non-zero, luck increases the roll, if zero, it decreases.
158 * Generally, op should be the player/caster/hitter requesting the roll, 145 * Generally, op should be the player/caster/hitter requesting the roll,
159 * not the recipient (ie, the poor slob getting hit). 146 * not the recipient (ie, the poor slob getting hit).
160 * The args are num D size (ie 4d6) [garbled 20010916] 147 * The args are num D size (ie 4d6) [garbled 20010916]
161 */ 148 */
162int 149int
163die_roll (int num, int size, const object *op, int goodbad) 150die_roll (int num, int size, const object *op, bool prefer_high)
164{ 151{
165 int min_roll, luck, total, i, gotlucky; 152 int min_roll, luck, total, i, gotlucky;
166 153
167 int diff = size; 154 int diff = size;
168 min_roll = 1; 155 min_roll = 1;
169 luck = total = gotlucky = 0; 156 luck = total = gotlucky = 0;
170 int base = diff > 2 ? 20 : 50; /* d2 and d3 are corner cases */ 157 int base = diff > 2 ? 20 : 50; /* d2 and d3 are corner cases */
171 158
172 if (size < 2 || diff < 1) 159 if (size < 2 || diff < 1)
173 { 160 {
174 LOG (llevError, "Calling die_roll with num=%d size=%d\n", num, size); 161 LOG (llevError | logBacktrace, "Calling die_roll with num=%d size=%d\n", num, size);
175 return num; /* avoids a float exception */ 162 return num; /* avoids a float exception */
176 } 163 }
177 164
178 if (op->type == PLAYER) 165 if (op->type == PLAYER)
179 luck = op->stats.luck; 166 luck = op->stats.luck;
… …
186 gotlucky++; 173 gotlucky++;
187 ((luck > 0) ? (luck = 1) : (luck = -1)); 174 ((luck > 0) ? (luck = 1) : (luck = -1));
188 diff -= luck; 175 diff -= luck;
189 if (diff < 1) 176 if (diff < 1)
190 return (num); /*check again */ 177 return (num); /*check again */
191 ((goodbad) ? (min_roll += luck) : (diff)); 178 ((prefer_high) ? (min_roll += luck) : (diff));
192 total += max (1, min (size, rndm (diff) + min_roll)); 179 total += max (1, min (size, rndm (diff) + min_roll));
193 } 180 }
194 else 181 else
195 total += rndm (size) + 1; 182 total += rndm (size) + 1;
196 } 183 }
… …
314 path = path_combine (src, dst); 301 path = path_combine (src, dst);
315 path_normalize (path); 302 path_normalize (path);
316 return (path); 303 return (path);
317} 304}
318 305
319/**
320 * open_and_uncompress() first searches for the original filename. If it exist,
321 * then it opens it and returns the file-pointer.
322 */
323FILE *
324open_and_uncompress (const char *name, int flag, int *compressed)
325{
326 *compressed = 0;
327 return fopen (name, "r");
328}
329
330/*
331 * See open_and_uncompress().
332 */
333
334void
335close_and_delete (FILE * fp, int compressed)
336{
337 fclose (fp);
338}
339
340/*
341 * Strip out the media tags from a String.
342 * Warning the input string will contain the result string
343 */
344void
345strip_media_tag (char *message)
346{
347 int in_tag = 0;
348 char *dest;
349 char *src;
350
351 src = dest = message;
352 while (*src != '\0')
353 {
354 if (*src == '[')
355 {
356 in_tag = 1;
357 }
358 else if (in_tag && (*src == ']'))
359 in_tag = 0;
360 else if (!in_tag)
361 {
362 *dest = *src;
363 dest++;
364 }
365 src++;
366 }
367 *dest = '\0';
368}
369
370#define EOL_SIZE (sizeof("\n")-1) 306#define EOL_SIZE (sizeof("\n")-1)
371void 307void
372strip_endline (char *buf) 308strip_endline (char *buf)
373{ 309{
374 if (strlen (buf) < sizeof ("\n")) 310 if (*buf && buf [strlen (buf) - 1] == '\n')
375 {
376 return;
377 }
378 if (!strcmp (buf + strlen (buf) - EOL_SIZE, "\n"))
379 buf[strlen (buf) - EOL_SIZE] = '\0'; 311 buf [strlen (buf) - 1] = '\0';
380} 312}
381 313
382/** 314/**
383 * Replace in string src all occurrences of key by replacement. The resulting 315 * Replace in string src all occurrences of key by replacement. The resulting
384 * string is put into result; at most resultsize characters (including the 316 * string is put into result; at most resultsize characters (including the

Diff Legend

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