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

Comparing deliantra/server/server/spell_util.C (file contents):
Revision 1.122 by root, Sat Dec 31 06:18:02 2011 UTC vs.
Revision 1.128 by root, Wed Nov 16 23:42:03 2016 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,2010,2011 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 4 * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2001 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2001 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#include <global.h> 25#include <global.h>
26#include <spells.h> 26#include <spells.h>
… …
255 return spop; 255 return spop;
256 256
257 return 0; 257 return 0;
258} 258}
259 259
260/* 260/*
261 * Look at object 'op' and see if they know the spell 261 * Look at object 'op' and see if they know the spell
262 * spname. This is pretty close to check_spell_known 262 * spname. This is pretty close to check_spell_known
263 * above, but it uses a looser matching mechanism. 263 * above, but it uses a looser matching mechanism.
264 * returns the matching spell object, or NULL. 264 * returns the matching spell object, or NULL.
265 * If we match multiple spells but don't get an 265 * If we match multiple spells but don't get an
266 * exact match, we also return NULL. 266 * exact match, we also return NULL.
267 */ 267 */
268object * 268object *
269lookup_spell_by_name (object *op, const char *spname) 269object::find_spell (const_utf8_string prefix) const
270{ 270{
271 object *spob1 = 0, *spob2 = 0; 271 if (shstr_cmp name = prefix)
272 int nummatch = 0; 272 {
273 273 // case 1, match spell name exactly
274 if (!spname)
275 return 0;
276
277 /* Try to find the spell. We store the results in spob1
278 * and spob2 - spob1 is only taking the length of
279 * the past spname, spob2 uses the length of the spell name.
280 */
281 for (object *spob = op->inv; spob; spob = spob->below) 274 for (object *spob = inv; spob; spob = spob->below)
275 if (spob->name == name && spob->type == SPELL)
276 return spob;
282 { 277 }
278 else
279 {
280 // case 2, match prefix
281 int len = strlen (prefix);
282
283 for (object *spob = inv; spob; spob = spob->below)
283 if (spob->type == SPELL) 284 if (spob->type == SPELL
284 { 285 && spob->name.length () < len
285 // TODO: WTF? 286 && prefix [spob->name.length ()] <= ' '
286 if (!strncmp (spob->name, spname, strlen (spname))) 287 && !memcmp (prefix, spob->name, spob->name.length ()))
287 {
288 nummatch++;
289 spob1 = spob;
290 }
291 else if (!strncmp (spob->name, spname, strlen (spob->name)))
292 {
293 /* if spells have ambiguous names, it makes matching
294 * really difficult. (eg, fire and fireball would
295 * fall into this category). It shouldn't be hard to
296 * make sure spell names don't overlap in that fashion.
297 */
298 if (spob2)
299 LOG (llevError, "Found multiple spells with overlapping base names: %s, %s\n", &spob2->name, &spob->name);
300
301 spob2 = spob;
302 }
303 }
304 }
305 /* if we have best match, return it. Otherwise, if we have one match
306 * on the loser match, return that, otehrwise null
307 */
308 if (spob2)
309 return spob2; 288 return spob;
289 }
310 290
311 if (spob1 && nummatch == 1)
312 return spob1;
313
314 return NULL; 291 return 0;
315} 292}
316 293
317/* reflwall - decides weither the (spell-)object sp_op will 294/* reflwall - decides weither the (spell-)object sp_op will
318 * be reflected from the given mapsquare. Returns 1 if true. 295 * be reflected from the given mapsquare. Returns 1 if true.
319 * (Note that for living creatures there is a small chance that 296 * (Note that for living creatures there is a small chance that
… …
338 315
339/* cast_create_object: creates object new_op in direction dir 316/* cast_create_object: creates object new_op in direction dir
340 * or if that is blocked, beneath the player (op). 317 * or if that is blocked, beneath the player (op).
341 * we pass 'caster', but don't use it for anything. 318 * we pass 'caster', but don't use it for anything.
342 * This is really just a simple wrapper function . 319 * This is really just a simple wrapper function .
343 * returns the direction that the object was actually placed 320 * returns true to indicate whether the operation was successful.
344 * in. 321 * destroys the object is unsuccessful.
345 */ 322 */
346int 323bool
347cast_create_obj (object *op, object *caster, object *new_op, int dir) 324cast_create_obj (object *op, object *caster, object *new_op, int dir)
348{ 325{
349 maptile *m; 326 mapxy pos (op);
350 sint16 sx, sy; 327 pos.move (dir);
351 328
352 if (dir && 329 if (!pos.normalise ()
353 ((get_map_flags (op->map, &m, op->x + freearr_x[dir], op->y + freearr_y[dir], &sx, &sy) & P_OUT_OF_MAP) || 330 || pos->blocks (op) // perversely enough, we check if the palyer can reach that space
354 OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))) 331 || !new_op->can_drop_at (pos.m, pos.x, pos.y)
332 )
355 { 333 {
356 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way."); 334 op->failmsg ("Your spell fizzles! H<Something is in the way.>");
357 new_draw_info (NDI_UNIQUE, 0, op, "You cast it at your feet."); 335 new_op->destroy ();
358 dir = 0; 336 return 0;
359 } 337 }
360 338
361 new_op->set_flag (FLAG_IDENTIFIED); 339 new_op->set_flag (FLAG_IDENTIFIED);
362 op->map->insert (new_op,
363 op->x + freearr_x[dir], op->y + freearr_y[dir],
364 op,
365 dir ? 0 : INS_BELOW_ORIGINATOR);
366 340
341 pos.insert (new_op, op, dir ? 0 : INS_BELOW_ORIGINATOR);
342
367 return dir; 343 return 1;
368} 344}
369 345
370static bool 346static bool
371mergable_owner (object *o1, object *o2) 347mergable_owner (object *o1, object *o2)
372{ 348{
… …
820 op->failmsgf ("%s smites you!" HINT_GRACE, godname); 796 op->failmsgf ("%s smites you!" HINT_GRACE, godname);
821 cast_magic_storm (op, tmp, power); 797 cast_magic_storm (op, tmp, power);
822 } 798 }
823} 799}
824 800
825/* 801/*
826 * spell_failure() handles the various effects for differing degrees 802 * spell_failure() handles the various effects for differing degrees
827 * of failure badness. 803 * of failure badness.
828 * op is the player that failed. 804 * op is the player that failed.
829 * failure is a random value of how badly you failed. 805 * failure is a random value of how badly you failed.
830 * power is how many spellpoints you'd normally need for the spell. 806 * power is how many spellpoints you'd normally need for the spell.
831 * skill is the skill you'd need to cast the spell. 807 * skill is the skill you'd need to cast the spell.
832 */ 808 */
833
834void 809void
835spell_failure (object *op, int failure, int power, object *skill) 810spell_failure (object *op, int failure, int power, object *skill)
836{ 811{
837 object *tmp; 812 object *tmp;
838 813

Diff Legend

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