546 lines
17 KiB
C
546 lines
17 KiB
C
/*
|
|
* static char *rcsid_rune_c =
|
|
* "$Id: rune.c 11578 2009-02-23 22:02:27Z lalo $";
|
|
*/
|
|
|
|
/*
|
|
CrossFire, A Multiplayer game for X-windows
|
|
|
|
Copyright (C) 2003,2006 Mark Wedel & Crossfire Development Team
|
|
Copyright (C) 1992 Frank Tore Johansen
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
The authors can be reached via e-mail at crossfire-devel@real-time.com
|
|
*/
|
|
|
|
/**
|
|
* @file
|
|
*
|
|
* All rune-related functions.
|
|
*/
|
|
|
|
#include <global.h>
|
|
#ifndef __CEXTRACT__
|
|
#include <sproto.h>
|
|
#endif
|
|
#include <spells.h>
|
|
|
|
|
|
#ifndef sqr
|
|
#define sqr(x) ((x)*(x))
|
|
#endif
|
|
|
|
|
|
/**
|
|
* Player is attempting to write a magical rune.
|
|
* This function does all checks for paths, sp/gr, ...
|
|
*
|
|
* @param op
|
|
* rune writer.
|
|
* @param caster
|
|
* object used for casting this rune.
|
|
* @param spell
|
|
* writing spell.
|
|
* @param dir
|
|
* orientation of rune, direction rune's contained spell will be cast in, if applicable
|
|
* @param runename
|
|
* name of the rune or message displayed by the rune for a rune of marking.
|
|
* @retval 0
|
|
* no rune was written.
|
|
* @retval 1
|
|
* rune written.
|
|
*/
|
|
int write_rune(object *op, object *caster, object *spell, int dir, const char *runename) {
|
|
object *tmp, *rune_spell, *rune;
|
|
char buf[MAX_BUF];
|
|
mapstruct *m;
|
|
sint16 nx, ny;
|
|
|
|
if (!dir) {
|
|
dir = 1;
|
|
}
|
|
|
|
nx = op->x+freearr_x[dir];
|
|
ny = op->y+freearr_y[dir];
|
|
m = op->map;
|
|
|
|
if (get_map_flags(m, &m, nx, ny, &nx, &ny)) {
|
|
draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_SPELL, MSG_TYPE_SPELL_ERROR,
|
|
"Can't make a rune there!", NULL);
|
|
return 0;
|
|
}
|
|
for (tmp = GET_MAP_OB(m, nx, ny); tmp != NULL; tmp = tmp->above)
|
|
if (tmp->type == RUNE)
|
|
break;
|
|
|
|
if (tmp) {
|
|
draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_SPELL, MSG_TYPE_SPELL_ERROR,
|
|
"You can't write a rune there.", NULL);
|
|
return 0;
|
|
}
|
|
|
|
if (spell->other_arch) {
|
|
rune_spell = arch_to_object(spell->other_arch);
|
|
} else {
|
|
/* Player specified spell. The player has to know the spell, so
|
|
* lets just look through the players inventory see if they know it
|
|
* use the item_matched_string for our typical matching method.
|
|
*/
|
|
int bestmatch = 0, ms;
|
|
|
|
if (!runename || *runename == 0) {
|
|
draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_SPELL, MSG_TYPE_SPELL_ERROR,
|
|
"Write a rune of what?", NULL);
|
|
return 0;
|
|
}
|
|
|
|
rune_spell = NULL;
|
|
for (tmp = op->inv; tmp; tmp = tmp->below) {
|
|
if (tmp->type == SPELL) {
|
|
ms = item_matched_string(op, tmp, runename);
|
|
if (ms > bestmatch) {
|
|
bestmatch = ms;
|
|
rune_spell = tmp;
|
|
}
|
|
}
|
|
}
|
|
if (!rune_spell) {
|
|
draw_ext_info_format(NDI_UNIQUE, 0, op,
|
|
MSG_TYPE_SPELL, MSG_TYPE_SPELL_ERROR,
|
|
"You don't know any spell named %s",
|
|
"You don't know any spell named %s",
|
|
runename);
|
|
return 0;
|
|
}
|
|
if (rune_spell->skill != spell->skill) {
|
|
draw_ext_info_format(NDI_UNIQUE, 0, op,
|
|
MSG_TYPE_SPELL, MSG_TYPE_SPELL_ERROR,
|
|
"You can't cast %s with %s",
|
|
"You can't cast %s with %s",
|
|
rune_spell->name, spell->name);
|
|
return 0;
|
|
}
|
|
if (caster->path_denied&spell->path_attuned) {
|
|
draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_SPELL, MSG_TYPE_SPELL_ERROR,
|
|
"%s belongs to a spell path denied to you.",
|
|
"%s belongs to a spell path denied to you.",
|
|
rune_spell->name);
|
|
return 0;
|
|
}
|
|
if (caster_level(caster, rune_spell) < rune_spell->level) {
|
|
draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_SPELL, MSG_TYPE_SPELL_ERROR,
|
|
"%s is beyond your ability to cast!",
|
|
"%s is beyond your ability to cast!",
|
|
rune_spell->name);
|
|
return 0;
|
|
}
|
|
if (SP_level_spellpoint_cost(caster, rune_spell, SPELL_MANA) > op->stats.sp) {
|
|
draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_SPELL, MSG_TYPE_SPELL_ERROR,
|
|
"You don't have enough mana.", NULL);
|
|
return 0;
|
|
}
|
|
if (SP_level_spellpoint_cost(caster, rune_spell, SPELL_GRACE) > op->stats.grace) {
|
|
draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_SPELL, MSG_TYPE_SPELL_ERROR,
|
|
"You don't have enough grace.", NULL);
|
|
return 0;
|
|
}
|
|
op->stats.grace -= SP_level_spellpoint_cost(caster, rune_spell, SPELL_GRACE);
|
|
op->stats.sp -= SP_level_spellpoint_cost(caster, rune_spell, SPELL_MANA);
|
|
}
|
|
/* already proper rune. Note this should only be the case if other_arch was set */
|
|
if (rune_spell->type == RUNE) {
|
|
rune = rune_spell;
|
|
} else {
|
|
rune = create_archetype(GENERIC_RUNE);
|
|
snprintf(buf, sizeof(buf), "You set off a rune of %s\n", rune_spell->name);
|
|
rune->msg = add_string(buf);
|
|
tmp = get_object();
|
|
copy_object(rune_spell, tmp);
|
|
insert_ob_in_ob(tmp, rune);
|
|
if (spell->face != blank_face)
|
|
rune->face = spell->face;
|
|
}
|
|
rune->level = caster_level(caster, spell);
|
|
rune->stats.Cha = rune->level/2; /* the invisibility parameter */
|
|
rune->x = nx;
|
|
rune->y = ny;
|
|
rune->map = m;
|
|
rune->direction = dir; /* where any spell will go upon detonation */
|
|
set_owner(rune, op); /* runes without need no owner */
|
|
set_spell_skill(op, caster, spell, rune);
|
|
insert_ob_in_map(rune, m, op, 0);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* This function handles those runes which detonate but do not cast spells.
|
|
* Typically, poisoned or diseased runes.
|
|
*
|
|
* @param op
|
|
* rune.
|
|
* @param victim
|
|
* victim of the rune.
|
|
*/
|
|
static void rune_attack(object *op, object *victim) {
|
|
if (victim) {
|
|
tag_t tag = victim->count;
|
|
hit_player(victim, op->stats.dam, op, op->attacktype, 1);
|
|
if (was_destroyed(victim, tag))
|
|
return;
|
|
/* if there's a disease in the needle, put it in the player */
|
|
if (HAS_RANDOM_ITEMS(op))
|
|
create_treasure(op->randomitems, op, 0, (victim->map ? victim->map->difficulty : 1), 0);
|
|
if (op->inv && op->inv->type == DISEASE) {
|
|
object *disease = op->inv;
|
|
|
|
infect_object(victim, disease, 1);
|
|
remove_ob(disease);
|
|
free_object(disease);
|
|
}
|
|
} else
|
|
hit_map(op, 0, op->attacktype, 1);
|
|
}
|
|
|
|
/**
|
|
* This function generalizes attacks by runes/traps. This ought to make
|
|
* it possible for runes to attack from the inventory,
|
|
* it'll spring the trap on the victim.
|
|
*
|
|
* @param trap
|
|
* trap that activates.
|
|
* @param victim
|
|
* victim of the trap.
|
|
*/
|
|
void spring_trap(object *trap, object *victim) {
|
|
object *env;
|
|
tag_t trap_tag = trap->count;
|
|
rv_vector rv;
|
|
int i, has_spell;
|
|
|
|
/* Prevent recursion */
|
|
if (trap->stats.hp <= 0)
|
|
return;
|
|
|
|
if (QUERY_FLAG(trap, FLAG_IS_LINKED))
|
|
use_trigger(trap);
|
|
|
|
/* Check if this trap casts a spell */
|
|
has_spell = ((trap->inv && trap->inv->type == SPELL) || (trap->other_arch && trap->other_arch->clone.type == SPELL));
|
|
|
|
env = object_get_env_recursive(trap);
|
|
|
|
/* If the victim is not next to this trap, and the trap doesn't cast
|
|
* a spell, don't set it off.
|
|
*/
|
|
get_rangevector(env, victim, &rv, 0);
|
|
if (rv.distance > 1 && !has_spell)
|
|
return;
|
|
|
|
/* Only living objects can trigger runes that don't cast spells, as
|
|
* doing direct damage to a non-living object doesn't work anyway.
|
|
* Typical example is an arrow attacking a door.
|
|
*/
|
|
if (!QUERY_FLAG(victim, FLAG_ALIVE) && !has_spell)
|
|
return;
|
|
|
|
trap->stats.hp--; /*decrement detcount */
|
|
|
|
if (victim && victim->type == PLAYER && trap->msg != NULL)
|
|
draw_ext_info(NDI_UNIQUE, 0, victim, MSG_TYPE_APPLY, MSG_TYPE_APPLY_TRAP,
|
|
trap->msg, trap->msg);
|
|
|
|
/* Flash an image of the trap on the map so the poor sod
|
|
* knows what hit him.
|
|
*/
|
|
trap_show(trap, env);
|
|
|
|
/* Only if it is a spell do we proceed here */
|
|
if (has_spell) {
|
|
object *spell;
|
|
|
|
/* This is necessary if the trap is inside something else */
|
|
remove_ob(trap);
|
|
trap->x = victim->x;
|
|
trap->y = victim->y;
|
|
insert_ob_in_map(trap, victim->map, trap, 0);
|
|
|
|
if (was_destroyed(trap, trap_tag))
|
|
return;
|
|
|
|
for (i = 0; i < MAX(1, trap->stats.maxhp); i++) {
|
|
if (trap->inv)
|
|
cast_spell(trap, trap, trap->direction, trap->inv, NULL);
|
|
else {
|
|
spell = arch_to_object(trap->other_arch);
|
|
cast_spell(trap, trap, trap->direction, spell, NULL);
|
|
free_object(spell);
|
|
}
|
|
}
|
|
} else {
|
|
rune_attack(trap, victim);
|
|
if (was_destroyed(trap, trap_tag))
|
|
return;
|
|
}
|
|
|
|
if (trap->stats.hp <= 0) {
|
|
trap->type = SIGN; /* make the trap impotent */
|
|
trap->stats.food = 20; /* make it stick around until its spells are gone */
|
|
SET_FLAG(trap, FLAG_IS_USED_UP);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Someone is trying to disarm a rune. The actual attempt is done in trap_disarm().
|
|
*
|
|
* @param op
|
|
* object trying to disarm.
|
|
* @param caster
|
|
* object casting the disarm spell.
|
|
* @param spell
|
|
* actual spell for casting.
|
|
* @param skill
|
|
* skill to disarm runes.
|
|
* @param dir
|
|
* direction to disarm.
|
|
* @retval 0
|
|
* rune wasn't disarmed.
|
|
* @retval 1
|
|
* a rune was disarmed.
|
|
*/
|
|
int dispel_rune(object *op, object *caster, object *spell, object *skill, int dir) {
|
|
object *tmp, *tmp2;
|
|
int searchflag = 1, mflags;
|
|
sint16 x, y;
|
|
mapstruct *m;
|
|
|
|
x = op->x+freearr_x[dir];
|
|
y = op->y+freearr_y[dir];
|
|
m = op->map;
|
|
|
|
mflags = get_map_flags(m, &m, x, y, &x, &y);
|
|
|
|
/* Should we perhaps not allow player to disable traps if a monster/
|
|
* player is standing on top?
|
|
*/
|
|
if (mflags&P_OUT_OF_MAP) {
|
|
draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_SPELL, MSG_TYPE_SPELL_FAILURE,
|
|
"There's nothing there!", NULL);
|
|
return 0;
|
|
}
|
|
|
|
/* This can happen if a player does a 'magic rune of dispel'. Without
|
|
* any skill, chance of success is zero, and we don't know who to tell
|
|
* (as otherwise we would have a skill pointer). Plus, trap_disarm()
|
|
* presumes skill is not null and will crash if it is.
|
|
*/
|
|
if (!skill)
|
|
return 0;
|
|
|
|
for (tmp = GET_MAP_OB(m, x, y); tmp != NULL; tmp = tmp->above) {
|
|
if (tmp->type == RUNE || tmp->type == TRAP)
|
|
break;
|
|
|
|
/* we could put a probability chance here, but since nothing happens
|
|
* if you fail, no point on that. I suppose we could do a level
|
|
* comparison so low level players can't erase high level players runes.
|
|
*/
|
|
if (tmp->type == SIGN && !strcmp(tmp->arch->name, "rune_mark")) {
|
|
remove_ob(tmp);
|
|
free_object(tmp);
|
|
draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_SPELL, MSG_TYPE_SPELL_SUCCESS,
|
|
"You wipe out the rune of marking!", NULL);
|
|
return 1;
|
|
}
|
|
|
|
/* now search tmp's inventory for traps
|
|
* This is for chests, where the rune is in the chests inventory.
|
|
*/
|
|
for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below) {
|
|
if (tmp2->type == RUNE || tmp2->type == TRAP) {
|
|
tmp = tmp2;
|
|
searchflag = 0;
|
|
break;
|
|
}
|
|
}
|
|
if (!searchflag)
|
|
break;
|
|
}
|
|
|
|
/* no rune there. */
|
|
if (tmp == NULL) {
|
|
draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_SPELL, MSG_TYPE_SPELL_FAILURE,
|
|
"There's nothing there!", NULL);
|
|
return 0;
|
|
}
|
|
trap_disarm(op, tmp, 0, skill);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Should op see trap?
|
|
* @param op
|
|
* living that could spot the trap.
|
|
* @param trap
|
|
* trap that is invisible.
|
|
* @retval 0
|
|
* trap wasn't spotted.
|
|
* @retval 1
|
|
* trap was spotted.
|
|
*/
|
|
int trap_see(object *op, object *trap) {
|
|
int chance;
|
|
|
|
chance = random_roll(0, 99, op, PREFER_HIGH);
|
|
|
|
/* decide if we see the rune or not */
|
|
if ((trap->stats.Cha == 1)
|
|
|| (chance > MIN(95, MAX(5, ((int)((float)(op->map->difficulty+trap->level+trap->stats.Cha-op->level)/10.0*50.0)))))) {
|
|
draw_ext_info_format(NDI_UNIQUE, 0, op, MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_SUCCESS,
|
|
"You spot a %s!",
|
|
"You spot a %s!",
|
|
trap->name);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Handles showing a trap/rune detonation.
|
|
* @param trap
|
|
* trap that detonates.
|
|
* @param where
|
|
* object at the location to detonate.
|
|
* @retval 0
|
|
* no animation inserted.
|
|
* @retval 1
|
|
* animation inserted.
|
|
*/
|
|
int trap_show(object *trap, object *where) {
|
|
object *tmp2;
|
|
|
|
if (where == NULL)
|
|
return 0;
|
|
tmp2 = create_archetype("runedet");
|
|
tmp2->face = &new_faces[GET_ANIMATION(trap, 0)];
|
|
tmp2->x = where->x;
|
|
tmp2->y = where->y;
|
|
tmp2->map = where->map;
|
|
insert_ob_in_map(tmp2, where->map, NULL, 0);
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Try to disarm a trap/rune.
|
|
*
|
|
* @param disarmer
|
|
* object disarming the trap/rune.
|
|
* @param trap
|
|
* trap to disarm.
|
|
* @param risk
|
|
* if 0, trap/rune won't spring if disarm failure. Else it will spring.
|
|
* @param skill
|
|
* spell used to disarm.
|
|
* @return
|
|
* experience to award, 0 for failure.
|
|
*/
|
|
int trap_disarm(object *disarmer, object *trap, int risk, object *skill) {
|
|
int trapworth; /* need to compute the experience worth of the trap
|
|
before we kill it */
|
|
|
|
/* this formula awards a more reasonable amount of exp */
|
|
trapworth = MAX(1, trap->level)*disarmer->map->difficulty*
|
|
sqr(MAX(trap->stats.dam, trap->inv ? trap->inv->level : 1))/skill->level;
|
|
|
|
if (!(random_roll(0, (MAX(2, MIN(20, trap->level-skill->level+5-disarmer->stats.Dex/2))-1), disarmer, PREFER_LOW))) {
|
|
draw_ext_info_format(NDI_UNIQUE, 0, disarmer,
|
|
MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_SUCCESS,
|
|
"You successfully disarm the %s!",
|
|
"You successfully disarm the %s!",
|
|
trap->name);
|
|
destroy_object(trap);
|
|
/* If it is your own trap, (or any players trap), don't you don't
|
|
* get exp for it.
|
|
*/
|
|
if (trap->owner && trap->owner->type != PLAYER && risk)
|
|
return trapworth;
|
|
else
|
|
return 1; /* give minimal exp and say success */
|
|
} else {
|
|
draw_ext_info_format(NDI_UNIQUE, 0, disarmer,
|
|
MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_FAILURE,
|
|
"You fail to disarm the %s.",
|
|
"You fail to disarm the %s.",
|
|
trap->name);
|
|
if (!(random_roll(0, (MAX(2, skill->level-trap->level+disarmer->stats.Dex/2-6))-1, disarmer, PREFER_LOW))
|
|
&& risk) {
|
|
draw_ext_info(NDI_UNIQUE, 0, disarmer,
|
|
MSG_TYPE_COMMAND, MSG_TYPE_COMMAND_SUCCESS,
|
|
"In fact, you set it off!", NULL);
|
|
spring_trap(trap, disarmer);
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adjust trap difficulty to the map.
|
|
* The default traps are too strong for wimpy level 1 players, and
|
|
* unthreatening to anyone of high level
|
|
*
|
|
* @param trap
|
|
* trap to adjust.
|
|
* @param difficulty
|
|
* map difficulty.
|
|
*/
|
|
void trap_adjust(object *trap, int difficulty) {
|
|
int i;
|
|
|
|
/* now we set the trap level to match the difficulty of the level
|
|
* the formula below will give a level from 1 to (2*difficulty) with
|
|
* a peak probability at difficulty
|
|
*/
|
|
|
|
trap->level = rndm(0, difficulty-1)+rndm(0, difficulty-1);
|
|
if (trap->level < 1)
|
|
trap->level = 1;
|
|
|
|
/* set the hiddenness of the trap, similar formula to above */
|
|
trap->stats.Cha = rndm(0, 19)+rndm(0, difficulty-1)+rndm(0, difficulty-1);
|
|
|
|
if (!trap->other_arch && !trap->inv) {
|
|
/* set the damage of the trap.
|
|
* we get 0-4 pts of damage per level of difficulty of the map in
|
|
* the trap
|
|
*/
|
|
|
|
trap->stats.dam = 0;
|
|
for (i = 0; i < difficulty; i++)
|
|
trap->stats.dam += rndm(0, 4);
|
|
|
|
/* the poison trap special case */
|
|
if (trap->attacktype&AT_POISON) {
|
|
trap->stats.dam = rndm(0, difficulty-1);
|
|
if (trap->stats.dam < 1)
|
|
trap->stats.dam = 1;
|
|
}
|
|
|
|
/* so we get an appropriate amnt of exp for AT_DEATH traps */
|
|
if (trap->attacktype&AT_DEATH)
|
|
trap->stats.dam = 127;
|
|
}
|
|
|
|
}
|