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

Comparing deliantra/server/server/spell_effect.C (file contents):
Revision 1.60 by root, Sun Jun 24 01:09:28 2007 UTC vs.
Revision 1.76 by root, Sun Oct 21 04:16:22 2007 UTC

… …
3 * 3 *
4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team 4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 * 7 *
8 * Crossfire TRT is free software; you can redistribute it and/or modify it 8 * Crossfire TRT is free software: you can redistribute it and/or modify
9 * under the terms of the GNU General Public License as published by the Free 9 * it under the terms of the GNU General Public License as published by
10 * Software Foundation; either version 2 of the License, or (at your option) 10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version. 11 * (at your option) any later version.
12 * 12 *
13 * This program is distributed in the hope that it will be useful, but 13 * This program is distributed in the hope that it will be useful,
14 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * for more details. 16 * GNU General Public License for more details.
17 * 17 *
18 * You should have received a copy of the GNU General Public License along 18 * You should have received a copy of the GNU General Public License
19 * with Crossfire TRT; if not, write to the Free Software Foundation, Inc. 51 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 * 20 *
22 * The authors can be reached via e-mail to <crossfire@schmorp.de> 21 * The authors can be reached via e-mail to <crossfire@schmorp.de>
23 */ 22 */
24 23
25#include <global.h> 24#include <global.h>
… …
70 return 0; 69 return 0;
71 } 70 }
72 if (!(random_roll (0, 3, op, PREFER_HIGH))) 71 if (!(random_roll (0, 3, op, PREFER_HIGH)))
73 { 72 {
74 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand)); 73 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand));
75 play_sound_map (op->map, op->x, op->y, SOUND_OB_EXPLODE); 74 op->play_sound (sound_find ("ob_explode"));
76 esrv_del_item (op->contr, wand->count); 75 esrv_del_item (op->contr, wand->count);
77 wand->destroy (); 76 wand->destroy ();
78 tmp = get_archetype ("fireball"); 77 tmp = get_archetype ("fireball");
79 tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10; 78 tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;
80 79
… …
123 * great a plus, the default is used. 122 * great a plus, the default is used.
124 * The # of arrows created also goes up with level, so if a 30th level mage 123 * The # of arrows created also goes up with level, so if a 30th level mage
125 * wants LOTS of arrows, and doesn't care what the plus is he could 124 * wants LOTS of arrows, and doesn't care what the plus is he could
126 * create nonnmagic arrows, or even -1, etc... 125 * create nonnmagic arrows, or even -1, etc...
127 */ 126 */
128
129int 127int
130cast_create_missile (object *op, object *caster, object *spell, int dir, const char *stringarg) 128cast_create_missile (object *op, object *caster, object *spell, int dir, const char *stringarg)
131{ 129{
132 int missile_plus = 0, bonus_plus = 0; 130 int bonus_plus = 0;
133 const char *missile_name; 131 const char *missile_name = "arrow";
134 object *tmp, *missile;
135 132
136 missile_name = "arrow";
137
138 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 133 for (object *tmp = op->inv; tmp; tmp = tmp->below)
139 if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED)) 134 if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED))
140 missile_name = tmp->race; 135 missile_name = tmp->race;
141 136
142 missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell); 137 int missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);
143 138
144 if (archetype::find (missile_name) == NULL) 139 archetype *missile_arch = archetype::find (missile_name);
140
141 if (!missile_arch)
145 { 142 {
146 LOG (llevDebug, "Cast create_missile: could not find archetype %s\n", missile_name); 143 LOG (llevDebug, "Cast create_missile: could not find archetype %s\n", missile_name);
147 return 0; 144 return 0;
148 } 145 }
149 146
150 missile = get_archetype (missile_name); 147 object *missile = missile_arch->instance ();
151 148
152 if (stringarg) 149 if (stringarg)
153 { 150 {
154 /* If it starts with a letter, presume it is a description */ 151 /* If it starts with a letter, presume it is a description */
155 if (isalpha (*stringarg)) 152 if (isalpha (*stringarg))
… …
173 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, stringarg); 170 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, stringarg);
174 return 0; 171 return 0;
175 } 172 }
176 173
177 give_artifact_abilities (missile, al->item); 174 give_artifact_abilities (missile, al->item);
178 /* These special arrows cost something extra. Don't have them also be magical - 175 /* These special arrows cost something extra. Don't have them also be magical -
179 * otherwise, in most cases, not enough will be created. I don't want to get into 176 * otherwise, in most cases, not enough will be created. I don't want to get into
180 * the parsing of having to do both plus and type. 177 * the parsing of having to do both plus and type.
181 */ 178 */
182 bonus_plus = 1 + (al->item->value / 5); 179 bonus_plus = 1 + (al->item->value / 5);
183 missile_plus = 0; 180 missile_plus = 0;
184 } 181 }
185 else if (atoi (stringarg) < missile_plus) 182 else if (atoi (stringarg) < missile_plus)
186 missile_plus = atoi (stringarg); 183 missile_plus = atoi (stringarg);
187 } 184 }
188 185
189 if (missile_plus > 4) 186 missile_plus = clamp (missile_plus, -4, 4);
190 missile_plus = 4;
191 else if (missile_plus < -4)
192 missile_plus = -4;
193 187
194 missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell); 188 missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell);
195 missile->nrof -= 3 * (missile_plus + bonus_plus); 189 missile->nrof -= 3 * (missile_plus + bonus_plus);
196 190
197 if (missile->nrof < 1) 191 if (missile->nrof < 1)
… …
217{ 211{
218 int food_value; 212 int food_value;
219 archetype *at = NULL; 213 archetype *at = NULL;
220 object *new_op; 214 object *new_op;
221 215
222 food_value = spell_ob->stats.food + +50 * SP_level_duration_adjust (caster, spell_ob); 216 food_value = spell_ob->stats.food + 50 * SP_level_duration_adjust (caster, spell_ob);
223 217
224 if (stringarg) 218 if (stringarg)
225 { 219 {
226 at = find_archetype_by_object_type_name (FOOD, stringarg); 220 at = find_archetype_by_object_type_name (FOOD, stringarg);
227 if (at == NULL) 221 if (at == NULL)
… …
257 && at_tmp->weight < at->weight))) 251 && at_tmp->weight < at->weight)))
258 at = at_tmp; 252 at = at_tmp;
259 } 253 }
260 } 254 }
261 } 255 }
256
262 /* Pretty unlikely (there are some very low food items), but you never 257 /* Pretty unlikely (there are some very low food items), but you never
263 * know 258 * know
264 */ 259 */
265 if (!at) 260 if (!at)
266 { 261 {
… …
291 if (!dir) 286 if (!dir)
292 { 287 {
293 examine_monster (op, op); 288 examine_monster (op, op);
294 return 1; 289 return 1;
295 } 290 }
291
296 maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob); 292 maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
297 for (r = 1; r < maxrange; r++) 293 for (r = 1; r < maxrange; r++)
298 { 294 {
299 sint16 x = op->x + r * freearr_x[dir], y = op->y + r * freearr_y[dir]; 295 sint16 x = op->x + r * freearr_x[dir], y = op->y + r * freearr_y[dir];
300 296
… …
320 examine_monster (op, tmp); 316 examine_monster (op, tmp);
321 return 1; 317 return 1;
322 } 318 }
323 } 319 }
324 } 320 }
321
325 new_draw_info (NDI_UNIQUE, 0, op, "You detect nothing."); 322 new_draw_info (NDI_UNIQUE, 0, op, "You detect nothing.");
326 return 1; 323 return 1;
327} 324}
328
329 325
330/* This checks to see if 'pl' is invisible to 'mon'. 326/* This checks to see if 'pl' is invisible to 'mon'.
331 * does race check, undead check, etc 327 * does race check, undead check, etc
332 * Returns TRUE if mon can't see pl, false 328 * Returns TRUE if mon can't see pl, false
333 * otherwise. This doesn't check range, walls, etc. It 329 * otherwise. This doesn't check range, walls, etc. It
… …
335 * pl is invisible. 331 * pl is invisible.
336 */ 332 */
337int 333int
338makes_invisible_to (object *pl, object *mon) 334makes_invisible_to (object *pl, object *mon)
339{ 335{
340
341 if (!pl->invisible) 336 if (!pl->invisible)
342 return 0; 337 return 0;
338
343 if (pl->type == PLAYER) 339 if (pl->type == PLAYER)
344 { 340 {
345 /* If race isn't set, then invisible unless it is undead */ 341 /* If race isn't set, then invisible unless it is undead */
346 if (!pl->contr->invis_race) 342 if (!pl->contr->invis_race)
347 { 343 {
348 if (QUERY_FLAG (mon, FLAG_UNDEAD)) 344 if (QUERY_FLAG (mon, FLAG_UNDEAD))
349 return 0; 345 return 0;
346
350 return 1; 347 return 1;
351 } 348 }
349
352 /* invis_race is set if we get here */ 350 /* invis_race is set if we get here */
353 if (!strcmp (pl->contr->invis_race, "undead") && is_true_undead (mon)) 351 if (!strcmp (pl->contr->invis_race, "undead") && is_true_undead (mon))
354 return 1; 352 return 1;
353
355 /* No race, can't be invisible to it */ 354 /* No race, can't be invisible to it */
356 if (!mon->race) 355 if (!mon->race)
357 return 0; 356 return 0;
357
358 if (strstr (mon->race, pl->contr->invis_race)) 358 if (strstr (mon->race, pl->contr->invis_race))
359 return 1; 359 return 1;
360
360 /* Nothing matched above, return 0 */ 361 /* Nothing matched above, return 0 */
361 return 0; 362 return 0;
362 } 363 }
363 else 364 else
364 { 365 {
… …
601 602
602 if (is_dragon_pl (op)) 603 if (is_dragon_pl (op))
603 /* now grab the 'dragon_ability'-force from the player's inventory */ 604 /* now grab the 'dragon_ability'-force from the player's inventory */
604 for (tmp = op->inv; tmp; tmp = tmp->below) 605 for (tmp = op->inv; tmp; tmp = tmp->below)
605 { 606 {
606 if (tmp->type == FORCE && !strcmp (tmp->arch->archname, "dragon_ability_force")) 607 if (tmp->type == FORCE && tmp->arch->archname == shstr_dragon_ability_force)
607 { 608 {
608 if (tmp->stats.exp == 0) 609 if (tmp->stats.exp == 0)
609 buf << "Your metabolism isn't focused on anything.\n"; 610 buf << "Your metabolism isn't focused on anything.\n";
610 else 611 else
611 buf << "Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n"; 612 buf << "Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n";
612 613
613 break; 614 break;
614 } 615 }
615 } 616 }
617
618 buf << '\0'; // zero-terminate
616 619
617 new_draw_info (NDI_UNIQUE, 0, op, buf.linearise ()); 620 new_draw_info (NDI_UNIQUE, 0, op, buf.linearise ());
618 621
619 return 1; 622 return 1;
620} 623}
… …
893 896
894 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */ 897 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */
895 return 1; 898 return 1;
896} 899}
897 900
898
899/* cast_heal: Heals something. 901/* cast_heal: Heals something.
900 * op is the caster. 902 * op is the caster.
901 * dir is the direction he is casting it in. 903 * dir is the direction he is casting it in.
902 * spell is the spell object. 904 * spell is the spell object.
903 */ 905 */
… …
929 { 931 {
930 /* See how many points we actually heal. Instead of messages 932 /* See how many points we actually heal. Instead of messages
931 * based on type of spell, we instead do messages based 933 * based on type of spell, we instead do messages based
932 * on amount of damage healed. 934 * on amount of damage healed.
933 */ 935 */
934 if (heal > (tmp->stats.maxhp - tmp->stats.hp)) 936 if (heal > tmp->stats.maxhp - tmp->stats.hp)
935 heal = tmp->stats.maxhp - tmp->stats.hp; 937 heal = tmp->stats.maxhp - tmp->stats.hp;
938
936 tmp->stats.hp += heal; 939 tmp->stats.hp += heal;
937 940
938 if (tmp->stats.hp >= tmp->stats.maxhp) 941 if (tmp->stats.hp >= tmp->stats.maxhp)
939 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!"); 942 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");
940 else if (heal > 50) 943 else if (heal > 50)
… …
949 success = 1; 952 success = 1;
950 } 953 }
951 } 954 }
952 955
953 if (spell->attacktype & AT_DISEASE) 956 if (spell->attacktype & AT_DISEASE)
954 if (cure_disease (tmp, op)) 957 if (cure_disease (tmp, op, spell))
955 success = 1; 958 success = 1;
956 959
957 if (spell->attacktype & AT_POISON) 960 if (spell->attacktype & AT_POISON)
958 { 961 {
959 at = archetype::find ("poisoning"); 962 at = archetype::find ("poisoning");
… …
1008 } 1011 }
1009 1012
1010 if (spell->stats.food && tmp->stats.food < 999) 1013 if (spell->stats.food && tmp->stats.food < 999)
1011 { 1014 {
1012 tmp->stats.food += spell->stats.food; 1015 tmp->stats.food += spell->stats.food;
1016
1013 if (tmp->stats.food > 999) 1017 if (tmp->stats.food > 999)
1014 tmp->stats.food = 999; 1018 tmp->stats.food = 999;
1019
1015 success = 1; 1020 success = 1;
1016 /* We could do something a bit better like the messages for healing above */ 1021 /* We could do something a bit better like the messages for healing above */
1017 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food"); 1022 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
1018 } 1023 }
1019 1024
… …
1274} 1279}
1275 1280
1276/* Alchemy code by Mark Wedel 1281/* Alchemy code by Mark Wedel
1277 * 1282 *
1278 * This code adds a new spell, called alchemy. Alchemy will turn 1283 * This code adds a new spell, called alchemy. Alchemy will turn
1279 * objects to gold nuggets, the value of the gold nuggets being 1284 * objects to pyrite ("false gold"), henceforth called gold nuggets.
1280 * about 90% of that of the item itself. It uses the value of the
1281 * object before charisma adjustments, because the nuggets themselves
1282 * will be will be adjusted by charisma when sold.
1283 * 1285 *
1284 * Large nuggets are worth 25 gp each (base). You will always get 1286 * The value of the gold nuggets being about 90% of that of the item
1285 * the maximum number of large nuggets you could get. 1287 * itself. It uses the value of the object before charisma adjustments,
1286 * Small nuggets are worth 1 gp each (base). You will get from 0 1288 * because the nuggets themselves will be will be adjusted by charisma
1287 * to the max amount of small nuggets as you could get. 1289 * when sold.
1288 *
1289 * For example, if an item is worth 110 gold, you will get
1290 * 4 large nuggets, and from 0-10 small nuggets.
1291 * 1290 *
1292 * There is also a chance (1:30) that you will get nothing at all 1291 * There is also a chance (1:30) that you will get nothing at all
1293 * for the object. There is also a maximum weight that will be 1292 * for the object. There is also a maximum weight that will be
1294 * alchemised. 1293 * alchemised.
1295 */ 1294 */
1296static void 1295static void
1297alchemy_object (object *obj, uint64 &total_value, int &total_weight) 1296alchemy_object (object *obj, uint64 &total_value, int &total_weight)
1298{ 1297{
1299 uint64 value = query_cost (obj, NULL, F_TRUE); 1298 uint64 value = query_cost (obj, NULL, F_TRUE);
1300 1299
1301 /* Give third price when we alchemy money (This should hopefully 1300 /* Give third price when we alchemy money (this should hopefully
1302 * make it so that it isn't worth it to alchemy money, sell 1301 * make it so that it isn't worth it to alchemy money, sell
1303 * the nuggets, alchemy the gold from that, etc. 1302 * the nuggets, alchemy the gold from that, etc.
1304 * Otherwise, give 9 silver on the gold for other objects, 1303 * Otherwise, give 9 silver on the gold for other objects,
1305 * so that it would still be more affordable to haul 1304 * so that it would still be more affordable to haul
1306 * the stuff back to town. 1305 * the stuff back to town.
… …
1318 total_weight += obj->total_weight (); 1317 total_weight += obj->total_weight ();
1319 1318
1320 obj->destroy (); 1319 obj->destroy ();
1321} 1320}
1322 1321
1323static void
1324update_map (object *op, maptile *m, int small_nuggets, object *small, int large_nuggets, object *large, int x, int y)
1325{
1326 int flag = 0;
1327
1328 /* Put any nuggets below the player, but we can only pass this
1329 * flag if we are on the same space as the player
1330 */
1331 if (x == op->x && y == op->y && op->map == m)
1332 flag = INS_BELOW_ORIGINATOR;
1333
1334 if (small_nuggets)
1335 {
1336 object *tmp = small->clone ();
1337 tmp->nrof = small_nuggets;
1338 m->insert (tmp, x, y, op, flag);
1339 }
1340
1341 if (large_nuggets)
1342 {
1343 object *tmp = large->clone ();
1344 tmp->nrof = large_nuggets;
1345 m->insert (tmp, x, y, op, flag);
1346 }
1347
1348 if (object *pl = m->at (x, y).player ())
1349 if (pl->contr->ns)
1350 pl->contr->ns->look_position = 0;
1351}
1352
1353int 1322int
1354alchemy (object *op, object *caster, object *spell_ob) 1323alchemy (object *op, object *caster, object *spell_ob)
1355{ 1324{
1356 if (op->type != PLAYER) 1325 if (op->type != PLAYER)
1357 return 0; 1326 return 0;
1358 1327
1359 object *large = get_archetype ("largenugget"); 1328 archetype *nugget[3];
1360 object *small = get_archetype ("smallnugget"); 1329
1330 nugget[0] = archetype::find ("pyrite3");
1331 nugget[1] = archetype::find ("pyrite2");
1332 nugget[2] = archetype::find ("pyrite");
1361 1333
1362 /* Put a maximum weight of items that can be alchemised. Limits the power 1334 /* Put a maximum weight of items that can be alchemised. Limits the power
1363 * some, and also prevents people from alchemising every table/chair/clock 1335 * some, and also prevents people from alchemising every table/chair/clock
1364 * in sight 1336 * in sight
1365 */ 1337 */
… …
1417 if (weight > weight_max) 1389 if (weight > weight_max)
1418 break; 1390 break;
1419 } 1391 }
1420 } 1392 }
1421 1393
1394 value -= rndm (value >> 4);
1422 value = min (value, value_max); 1395 value = min (value, value_max);
1423 1396
1424 uint64 count = value / large->value; 1397 for (int i = 0; i < sizeof (nugget) / sizeof (nugget [0]); ++i)
1425 int large_nuggets = count; 1398 if (int nrof = value / nugget [i]->value)
1426 value -= count * large->value;
1427
1428 count = value / small->value;
1429 int small_nuggets = count;
1430
1431 /* Insert all the nuggets at one time. This probably saves time, but
1432 * it also prevents us from alcheming nuggets that were just created
1433 * with this spell.
1434 */ 1399 {
1435 update_map (op, mp, small_nuggets, small, large_nuggets, large, nx, ny); 1400 value -= nrof * nugget[i]->value;
1401
1402 object *tmp = arch_to_object (nugget[i]);
1403 tmp->nrof = nrof;
1404 tmp->flag [FLAG_IDENTIFIED] = true;
1405 op->map->insert (tmp, x, y, op, 0);
1406 }
1436 1407
1437 if (weight > weight_max) 1408 if (weight > weight_max)
1438 goto bailout; 1409 goto bailout;
1439 } 1410 }
1440 } 1411 }
1441 1412
1442bailout: 1413bailout:
1443 large->destroy ();
1444 small->destroy ();
1445 return 1; 1414 return 1;
1446} 1415}
1447 1416
1448 1417
1449/* This function removes the cursed/damned status on equipped 1418/* This function removes the cursed/damned status on equipped
… …
1490 1459
1491 return success; 1460 return success;
1492} 1461}
1493 1462
1494/* Identifies objects in the players inventory/on the ground */ 1463/* Identifies objects in the players inventory/on the ground */
1495
1496int 1464int
1497cast_identify (object *op, object *caster, object *spell) 1465cast_identify (object *op, object *caster, object *spell)
1498{ 1466{
1467 dynbuf_text buf;
1499 object *tmp; 1468 object *tmp;
1500 int success = 0, num_ident;
1501 1469
1502 num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1470 int num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1503 1471
1504 if (num_ident < 1) 1472 if (num_ident < 1)
1505 num_ident = 1; 1473 num_ident = 1;
1506 1474
1507 for (tmp = op->inv; tmp; tmp = tmp->below) 1475 for (tmp = op->inv; tmp; tmp = tmp->below)
… …
1510 { 1478 {
1511 identify (tmp); 1479 identify (tmp);
1512 1480
1513 if (op->type == PLAYER) 1481 if (op->type == PLAYER)
1514 { 1482 {
1515 new_draw_info_format (NDI_UNIQUE, 0, op, "You identified: %s.", long_desc (tmp, op)); 1483 buf.printf ("You identified: %s.\n\n", long_desc (tmp, op));
1516 1484
1517 if (tmp->msg) 1485 if (tmp->msg)
1518 { 1486 buf << "The item has a story:\n\n" << tmp->msg << "\n\n";
1519 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1520 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1521 }
1522 } 1487 }
1523 1488
1524 num_ident--; 1489 num_ident--;
1525 success = 1;
1526 if (!num_ident) 1490 if (!num_ident)
1527 break; 1491 break;
1528 } 1492 }
1529 } 1493 }
1530 1494
… …
1539 { 1503 {
1540 identify (tmp); 1504 identify (tmp);
1541 1505
1542 if (op->type == PLAYER) 1506 if (op->type == PLAYER)
1543 { 1507 {
1544 new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground you identified: %s.", long_desc (tmp, op)); 1508 buf.printf ("On the ground you identified: %s.\n\n", long_desc (tmp, op));
1545 1509
1546 if (tmp->msg) 1510 if (tmp->msg)
1547 { 1511 buf << "The item has a story:\n\n" << tmp->msg << "\n\n";
1548 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1549 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1550 }
1551 1512
1552 esrv_send_item (op, tmp); 1513 esrv_send_item (op, tmp);
1553 } 1514 }
1554 1515
1555 num_ident--; 1516 num_ident--;
1556 success = 1;
1557 if (!num_ident) 1517 if (!num_ident)
1558 break; 1518 break;
1559 } 1519 }
1560 } 1520 }
1561 1521
1562 if (!success) 1522 if (buf.empty ())
1563 new_draw_info (NDI_UNIQUE, 0, op, "You can't reach anything unidentified."); 1523 {
1524 op->failmsg ("You can't reach anything unidentified.");
1525 return 0;
1526 }
1564 else 1527 else
1528 {
1529 if (op->contr)
1530 op->contr->infobox (MSG_CHANNEL ("identify"), buf);
1531
1565 spell_effect (spell, op->x, op->y, op->map, op); 1532 spell_effect (spell, op->x, op->y, op->map, op);
1566 1533 return 1;
1567 return success; 1534 }
1568} 1535}
1569 1536
1570int 1537int
1571cast_detection (object *op, object *caster, object *spell, object *skill) 1538cast_detection (object *op, object *caster, object *spell, object *skill)
1572{ 1539{
… …
1997 object *weapon, *tmp; 1964 object *weapon, *tmp;
1998 char buf[MAX_BUF]; 1965 char buf[MAX_BUF];
1999 int a, i; 1966 int a, i;
2000 sint16 x, y; 1967 sint16 x, y;
2001 maptile *m; 1968 maptile *m;
2002 materialtype_t *mt;
2003 1969
2004 if (!spell->other_arch) 1970 if (!spell->other_arch)
2005 { 1971 {
2006 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 1972 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
2007 LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name); 1973 LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name);
… …
2119 2085
2120 /* attacktype */ 2086 /* attacktype */
2121 if (!tmp->attacktype) 2087 if (!tmp->attacktype)
2122 tmp->attacktype = AT_PHYSICAL; 2088 tmp->attacktype = AT_PHYSICAL;
2123 2089
2124 mt = NULL;
2125 if (op->materialname != NULL)
2126 mt = name_to_material (op->materialname); 2090 if (materialtype_t *mt = name_to_material (op->materialname))
2127 if (mt != NULL)
2128 { 2091 {
2129 for (i = 0; i < NROFATTACKS; i++) 2092 for (i = 0; i < NROFATTACKS; i++)
2130 tmp->resist[i] = 50 - (mt->save[i] * 5); 2093 tmp->resist[i] = 50 - (mt->save[i] * 5);
2131 a = mt->save[0]; 2094 a = mt->save[0];
2132 } 2095 }
… …
2134 { 2097 {
2135 for (i = 0; i < NROFATTACKS; i++) 2098 for (i = 0; i < NROFATTACKS; i++)
2136 tmp->resist[i] = 5; 2099 tmp->resist[i] = 5;
2137 a = 10; 2100 a = 10;
2138 } 2101 }
2102
2139 /* Set weapon's immunity */ 2103 /* Set weapon's immunity */
2140 tmp->resist[ATNR_CONFUSION] = 100; 2104 tmp->resist[ATNR_CONFUSION] = 100;
2141 tmp->resist[ATNR_POISON] = 100; 2105 tmp->resist[ATNR_POISON] = 100;
2142 tmp->resist[ATNR_SLOW] = 100; 2106 tmp->resist[ATNR_SLOW] = 100;
2143 tmp->resist[ATNR_PARALYZE] = 100; 2107 tmp->resist[ATNR_PARALYZE] = 100;
… …
2149 2113
2150 /* Improve weapon's armour value according to best save vs. physical of its material */ 2114 /* Improve weapon's armour value according to best save vs. physical of its material */
2151 2115
2152 if (a > 14) 2116 if (a > 14)
2153 a = 14; 2117 a = 14;
2118
2154 tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a)); 2119 tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));
2155 2120
2156 /* Determine golem's speed */ 2121 /* Determine golem's speed */
2157 tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell))); 2122 tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell)));
2158 2123
… …
2203 new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here."); 2168 new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here.");
2204 } 2169 }
2205 return success; 2170 return success;
2206} 2171}
2207 2172
2208
2209
2210
2211
2212/* create an aura spell object and put it in the player's inventory. 2173/* create an aura spell object and put it in the player's inventory.
2213 * as usual, op is player, caster is the object casting the spell, 2174 * as usual, op is player, caster is the object casting the spell,
2214 * spell is the spell object itself. 2175 * spell is the spell object itself.
2215 */ 2176 */
2216int 2177int
… …
2227 2188
2228 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell); 2189 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);
2229 2190
2230 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 2191 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2231 2192
2232 new_aura->set_owner (op);
2233 set_spell_skill (op, caster, spell, new_aura); 2193 set_spell_skill (op, caster, spell, new_aura);
2234 new_aura->attacktype = spell->attacktype; 2194 new_aura->attacktype = spell->attacktype;
2235 2195
2236 new_aura->level = caster_level (caster, spell); 2196 new_aura->level = caster_level (caster, spell);
2197
2237 if (refresh) 2198 if (refresh)
2238 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect."); 2199 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
2239 else 2200 else
2240 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force."); 2201 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
2202
2241 insert_ob_in_ob (new_aura, op); 2203 insert_ob_in_ob (new_aura, op);
2204 new_aura->set_owner (op);
2205
2242 return 1; 2206 return 1;
2243} 2207}
2244
2245 2208
2246/* move aura function. An aura is a part of someone's inventory, 2209/* move aura function. An aura is a part of someone's inventory,
2247 * which he carries with him, but which acts on the map immediately 2210 * which he carries with him, but which acts on the map immediately
2248 * around him. 2211 * around him.
2249 * Aura parameters: 2212 * Aura parameters:
2250 * duration: duration counter. 2213 * duration: duration counter.
2251 * attacktype: aura's attacktype 2214 * attacktype: aura's attacktype
2252 * other_arch: archetype to drop where we attack 2215 * other_arch: archetype to drop where we attack
2253 */ 2216 */
2254
2255void 2217void
2256move_aura (object *aura) 2218move_aura (object *aura)
2257{ 2219{
2258 int i, mflags;
2259 object *env;
2260 maptile *m;
2261
2262 /* auras belong in inventories */ 2220 /* auras belong in inventories */
2263 env = aura->env; 2221 object *env = aura->env;
2222 object *owner = aura->owner;
2264 2223
2265 /* no matter what we've gotta remove the aura... 2224 /* no matter what we've gotta remove the aura...
2266 * we'll put it back if its time isn't up. 2225 * we'll put it back if its time isn't up.
2267 */ 2226 */
2268 aura->remove (); 2227 aura->remove ();
… …
2273 aura->destroy (); 2232 aura->destroy ();
2274 return; 2233 return;
2275 } 2234 }
2276 2235
2277 /* auras only exist in inventories */ 2236 /* auras only exist in inventories */
2278 if (env == NULL || env->map == NULL) 2237 if (!env || !env->map)
2279 { 2238 {
2280 aura->destroy (); 2239 aura->destroy ();
2281 return; 2240 return;
2282 } 2241 }
2283 2242
2284 /* we need to jump out of the inventory for a bit 2243 /* we need to jump out of the inventory for a bit
2285 * in order to hit the map conveniently. 2244 * in order to hit the map conveniently.
2286 */ 2245 */
2287 aura->insert_at (env, aura); 2246 aura->insert_at (env, aura);
2288 2247
2289 for (i = 1; i < 9; i++) 2248 for (int i = 1; i < 9; i++)
2290 { 2249 {
2291 sint16 nx, ny; 2250 mapxy pos (env);
2251 pos.move (i);
2292 2252
2293 nx = aura->x + freearr_x[i];
2294 ny = aura->y + freearr_y[i];
2295 mflags = get_map_flags (env->map, &m, nx, ny, &nx, &ny);
2296
2297 /* Consider the movement tyep of the person with the aura as 2253 /* Consider the movement type of the person with the aura as
2298 * movement type of the aura. Eg, if the player is flying, the aura 2254 * movement type of the aura. Eg, if the player is flying, the aura
2299 * is flying also, if player is walking, it is on the ground, etc. 2255 * is flying also, if player is walking, it is on the ground, etc.
2300 */ 2256 */
2301 if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny)))) 2257 if (pos.normalise () && !(OB_TYPE_MOVE_BLOCK (env, pos->move_block)))
2302 { 2258 {
2303 hit_map (aura, i, aura->attacktype, 0); 2259 hit_map (aura, i, aura->attacktype, 0);
2304 2260
2305 if (aura->other_arch) 2261 if (aura->other_arch)
2306 m->insert (arch_to_object (aura->other_arch), nx, ny, aura); 2262 pos.insert (arch_to_object (aura->other_arch), aura);
2307 } 2263 }
2308 } 2264 }
2309 2265
2310 /* put the aura back in the player's inventory */ 2266 /* put the aura back in the player's inventory */
2311 aura->remove (); 2267 env->insert (aura);
2312 insert_ob_in_ob (aura, env); 2268 aura->set_owner (owner);
2313} 2269}
2314 2270
2315/* moves the peacemaker spell. 2271/* moves the peacemaker spell.
2316 * op is the piece object. 2272 * op is the piece object.
2317 */ 2273 */
2318
2319void 2274void
2320move_peacemaker (object *op) 2275move_peacemaker (object *op)
2321{ 2276{
2322 object *tmp; 2277 object *tmp;
2323 2278

Diff Legend

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