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.65 by root, Wed Aug 1 00:26:04 2007 UTC vs.
Revision 1.73 by root, Sat Sep 1 08:03:46 2007 UTC

… …
335 * pl is invisible. 335 * pl is invisible.
336 */ 336 */
337int 337int
338makes_invisible_to (object *pl, object *mon) 338makes_invisible_to (object *pl, object *mon)
339{ 339{
340
341 if (!pl->invisible) 340 if (!pl->invisible)
342 return 0; 341 return 0;
342
343 if (pl->type == PLAYER) 343 if (pl->type == PLAYER)
344 { 344 {
345 /* If race isn't set, then invisible unless it is undead */ 345 /* If race isn't set, then invisible unless it is undead */
346 if (!pl->contr->invis_race) 346 if (!pl->contr->invis_race)
347 { 347 {
348 if (QUERY_FLAG (mon, FLAG_UNDEAD)) 348 if (QUERY_FLAG (mon, FLAG_UNDEAD))
349 return 0; 349 return 0;
350
350 return 1; 351 return 1;
351 } 352 }
353
352 /* invis_race is set if we get here */ 354 /* invis_race is set if we get here */
353 if (!strcmp (pl->contr->invis_race, "undead") && is_true_undead (mon)) 355 if (!strcmp (pl->contr->invis_race, "undead") && is_true_undead (mon))
354 return 1; 356 return 1;
357
355 /* No race, can't be invisible to it */ 358 /* No race, can't be invisible to it */
356 if (!mon->race) 359 if (!mon->race)
357 return 0; 360 return 0;
361
358 if (strstr (mon->race, pl->contr->invis_race)) 362 if (strstr (mon->race, pl->contr->invis_race))
359 return 1; 363 return 1;
364
360 /* Nothing matched above, return 0 */ 365 /* Nothing matched above, return 0 */
361 return 0; 366 return 0;
362 } 367 }
363 else 368 else
364 { 369 {
… …
601 606
602 if (is_dragon_pl (op)) 607 if (is_dragon_pl (op))
603 /* now grab the 'dragon_ability'-force from the player's inventory */ 608 /* now grab the 'dragon_ability'-force from the player's inventory */
604 for (tmp = op->inv; tmp; tmp = tmp->below) 609 for (tmp = op->inv; tmp; tmp = tmp->below)
605 { 610 {
606 if (tmp->type == FORCE && !strcmp (tmp->arch->archname, "dragon_ability_force")) 611 if (tmp->type == FORCE && tmp->arch->archname == shstr_dragon_ability_force)
607 { 612 {
608 if (tmp->stats.exp == 0) 613 if (tmp->stats.exp == 0)
609 buf << "Your metabolism isn't focused on anything.\n"; 614 buf << "Your metabolism isn't focused on anything.\n";
610 else 615 else
611 buf << "Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n"; 616 buf << "Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n";
… …
895 900
896 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */ 901 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */
897 return 1; 902 return 1;
898} 903}
899 904
900
901/* cast_heal: Heals something. 905/* cast_heal: Heals something.
902 * op is the caster. 906 * op is the caster.
903 * dir is the direction he is casting it in. 907 * dir is the direction he is casting it in.
904 * spell is the spell object. 908 * spell is the spell object.
905 */ 909 */
… …
931 { 935 {
932 /* See how many points we actually heal. Instead of messages 936 /* See how many points we actually heal. Instead of messages
933 * based on type of spell, we instead do messages based 937 * based on type of spell, we instead do messages based
934 * on amount of damage healed. 938 * on amount of damage healed.
935 */ 939 */
936 if (heal > (tmp->stats.maxhp - tmp->stats.hp)) 940 if (heal > tmp->stats.maxhp - tmp->stats.hp)
937 heal = tmp->stats.maxhp - tmp->stats.hp; 941 heal = tmp->stats.maxhp - tmp->stats.hp;
942
938 tmp->stats.hp += heal; 943 tmp->stats.hp += heal;
939 944
940 if (tmp->stats.hp >= tmp->stats.maxhp) 945 if (tmp->stats.hp >= tmp->stats.maxhp)
941 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!"); 946 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");
942 else if (heal > 50) 947 else if (heal > 50)
… …
951 success = 1; 956 success = 1;
952 } 957 }
953 } 958 }
954 959
955 if (spell->attacktype & AT_DISEASE) 960 if (spell->attacktype & AT_DISEASE)
956 if (cure_disease (tmp, op)) 961 if (cure_disease (tmp, op, spell))
957 success = 1; 962 success = 1;
958 963
959 if (spell->attacktype & AT_POISON) 964 if (spell->attacktype & AT_POISON)
960 { 965 {
961 at = archetype::find ("poisoning"); 966 at = archetype::find ("poisoning");
… …
1010 } 1015 }
1011 1016
1012 if (spell->stats.food && tmp->stats.food < 999) 1017 if (spell->stats.food && tmp->stats.food < 999)
1013 { 1018 {
1014 tmp->stats.food += spell->stats.food; 1019 tmp->stats.food += spell->stats.food;
1020
1015 if (tmp->stats.food > 999) 1021 if (tmp->stats.food > 999)
1016 tmp->stats.food = 999; 1022 tmp->stats.food = 999;
1023
1017 success = 1; 1024 success = 1;
1018 /* We could do something a bit better like the messages for healing above */ 1025 /* We could do something a bit better like the messages for healing above */
1019 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food"); 1026 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
1020 } 1027 }
1021 1028
… …
1276} 1283}
1277 1284
1278/* Alchemy code by Mark Wedel 1285/* Alchemy code by Mark Wedel
1279 * 1286 *
1280 * This code adds a new spell, called alchemy. Alchemy will turn 1287 * This code adds a new spell, called alchemy. Alchemy will turn
1281 * objects to gold nuggets, the value of the gold nuggets being 1288 * objects to pyrite ("false gold"), henceforth called gold nuggets.
1282 * about 90% of that of the item itself. It uses the value of the
1283 * object before charisma adjustments, because the nuggets themselves
1284 * will be will be adjusted by charisma when sold.
1285 * 1289 *
1286 * Large nuggets are worth 25 gp each (base). You will always get 1290 * The value of the gold nuggets being about 90% of that of the item
1287 * the maximum number of large nuggets you could get. 1291 * itself. It uses the value of the object before charisma adjustments,
1288 * Small nuggets are worth 1 gp each (base). You will get from 0 1292 * because the nuggets themselves will be will be adjusted by charisma
1289 * to the max amount of small nuggets as you could get. 1293 * when sold.
1290 *
1291 * For example, if an item is worth 110 gold, you will get
1292 * 4 large nuggets, and from 0-10 small nuggets.
1293 * 1294 *
1294 * There is also a chance (1:30) that you will get nothing at all 1295 * There is also a chance (1:30) that you will get nothing at all
1295 * for the object. There is also a maximum weight that will be 1296 * for the object. There is also a maximum weight that will be
1296 * alchemised. 1297 * alchemised.
1297 */ 1298 */
… …
1320 total_weight += obj->total_weight (); 1321 total_weight += obj->total_weight ();
1321 1322
1322 obj->destroy (); 1323 obj->destroy ();
1323} 1324}
1324 1325
1325static void
1326update_map (object *op, maptile *m, int small_nuggets, object *small, int large_nuggets, object *large, int x, int y)
1327{
1328 int flag = 0;
1329
1330 /* Put any nuggets below the player, but we can only pass this
1331 * flag if we are on the same space as the player
1332 */
1333 if (x == op->x && y == op->y && op->map == m)
1334 flag = INS_BELOW_ORIGINATOR;
1335
1336 if (small_nuggets)
1337 {
1338 object *tmp = small->clone ();
1339 tmp->nrof = small_nuggets;
1340 m->insert (tmp, x, y, op, flag);
1341 }
1342
1343 if (large_nuggets)
1344 {
1345 object *tmp = large->clone ();
1346 tmp->nrof = large_nuggets;
1347 m->insert (tmp, x, y, op, flag);
1348 }
1349
1350 if (object *pl = m->at (x, y).player ())
1351 if (pl->contr->ns)
1352 pl->contr->ns->look_position = 0;
1353}
1354
1355int 1326int
1356alchemy (object *op, object *caster, object *spell_ob) 1327alchemy (object *op, object *caster, object *spell_ob)
1357{ 1328{
1358 if (op->type != PLAYER) 1329 if (op->type != PLAYER)
1359 return 0; 1330 return 0;
1360 1331
1361 object *large = get_archetype ("largenugget"); 1332 archetype *nugget[3];
1362 object *small = get_archetype ("smallnugget"); 1333
1334 nugget[0] = archetype::find ("pyrite3");
1335 nugget[1] = archetype::find ("pyrite2");
1336 nugget[2] = archetype::find ("pyrite");
1363 1337
1364 /* Put a maximum weight of items that can be alchemised. Limits the power 1338 /* Put a maximum weight of items that can be alchemised. Limits the power
1365 * some, and also prevents people from alchemising every table/chair/clock 1339 * some, and also prevents people from alchemising every table/chair/clock
1366 * in sight 1340 * in sight
1367 */ 1341 */
… …
1419 if (weight > weight_max) 1393 if (weight > weight_max)
1420 break; 1394 break;
1421 } 1395 }
1422 } 1396 }
1423 1397
1398 value -= rndm (value >> 4);
1424 value = min (value, value_max); 1399 value = min (value, value_max);
1425 1400
1426 uint64 count = value / large->value; 1401 for (int i = 0; i < sizeof (nugget) / sizeof (nugget [0]); ++i)
1427 int large_nuggets = count; 1402 if (int nrof = value / nugget [i]->value)
1428 value -= count * large->value;
1429
1430 count = value / small->value;
1431 int small_nuggets = count;
1432
1433 /* Insert all the nuggets at one time. This probably saves time, but
1434 * it also prevents us from alcheming nuggets that were just created
1435 * with this spell.
1436 */ 1403 {
1437 update_map (op, mp, small_nuggets, small, large_nuggets, large, nx, ny); 1404 value -= nrof * nugget[i]->value;
1405
1406 object *tmp = arch_to_object (nugget[i]);
1407 tmp->nrof = nrof;
1408 tmp->flag [FLAG_IDENTIFIED] = true;
1409 op->map->insert (tmp, x, y, op, 0);
1410 }
1438 1411
1439 if (weight > weight_max) 1412 if (weight > weight_max)
1440 goto bailout; 1413 goto bailout;
1441 } 1414 }
1442 } 1415 }
1443 1416
1444bailout: 1417bailout:
1445 large->destroy ();
1446 small->destroy ();
1447 return 1; 1418 return 1;
1448} 1419}
1449 1420
1450 1421
1451/* This function removes the cursed/damned status on equipped 1422/* This function removes the cursed/damned status on equipped
… …
1492 1463
1493 return success; 1464 return success;
1494} 1465}
1495 1466
1496/* Identifies objects in the players inventory/on the ground */ 1467/* Identifies objects in the players inventory/on the ground */
1497
1498int 1468int
1499cast_identify (object *op, object *caster, object *spell) 1469cast_identify (object *op, object *caster, object *spell)
1500{ 1470{
1471 dynbuf_text buf;
1501 object *tmp; 1472 object *tmp;
1502 int success = 0, num_ident;
1503 1473
1504 num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1474 int num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1505 1475
1506 if (num_ident < 1) 1476 if (num_ident < 1)
1507 num_ident = 1; 1477 num_ident = 1;
1508 1478
1509 for (tmp = op->inv; tmp; tmp = tmp->below) 1479 for (tmp = op->inv; tmp; tmp = tmp->below)
… …
1512 { 1482 {
1513 identify (tmp); 1483 identify (tmp);
1514 1484
1515 if (op->type == PLAYER) 1485 if (op->type == PLAYER)
1516 { 1486 {
1517 new_draw_info_format (NDI_UNIQUE, 0, op, "You identified: %s.", long_desc (tmp, op)); 1487 buf.printf ("You identified: %s.\n\n", long_desc (tmp, op));
1518 1488
1519 if (tmp->msg) 1489 if (tmp->msg)
1520 { 1490 buf << "The item has a story:\n\n" << tmp->msg << "\n\n";
1521 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1522 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1523 }
1524 } 1491 }
1525 1492
1526 num_ident--; 1493 num_ident--;
1527 success = 1;
1528 if (!num_ident) 1494 if (!num_ident)
1529 break; 1495 break;
1530 } 1496 }
1531 } 1497 }
1532 1498
… …
1541 { 1507 {
1542 identify (tmp); 1508 identify (tmp);
1543 1509
1544 if (op->type == PLAYER) 1510 if (op->type == PLAYER)
1545 { 1511 {
1546 new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground you identified: %s.", long_desc (tmp, op)); 1512 buf.printf ("On the ground you identified: %s.\n\n", long_desc (tmp, op));
1547 1513
1548 if (tmp->msg) 1514 if (tmp->msg)
1549 { 1515 buf << "The item has a story:\n\n" << tmp->msg << "\n\n";
1550 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1551 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1552 }
1553 1516
1554 esrv_send_item (op, tmp); 1517 esrv_send_item (op, tmp);
1555 } 1518 }
1556 1519
1557 num_ident--; 1520 num_ident--;
1558 success = 1;
1559 if (!num_ident) 1521 if (!num_ident)
1560 break; 1522 break;
1561 } 1523 }
1562 } 1524 }
1563 1525
1564 if (!success) 1526 if (buf.empty ())
1565 new_draw_info (NDI_UNIQUE, 0, op, "You can't reach anything unidentified."); 1527 {
1528 op->failmsg ("You can't reach anything unidentified.");
1529 return 0;
1530 }
1566 else 1531 else
1532 {
1533 if (op->contr)
1534 op->contr->infobox (MSG_CHANNEL ("identify"), buf);
1535
1567 spell_effect (spell, op->x, op->y, op->map, op); 1536 spell_effect (spell, op->x, op->y, op->map, op);
1568 1537 return 1;
1569 return success; 1538 }
1570} 1539}
1571 1540
1572int 1541int
1573cast_detection (object *op, object *caster, object *spell, object *skill) 1542cast_detection (object *op, object *caster, object *spell, object *skill)
1574{ 1543{
… …
2203 new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here."); 2172 new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here.");
2204 } 2173 }
2205 return success; 2174 return success;
2206} 2175}
2207 2176
2208
2209
2210
2211
2212/* create an aura spell object and put it in the player's inventory. 2177/* 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, 2178 * as usual, op is player, caster is the object casting the spell,
2214 * spell is the spell object itself. 2179 * spell is the spell object itself.
2215 */ 2180 */
2216int 2181int
… …
2227 2192
2228 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell); 2193 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);
2229 2194
2230 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 2195 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2231 2196
2232 new_aura->set_owner (op);
2233 set_spell_skill (op, caster, spell, new_aura); 2197 set_spell_skill (op, caster, spell, new_aura);
2234 new_aura->attacktype = spell->attacktype; 2198 new_aura->attacktype = spell->attacktype;
2235 2199
2236 new_aura->level = caster_level (caster, spell); 2200 new_aura->level = caster_level (caster, spell);
2201
2237 if (refresh) 2202 if (refresh)
2238 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect."); 2203 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
2239 else 2204 else
2240 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force."); 2205 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
2206
2241 insert_ob_in_ob (new_aura, op); 2207 insert_ob_in_ob (new_aura, op);
2208 new_aura->set_owner (op);
2209
2242 return 1; 2210 return 1;
2243} 2211}
2244
2245 2212
2246/* move aura function. An aura is a part of someone's inventory, 2213/* 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 2214 * which he carries with him, but which acts on the map immediately
2248 * around him. 2215 * around him.
2249 * Aura parameters: 2216 * Aura parameters:
2250 * duration: duration counter. 2217 * duration: duration counter.
2251 * attacktype: aura's attacktype 2218 * attacktype: aura's attacktype
2252 * other_arch: archetype to drop where we attack 2219 * other_arch: archetype to drop where we attack
2253 */ 2220 */
2254
2255void 2221void
2256move_aura (object *aura) 2222move_aura (object *aura)
2257{ 2223{
2258 int i, mflags;
2259 object *env;
2260 maptile *m;
2261
2262 /* auras belong in inventories */ 2224 /* auras belong in inventories */
2263 env = aura->env; 2225 object *env = aura->env;
2226 object *owner = aura->owner;
2264 2227
2265 /* no matter what we've gotta remove the aura... 2228 /* no matter what we've gotta remove the aura...
2266 * we'll put it back if its time isn't up. 2229 * we'll put it back if its time isn't up.
2267 */ 2230 */
2268 aura->remove (); 2231 aura->remove ();
… …
2273 aura->destroy (); 2236 aura->destroy ();
2274 return; 2237 return;
2275 } 2238 }
2276 2239
2277 /* auras only exist in inventories */ 2240 /* auras only exist in inventories */
2278 if (env == NULL || env->map == NULL) 2241 if (!env || !env->map)
2279 { 2242 {
2280 aura->destroy (); 2243 aura->destroy ();
2281 return; 2244 return;
2282 } 2245 }
2283 2246
2284 /* we need to jump out of the inventory for a bit 2247 /* we need to jump out of the inventory for a bit
2285 * in order to hit the map conveniently. 2248 * in order to hit the map conveniently.
2286 */ 2249 */
2287 aura->insert_at (env, aura); 2250 aura->insert_at (env, aura);
2288 2251
2289 for (i = 1; i < 9; i++) 2252 for (int i = 1; i < 9; i++)
2290 { 2253 {
2291 sint16 nx, ny; 2254 mapxy pos (env);
2255 pos.move (i);
2292 2256
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 2257 /* 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 2258 * 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. 2259 * is flying also, if player is walking, it is on the ground, etc.
2300 */ 2260 */
2301 if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny)))) 2261 if (pos.normalise () && !(OB_TYPE_MOVE_BLOCK (env, pos->move_block)))
2302 { 2262 {
2303 hit_map (aura, i, aura->attacktype, 0); 2263 hit_map (aura, i, aura->attacktype, 0);
2304 2264
2305 if (aura->other_arch) 2265 if (aura->other_arch)
2306 m->insert (arch_to_object (aura->other_arch), nx, ny, aura); 2266 pos.insert (arch_to_object (aura->other_arch), aura);
2307 } 2267 }
2308 } 2268 }
2309 2269
2310 /* put the aura back in the player's inventory */ 2270 /* put the aura back in the player's inventory */
2311 aura->remove (); 2271 env->insert (aura);
2312 insert_ob_in_ob (aura, env); 2272 aura->set_owner (owner);
2313} 2273}
2314 2274
2315/* moves the peacemaker spell. 2275/* moves the peacemaker spell.
2316 * op is the piece object. 2276 * op is the piece object.
2317 */ 2277 */
2318
2319void 2278void
2320move_peacemaker (object *op) 2279move_peacemaker (object *op)
2321{ 2280{
2322 object *tmp; 2281 object *tmp;
2323 2282

Diff Legend

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