1339 lines
28 KiB
C
1339 lines
28 KiB
C
#include <assert.h>
|
|
#include <math.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "attack.h"
|
|
#include "defs.h"
|
|
#include "flag.h"
|
|
#include "io.h"
|
|
#include "lf.h"
|
|
#include "map.h"
|
|
#include "move.h"
|
|
#include "nexus.h"
|
|
#include "objects.h"
|
|
#include "text.h"
|
|
|
|
extern lifeform_t *player;
|
|
|
|
|
|
int applyarmourdamage(lifeform_t *lf, object_t *wep, int dam, enum DAMTYPE damtype) {
|
|
object_t *armour;
|
|
int adam;
|
|
int damtaken = 0;
|
|
if ((damtype == DT_ACID) || hasflag(wep->flags, F_ARMOURPIERCE)) {
|
|
// ALL of damage reduction goes towards armour
|
|
adam = dam;
|
|
} else {
|
|
// some of damage reduction goes towards armour
|
|
adam = (dam / 2);
|
|
}
|
|
// pick a random piece of armour
|
|
armour = getrandomarmour(lf);
|
|
if (armour) {
|
|
damtaken = takedamage(armour,adam, damtype);
|
|
}
|
|
return damtaken;
|
|
}
|
|
|
|
void applyarmourdamreduction(lifeform_t *lf, object_t *wep, int reduceamt, int *dam, enum DAMTYPE damtype) {
|
|
int db = B_FALSE;
|
|
|
|
// armour can't stop armour-piercing weapons
|
|
if (hasflag(wep->flags, F_ARMOURPIERCE)) {
|
|
reduceamt = 0;
|
|
}
|
|
|
|
if (db) {
|
|
if (reduceamt > 0) {
|
|
dblog("Armour reduces dam by %d to %d.",reduceamt,dam);
|
|
} else {
|
|
dblog("No armour dam reduction.");
|
|
}
|
|
}
|
|
if (dam && (reduceamt >= 0)) {
|
|
*dam -= reduceamt;
|
|
if (*dam < 0) *dam = 0;
|
|
}
|
|
}
|
|
|
|
|
|
int attackcell(lifeform_t *lf, cell_t *c) {
|
|
// anyone there? if so just attack.
|
|
if (c->lf) {
|
|
attacklf(lf, c->lf);
|
|
} else {
|
|
object_t *o;
|
|
// has an mpassable object?
|
|
o = hasobwithflag(c->obpile, F_IMPASSABLE);
|
|
if (o) {
|
|
attackob(lf, o);
|
|
} else {
|
|
// TODO: attack wall?
|
|
return B_TRUE;
|
|
}
|
|
}
|
|
return B_FALSE;
|
|
}
|
|
|
|
int attacklf(lifeform_t *lf, lifeform_t *victim) {
|
|
int dam[100];
|
|
enum DAMTYPE damtype[100];
|
|
int ndam = 0;
|
|
char buf[BUFLEN];
|
|
char attackername[BUFLEN];
|
|
char victimname[BUFLEN];
|
|
int fatal = B_FALSE;
|
|
flag_t *unarmedflag = NULL;
|
|
object_t *wep;
|
|
obpile_t *op = NULL;
|
|
int attacktime;
|
|
int hit = B_FALSE;
|
|
int critical = 0;
|
|
char wepname[BUFLEN];
|
|
//int acc;
|
|
//int ev;
|
|
int i;
|
|
int willheal = B_FALSE;
|
|
|
|
int aidb = B_FALSE;
|
|
|
|
|
|
if (lfhasflag(lf, F_DEBUG)) {
|
|
aidb = B_TRUE;
|
|
}
|
|
|
|
moveeffects(lf);
|
|
|
|
if (isdead(lf)) {
|
|
return B_TRUE;
|
|
}
|
|
|
|
|
|
|
|
// get names
|
|
getlfname(lf, attackername);
|
|
|
|
if (lf == victim) {
|
|
if (isplayer(lf)) {
|
|
strcpy(victimname, "yourself");
|
|
} else {
|
|
strcpy(victimname, "itself");
|
|
}
|
|
} else {
|
|
getlfname(victim, victimname);
|
|
}
|
|
|
|
|
|
if (aidb) dblog(".oO { trying to attack %s }", victimname);
|
|
|
|
// get weapon
|
|
//wep = getweapon(lf);
|
|
wep = getattackwep(lf, &op, &unarmedflag);
|
|
if (!wep) {
|
|
if (isplayer(lf)) {
|
|
msg("You cannot attack!");
|
|
} else if (cansee(player, lf)) {
|
|
//msg("%s looks like it wants to attack!",attackername);
|
|
}
|
|
if (op) killobpile(op);
|
|
return B_TRUE;
|
|
}
|
|
|
|
|
|
getobname(wep, wepname, 1);
|
|
|
|
if (aidb) dblog(".oO { my weapon is %s %s }", wepname, unarmedflag ? "(unarmed)" : "");
|
|
|
|
// depends on weapon, race attackspeed modifier flag, etc
|
|
attacktime = getattackspeed(lf);
|
|
|
|
taketime(lf, attacktime);
|
|
|
|
// did you hit?
|
|
ndam = 0;
|
|
if (rolltohit(lf, victim, &critical)) {
|
|
int n;
|
|
hit = B_TRUE;
|
|
if (aidb) dblog(".oO { i hit! }");
|
|
|
|
// special case
|
|
if (isplayer(lf) && (victim->race->id == R_GLOWBUG)) {
|
|
if ((wep->type->id == OT_EMPTYFLASK) || (wep->type->id == OT_EMPTYVIAL)) {
|
|
object_t *o;
|
|
// catch the glowbug!
|
|
msg("You catch %s in your %s.", victimname, noprefix(wepname));
|
|
removeob(wep, 1);
|
|
killlf(victim); // don't leave a corpse
|
|
o = addob(lf->pack, "glowing flask");
|
|
if (o) {
|
|
getobname(o, buf, o->amt);
|
|
msgnocap("%c - %s.",o->letter, buf);
|
|
} else {
|
|
// add to the ground
|
|
o = addob(lf->cell->obpile, "glowing flask");
|
|
if (o) {
|
|
getobname(o, buf, o->amt);
|
|
msg("%s drops to the ground.", buf);
|
|
}
|
|
}
|
|
if (op) {
|
|
killobpile(op);
|
|
}
|
|
return B_FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
// determine base damage
|
|
|
|
// determine damage
|
|
//if (unarmed && (unarmedflag->val[0] != NA)) {
|
|
// ie. if critical is 0, do this once.
|
|
// if critical is 1, do this twice.
|
|
// etc.
|
|
dam[ndam] = 0;
|
|
for (n = 0; n < critical+1; n++) {
|
|
if (unarmedflag) {
|
|
// this mosnter's unarmed attack will
|
|
// override normal damage calculation
|
|
dam[ndam] += getdamrollfromflag(unarmedflag);
|
|
} else {
|
|
dam[ndam] += getdamroll(wep, victim);
|
|
}
|
|
}
|
|
if (aidb) dblog("rolled dam[%d] = %d",ndam,dam[ndam]);
|
|
|
|
if (dam[ndam] < 0) {
|
|
willheal = B_TRUE;
|
|
}
|
|
|
|
if (!willheal) {
|
|
// modify for strength
|
|
if (!hasflag(wep->flags, F_NOSTRDAMMOD) && !lfhasflag(lf, F_NOSTRDAMMOD)) {
|
|
dam[ndam] = (int)((float)dam[ndam] * getstrdammod(lf));
|
|
}
|
|
}
|
|
|
|
// damtype?
|
|
damtype[ndam] = getdamtype(wep);
|
|
if (aidb) dblog(".oO { dealing %d %s damage }", dam[ndam], getdamname(damtype[ndam]));
|
|
ndam++;
|
|
|
|
|
|
// blessed vs undead etc?
|
|
if (!willheal) {
|
|
if (isblessed(wep) && lfhasflagval(victim, F_DTVULN, DT_HOLY, NA, NA, NULL)) {
|
|
// a little extra damage
|
|
dam[ndam] = (int) ( (float)dam[ndam] * 1.25 );
|
|
}
|
|
|
|
// determine extra damage
|
|
getextradam(wep, &dam[0], &damtype[0], &ndam);
|
|
}
|
|
} else {
|
|
hit = B_FALSE;
|
|
ndam = 0;
|
|
}
|
|
|
|
|
|
|
|
if (ndam > 0) {
|
|
flag_t *f;
|
|
for (i = 0; i < ndam; i++) {
|
|
int reduceamt;
|
|
|
|
dblog("initial dam[%d] = %d",i,dam[i]);
|
|
|
|
if (lfhasflag(lf, F_HEAVYBLOW)) {
|
|
dam[i] = (int)((float)dam[i] * 1.5);
|
|
dblog("heavy blow makes dam[%d] = %d",i,dam[i]);
|
|
}
|
|
|
|
// modify based on resistances
|
|
adjustdamlf(victim, &dam[i], damtype[i]);
|
|
dblog("adjusted for lf to dam[%d] = %d",i,dam[i]);
|
|
|
|
// modify for defender's armour
|
|
reduceamt = getarmourdamreduction(victim, wep, dam[i], damtype[i]);
|
|
|
|
applyarmourdamreduction(victim, wep, reduceamt, &dam[i], damtype[i]);
|
|
|
|
dblog("reduced by armour to dam[%d] = %d",i,dam[i]);
|
|
|
|
// will this hit be fatal?
|
|
if (dam[i] >= victim->hp) {
|
|
fatal = B_TRUE;
|
|
}
|
|
|
|
// announce it
|
|
if (isplayer(lf)) {
|
|
char extradambuf[BUFLEN];
|
|
char *verb;
|
|
if (dam[i] == 0) {
|
|
strcpy(extradambuf, " but do no damage");
|
|
} else if (lfhasflag(player, F_EXTRAINFO) || lfhasflag(player, F_OMNIPOTENT) ) {
|
|
sprintf(extradambuf, " [%d dmg]",dam[i]);
|
|
} else {
|
|
strcpy(extradambuf, "");
|
|
}
|
|
|
|
if (fatal) {
|
|
verb = getkillverb(victim, damtype[i], dam[i], victim->maxhp);
|
|
} else {
|
|
verb = getattackverb(lf, wep, damtype[i], dam[i], victim->maxhp);
|
|
}
|
|
warn("You %s %s%s%s",
|
|
verb,
|
|
victimname, extradambuf,
|
|
fatal ? "!" : ".");
|
|
|
|
if (fatal && strstr(verb, "behead")) {
|
|
addflag(victim->flags, F_BEHEADED, B_TRUE, NA, NA, NULL);
|
|
}
|
|
|
|
if (fatal && !hasflag(victim->flags, F_NODEATHANNOUNCE)) {
|
|
// don't also say "the xx dies"
|
|
addflag(victim->flags, F_NODEATHANNOUNCE, B_TRUE, NA, NA, NULL);
|
|
}
|
|
} else {
|
|
if (cansee(player, lf) || isplayer(victim)) {
|
|
char withwep[BUFLEN];
|
|
char attackverb[BUFLEN];
|
|
char nodamstr[BUFLEN];
|
|
|
|
// capitalise first letter
|
|
sprintf(buf, "%s",attackername);
|
|
capitalise(buf);
|
|
|
|
if (wep && !unarmedflag && (lf->race->id != R_DANCINGWEAPON) && cansee(player, lf)) {
|
|
sprintf(withwep, " with %s", wepname);
|
|
} else {
|
|
strcpy(withwep, "");
|
|
}
|
|
|
|
strcpy(attackverb, getattackverb(lf, wep, damtype[i],dam[i],victim->maxhp));
|
|
if ((dam[i] == 0) && (damtype[i] != DT_TOUCH)) {
|
|
strcpy(nodamstr, " but does no damage");
|
|
} else {
|
|
strcpy(nodamstr, "");
|
|
}
|
|
warn("%s %s%s %s%s%s.", buf, attackverb,
|
|
attackverb[strlen(attackverb)-1] == 's' ? "es" : "s",
|
|
victimname,withwep, nodamstr);
|
|
} else {
|
|
youhear(lf->cell, "sounds of fighting");
|
|
}
|
|
}
|
|
|
|
|
|
if (willheal) {
|
|
if (cansee(player, victim)) {
|
|
flag_t *f;
|
|
msg("%s is healed!",victimname);
|
|
f = hasflag(wep->flags, F_BALANCE);
|
|
if (f) {
|
|
f->known = B_TRUE;
|
|
}
|
|
gainhp(victim, dam[i]);
|
|
}
|
|
} else {
|
|
char attackername2[BUFLEN];
|
|
real_getlfname(lf, attackername2, B_FALSE);
|
|
// victim loses hp
|
|
// don't adjust damage - we've already done that
|
|
if (wep && !unarmedflag) {
|
|
char wepname[BUFLEN];
|
|
getobname(wep, wepname, 1);
|
|
sprintf(buf, "%s^%s %s",attackername2,
|
|
(lf == victim) ? "using" : "weilding",
|
|
wepname);
|
|
} else {
|
|
strcpy(buf, attackername2);
|
|
}
|
|
|
|
losehp_real(victim, dam[i], damtype[i], lf, buf, B_FALSE);
|
|
|
|
// victim's armour loses hp
|
|
if (reduceamt) {
|
|
applyarmourdamage(victim, wep, reduceamt, damtype[i]);
|
|
}
|
|
}
|
|
} // end foreach damtype
|
|
|
|
// special weapon effects
|
|
if (dam[0]) {
|
|
wepeffects(wep->flags, victim->cell);
|
|
}
|
|
|
|
if (!isdead(victim)) {
|
|
if (unarmedflag) {
|
|
f = lfhasflag(lf, F_FREEZINGTOUCH);
|
|
if (f) {
|
|
// victim turns to ice for a while!
|
|
freezelf(victim, lf, rnd(5,10));
|
|
killflag(f);
|
|
}
|
|
}
|
|
|
|
f = lfhasflag(lf, F_QUICKBITE);
|
|
if (f) {
|
|
if (isbleeding(victim)) {
|
|
int dam;
|
|
char lfname[BUFLEN];
|
|
dam = rolldie(f->val[0], f->val[1]) + f->val[2];
|
|
real_getlfname(lf, lfname, B_FALSE);
|
|
losehp_real(victim, dam, DT_BITE, lf, lfname, B_FALSE);
|
|
if (isplayer(victim) || cansee(player, victim)) {
|
|
msg("%s bites %s!", lfname, victimname);
|
|
}
|
|
}
|
|
}
|
|
|
|
f = lfhasflag(lf, F_PACKATTACK);
|
|
if (f) {
|
|
int dir;
|
|
cell_t *c;
|
|
int nmatched = 0;
|
|
// count adjacent allies of name xx
|
|
for (dir = DC_N; dir <= DC_NW; dir++) {
|
|
c = getcellindir(victim->cell, dir);
|
|
if (c && c->lf) {
|
|
if (strcasestr(c->lf->race->name, f->text)) {
|
|
nmatched++;
|
|
}
|
|
}
|
|
}
|
|
if (nmatched >= f->val[2]) {
|
|
char damstring[BUFLEN];
|
|
sprintf(damstring, "a %s pack", f->text);
|
|
losehp(victim, f->val[0], f->val[1], lf, damstring);
|
|
if (isplayer(victim) || cansee(player, victim)) {
|
|
msg("The %s pack attacks %s!", f->text, victimname);
|
|
}
|
|
}
|
|
}
|
|
|
|
// confer flags from attacker?
|
|
if (dam[0]) {
|
|
wepeffects(lf->flags, victim->cell);
|
|
}
|
|
|
|
// special lifeform-based effects
|
|
if ((lf->race->id == R_COCKATRICE) && dam[0]) {
|
|
// first saving throw...
|
|
if (skillcheck(victim, SC_CON, 25, 0)) {
|
|
// slowed
|
|
addtempflag(victim->flags, F_SLOWMOVE, 15, NA, NA, NULL, 2);
|
|
addtempflag(victim->flags, F_SLOWACT, 15, NA, NA, NULL, 2);
|
|
} else {
|
|
// second saving throw...
|
|
if (skillcheck(victim, SC_CON, 25, 0)) {
|
|
// paralyzed
|
|
addtempflag(victim->flags, F_PARALYZED, B_TRUE, NA, NA, NULL, 5);
|
|
} else {
|
|
if (!lfhasflag(lf, F_BEINGSTONED)) {
|
|
// stoned!
|
|
addflag(victim->flags, F_BEINGSTONED, 2, NA, NA, NULL);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
} else { // miss!
|
|
if (aidb) dblog(".oO { i missed! }");
|
|
// announce it
|
|
if (lfhasflag(victim, F_MAGSHIELD) && ismetal(wep->material->id)) {
|
|
if (isplayer(lf) || cansee(player, lf)) {
|
|
sprintf(buf, "%s",attackername);
|
|
|
|
msg("%s%s magnetic shield repels %s%s attack.", victimname, getpossessive(victimname),
|
|
buf, getpossessive(buf));
|
|
}
|
|
} else {
|
|
if (isplayer(lf)) {
|
|
msg("You miss %s.", victimname);
|
|
} else {
|
|
if (cansee(player, lf)) {
|
|
// capitalise first letter
|
|
sprintf(buf, "%s",attackername);
|
|
|
|
msg("%s misses %s.", buf, victimname);
|
|
}
|
|
}
|
|
|
|
if (lfhasflag(victim, F_DODGES)) {
|
|
flag_t *f;
|
|
cell_t *adj;
|
|
|
|
f = addflag(victim->flags, F_NOTIME, B_TRUE, NA, NA, NULL);
|
|
adj = getrandomadjcell(victim->cell, WE_NOTSOLID);
|
|
moveto(lf, adj, B_FALSE);
|
|
msg("%s dodge%s!",victimname,isplayer(victim) ? "" : "s");
|
|
killflag(f);
|
|
|
|
}
|
|
}
|
|
fightback(victim, lf);
|
|
}
|
|
|
|
// get rid of temp unarmed object pile
|
|
if (op) {
|
|
killobpile(op);
|
|
}
|
|
|
|
|
|
// induction of fear?
|
|
if (!isdead(victim)) {
|
|
if (lfhasflag(victim, F_INDUCEFEAR)) {
|
|
scare(lf, victim, rnd(2,3));
|
|
}
|
|
}
|
|
|
|
if (aidb) dblog(".oO { doattack about to return B_FALSE }");
|
|
return B_FALSE;
|
|
}
|
|
|
|
int attackob(lifeform_t *lf, object_t *o) {
|
|
int dam[100];
|
|
enum DAMTYPE damtype[100];
|
|
int ndam = 0;
|
|
char attackername[BUFLEN];
|
|
char obname[BUFLEN];
|
|
flag_t *f;
|
|
flag_t *unarmedflag = NULL;
|
|
object_t *wep;
|
|
obpile_t *op = NULL;
|
|
cell_t *obloc = NULL;
|
|
int attacktime;
|
|
int unarmed = B_FALSE;
|
|
char wepname[BUFLEN];
|
|
int i;
|
|
//int aidb = B_TRUE;
|
|
int maxhp;
|
|
|
|
moveeffects(lf);
|
|
if (isdead(lf)) return B_TRUE;
|
|
|
|
// get names
|
|
getlfname(lf, attackername);
|
|
getobname(o, obname, o->amt);
|
|
|
|
// get target object details
|
|
obloc = o->pile->where;
|
|
f = hasflag(o->flags, F_OBHP);
|
|
if (f) {
|
|
maxhp = f->val[1];
|
|
} else {
|
|
maxhp = 1;
|
|
}
|
|
|
|
// get weapon
|
|
wep = getattackwep(lf, &op, &unarmedflag);
|
|
if (!wep) {
|
|
if (isplayer(lf)) {
|
|
msg("You cannot attack!");
|
|
} else if (cansee(player, lf)) {
|
|
//msg("%s looks like it wants to attack!",attackername);
|
|
}
|
|
if (!isplayer(lf)) {
|
|
// if ai, take some time to avoid infinite loops!
|
|
taketime(lf, getactspeed(lf));
|
|
}
|
|
if (op) killobpile(op);
|
|
return B_TRUE;
|
|
}
|
|
|
|
getobname(wep, wepname, 1);
|
|
|
|
// depends on weapon, race attackspeed modifier flag, etc
|
|
attacktime = getattackspeed(lf);
|
|
|
|
taketime(lf, attacktime);
|
|
|
|
// don't need to figure out accuracy - we always hit.
|
|
|
|
// determine damage
|
|
ndam = 0;
|
|
//if (unarmedflag && (unarmedflag->val[0] != NA)) {
|
|
if (unarmedflag) {
|
|
// this mosnter's unarmed attack will
|
|
// override normal damage calculation
|
|
dam[ndam] = getdamrollfromflag(unarmedflag);
|
|
} else {
|
|
dam[ndam] = getdamroll(wep, NULL);
|
|
}
|
|
|
|
// damtype?
|
|
damtype[ndam] = getdamtype(wep);
|
|
ndam++;
|
|
|
|
// don't need to check for blessed vs mosnters
|
|
|
|
// determine extra damage
|
|
getextradam(wep, &dam[0], &damtype[0], &ndam);
|
|
|
|
|
|
for (i = 0; i < ndam; i++) {
|
|
// announce the hit
|
|
if (isplayer(lf)) {
|
|
char extradambuf[BUFLEN];
|
|
if (lfhasflag(player, F_EXTRAINFO) || lfhasflag(player, F_OMNIPOTENT) ) {
|
|
sprintf(extradambuf, " [%d dmg]",dam[i]);
|
|
} else {
|
|
strcpy(extradambuf, "");
|
|
}
|
|
msg("You %s %s.", getattackverb(lf, wep, damtype[i], dam[i], maxhp),
|
|
obname, extradambuf);
|
|
} else if (cansee(player, lf)) {
|
|
char withwep[BUFLEN];
|
|
|
|
if (wep && !unarmed && !isblind(player)) { // announce weapon used
|
|
sprintf(withwep, " with %s", wepname);
|
|
} else {
|
|
strcpy(withwep, "");
|
|
}
|
|
|
|
msg("%s %ss %s%s.", attackername,
|
|
getattackverb(lf, wep, damtype[i],dam[i],maxhp), obname,withwep);
|
|
} else {
|
|
youhear(lf->cell, "sounds of fighting");
|
|
}
|
|
|
|
if ((i == 0) && unarmedflag && hasflag(o->flags, F_HARD)) {
|
|
char buf[BUFLEN];
|
|
sprintf(buf, "punching %s", obname);
|
|
if ( losehp(lf, 1, DT_BASH, lf, buf)) {
|
|
if (isplayer(lf)) {
|
|
msg("Ow!");
|
|
}
|
|
}
|
|
}
|
|
|
|
// object loses hp
|
|
takedamage(o, dam[i], damtype[i]);
|
|
|
|
} // end foreach damtype
|
|
|
|
// special weapon effects
|
|
if (dam[0]) {
|
|
wepeffects(wep->flags, obloc);
|
|
}
|
|
|
|
if (unarmedflag) {
|
|
// touch effects
|
|
touch(lf, o);
|
|
} else {
|
|
// weapon gets damaged ?
|
|
if (wep && (ndam > 0)) {
|
|
switch (damtype[0]) {
|
|
case DT_PIERCE:
|
|
case DT_SLASH:
|
|
// weapon gets duller
|
|
if (rnd(1,2)) makeduller(wep, 1);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// get rid of temp unarmed object pile
|
|
if (op) {
|
|
killobpile(op);
|
|
}
|
|
|
|
return B_FALSE;
|
|
}
|
|
|
|
// returns the amount of damage the armour blocked...
|
|
int getarmourdamreduction(lifeform_t *lf, object_t *wep, int dam, enum DAMTYPE damtype) {
|
|
int reduceamt = 0;
|
|
float reducepct;
|
|
int ar;
|
|
|
|
ar = getarmourrating(lf);
|
|
reducepct = getdamreducepct(ar);
|
|
reduceamt = (int) ceil((reducepct / 100.0) * (float)dam);
|
|
|
|
if (reduceamt < 0) reduceamt = 0;
|
|
return reduceamt;
|
|
}
|
|
|
|
|
|
// returns a const char *
|
|
char *getattackverb(lifeform_t *lf, object_t *wep, enum DAMTYPE damtype, int dam, int maxhp) {
|
|
float pct;
|
|
enum LFSIZE ownersize = SZ_HUMAN;
|
|
|
|
if (lf) {
|
|
ownersize = getlfsize(lf);
|
|
}
|
|
|
|
pct = (int)(((float) dam / (float) maxhp) * 100.0);
|
|
|
|
if (wep) {
|
|
flag_t *f;
|
|
f = hasflag(wep->flags, F_ATTACKVERB);
|
|
if (f) {
|
|
return f->text;
|
|
}
|
|
}
|
|
|
|
if (damtype == DT_ACID) {
|
|
return "burn";
|
|
} else if (damtype == DT_BASH) {
|
|
if (pct <= 5) {
|
|
return "whack";
|
|
} else if (pct <= 20) {
|
|
if (rnd(1,2) == 1) {
|
|
return "hit";
|
|
} else {
|
|
return "bash";
|
|
}
|
|
} else {
|
|
return "pummel";
|
|
}
|
|
} else if (damtype == DT_BITE) {
|
|
if (lf && (ownersize <= SZ_SMALL)) {
|
|
if (pct <= 5) {
|
|
return "nip";
|
|
} else if (pct <= 30) {
|
|
return "bite";
|
|
}
|
|
} else {
|
|
if (pct <= 5) {
|
|
return "gnaw";
|
|
} else if (pct <= 30) {
|
|
return "bite";
|
|
} else {
|
|
return "savage";
|
|
}
|
|
}
|
|
} else if (damtype == DT_CLAW) {
|
|
if (pct <= 5) {
|
|
return "scratch";
|
|
} else if (pct <= 15) {
|
|
return "claw";
|
|
} else if (pct <= 30) {
|
|
return "tear";
|
|
} else if (pct <= 40) {
|
|
return "rake";
|
|
} else if (pct <= 50) {
|
|
return "gouge";
|
|
} else {
|
|
return "eviscerate";
|
|
}
|
|
} else if (damtype == DT_CHOP) {
|
|
if (pct <= 5) {
|
|
return "hit";
|
|
} else if (pct <= 15) {
|
|
return "hack";
|
|
} else {
|
|
return "chop";
|
|
}
|
|
} else if (damtype == DT_COLD) {
|
|
if (pct <= 10) {
|
|
return "chill";
|
|
} else {
|
|
return "freeze";
|
|
}
|
|
} else if (damtype == DT_CRUSH) {
|
|
return "crush";
|
|
} else if (damtype == DT_ELECTRIC) {
|
|
if (pct <= 5) {
|
|
return "zap";
|
|
} else if (pct <= 15) {
|
|
return "jolt";
|
|
} else if (pct <= 20) {
|
|
return "shock";
|
|
} else if (pct <= 30) {
|
|
return "electrify";
|
|
} else {
|
|
return "electrocute";
|
|
}
|
|
} else if (damtype == DT_FIRE) {
|
|
if (pct <= 5) {
|
|
return "scorch";
|
|
} else if (pct <= 20) {
|
|
return "burn";
|
|
} else if (pct <= 40) {
|
|
return "scald";
|
|
} else {
|
|
return "incinerate";
|
|
}
|
|
} else if (damtype == DT_HOLY) {
|
|
switch (rnd(1,2)) {
|
|
case 1:
|
|
return "smite";
|
|
case 2:
|
|
return "cleanse";
|
|
}
|
|
} else if (damtype == DT_PIERCE) {
|
|
if (pct <= 5) {
|
|
return "poke";
|
|
} else if (pct <= 15) {
|
|
return "stab";
|
|
} else if (pct <= 30) {
|
|
return "pierce";
|
|
} else if (pct <= 40) {
|
|
return "spear";
|
|
} else {
|
|
return "deeply stab";
|
|
}
|
|
} else if (damtype == DT_POISONGAS) {
|
|
return "poison";
|
|
} else if (damtype == DT_PROJECTILE) {
|
|
return "hit";
|
|
} else if (damtype == DT_SLASH) {
|
|
if (pct <= 5) {
|
|
return "scratch";
|
|
} else if (pct <= 15) {
|
|
return "hit";
|
|
} else if (pct <= 30) {
|
|
return "slash";
|
|
} else {
|
|
return "slice";
|
|
}
|
|
} else if (damtype == DT_TOUCH) {
|
|
return "touch";
|
|
} else if (damtype == DT_UNARMED) {
|
|
if (rnd(1,2) == 1) {
|
|
return "punch";
|
|
} else {
|
|
return "hit";
|
|
}
|
|
}
|
|
return "hit";
|
|
}
|
|
|
|
object_t *getattackwep(lifeform_t *lf, obpile_t **unarmedpile, flag_t **unarmedflag) {
|
|
object_t *wep;
|
|
|
|
wep = getweapon(lf);
|
|
if (!wep) {
|
|
// ie. unarmed
|
|
*unarmedpile = getunarmedweapon(lf, unarmedflag);
|
|
|
|
if ((*unarmedpile)->first) {
|
|
wep = (*unarmedpile)->first;
|
|
} else {
|
|
wep = NULL;
|
|
}
|
|
}
|
|
return wep;
|
|
}
|
|
|
|
enum DAMTYPE getdamtype(object_t *wep) {
|
|
flag_t *f;
|
|
enum DAMTYPE dt = DT_NONE;
|
|
|
|
f = hasflag(wep->flags, F_DAMTYPE);
|
|
if (f) {
|
|
dt = f->val[0];
|
|
} else {
|
|
// default - you are just bashing with whatever
|
|
// you weilded.
|
|
dt = DT_BASH;
|
|
}
|
|
return dt;
|
|
}
|
|
|
|
int getextradam(object_t *wep, int *dam, enum DAMTYPE *damtype, int *ndam) {
|
|
flag_t *f;
|
|
for (f = wep->flags->first ; f ; f = f->next) {
|
|
if (f->id == F_ONFIRE) {
|
|
*(dam + *ndam) = rolldie(2,8);
|
|
*(damtype + *ndam) = DT_FIRE;
|
|
(*ndam)++;
|
|
}
|
|
}
|
|
return *dam;
|
|
}
|
|
|
|
char *getkillverb(lifeform_t *victim, enum DAMTYPE damtype, int dam, int maxhp) {
|
|
float pct;
|
|
pct = (int)(((float) dam / (float) maxhp) * 100.0);
|
|
|
|
if ((damtype == DT_BASH) && lfhasflag(victim, F_FROZEN)) {
|
|
return "shatter";
|
|
}
|
|
|
|
if (damtype == DT_CRUSH) {
|
|
return "crush";
|
|
}
|
|
|
|
if (damtype == DT_HOLY) {
|
|
return "smite";
|
|
}
|
|
|
|
if (pct >= 70) {
|
|
if (damtype == DT_PIERCE) return "impale";
|
|
if (damtype == DT_BASH) return "flatten";
|
|
if (damtype == DT_BITE) return "gore";
|
|
if (damtype == DT_CLAW) return "disembowel";
|
|
if (damtype == DT_SLASH) {
|
|
if (lfhasflagval(victim, F_NOBODYPART, BP_HEAD, NA, NA, NULL)) {
|
|
return "bisect";
|
|
} else {
|
|
if ((getlfsize(victim) >= SZ_MEDIUM) && (rnd(1,3) == 1)) {
|
|
return "behead";
|
|
} else {
|
|
return "bisect";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return "kill";
|
|
}
|
|
|
|
|
|
|
|
|
|
void getdamrange(flagpile_t *fp, int *min, int *max) {
|
|
int mindam,maxdam;
|
|
flag_t *f;
|
|
|
|
f = hasflag(fp, F_DAM);
|
|
if (f) {
|
|
int mod,ndice,sides;
|
|
ndice = f->val[0];
|
|
sides = f->val[1];
|
|
if (f->val[2] == NA) {
|
|
mod = 0;
|
|
} else {
|
|
mod = f->val[2];
|
|
}
|
|
|
|
mindam = (ndice * 1) + mod;
|
|
maxdam = (ndice * sides) + mod;
|
|
} else {
|
|
// TODO wepaon does damage based on weight
|
|
mindam = 0;
|
|
maxdam = 0;
|
|
}
|
|
if (min) *min = mindam;
|
|
if (max) *max = maxdam;
|
|
}
|
|
|
|
void getdamrangeunarmed(flag_t *f, int *min, int *max) {
|
|
obpile_t *op;
|
|
object_t *o;
|
|
op = addobpile(NULL, NULL);
|
|
o = addob(op, f->text);
|
|
if (o) {
|
|
int ndice,nsides,mod;
|
|
flag_t *damflag;
|
|
|
|
damflag = hasflag(o->flags, F_DAM);
|
|
|
|
if (f->val[0] == NA) {
|
|
ndice = damflag->val[0];
|
|
} else {
|
|
ndice = f->val[0];
|
|
}
|
|
if (f->val[1] == NA) {
|
|
nsides = damflag->val[1];
|
|
} else {
|
|
nsides = f->val[1];
|
|
}
|
|
if (f->val[2] == NA) {
|
|
if (damflag->val[2] != NA) {
|
|
mod = damflag->val[2];
|
|
} else {
|
|
mod = 0;
|
|
}
|
|
} else {
|
|
mod = f->val[2];
|
|
}
|
|
|
|
if (min) *min = (ndice * 1) + mod;
|
|
if (max) *max = (ndice * nsides) + mod;
|
|
|
|
killob(o);
|
|
} else {
|
|
if (min) *min = 0;
|
|
if (max) *max = 0;
|
|
}
|
|
free(op);
|
|
}
|
|
|
|
|
|
// roll for damage
|
|
int getdamroll(object_t *o, lifeform_t *victim) {
|
|
int dam;
|
|
flag_t *f;
|
|
f = hasflag(o->flags, F_DAM);
|
|
if (f) {
|
|
dam = getdamrollfromflag(f);
|
|
if (isblessed(o)) {
|
|
int dam2;
|
|
// blessed weapons get two rolls, and take the best
|
|
dam2 = getdamrollfromflag(f);
|
|
if (dam2 > dam) dam = dam2;
|
|
} else if (iscursed(o)) {
|
|
int dam2;
|
|
// cursed weapons get two rolls, and take the worst
|
|
dam2 = getdamrollfromflag(f);
|
|
if (dam2 < dam) dam = dam2;
|
|
}
|
|
|
|
} else {
|
|
// TODO wepaon does bashing damage based on weight
|
|
dam = rnd(1,2);
|
|
}
|
|
|
|
// modify for bonus
|
|
f = hasflag(o->flags, F_BONUS);
|
|
if (f) {
|
|
dam += f->val[0];
|
|
}
|
|
|
|
if (dam < 0) dam = 0;
|
|
|
|
// special effects ?
|
|
f = hasflag(o->flags, F_BALANCE);
|
|
if (f) {
|
|
lifeform_t *owner;
|
|
owner = o->pile->owner;
|
|
if (owner && victim) {
|
|
float ratio;
|
|
ratio = (float)owner->maxhp / (float)victim->maxhp;
|
|
|
|
if (ratio >= 1.25) {
|
|
// heals instead!
|
|
dam = -dam;
|
|
} else if (ratio <= 0.75) {
|
|
// extra dam!
|
|
dam = (int) ((float)dam * ratio);
|
|
}
|
|
}
|
|
}
|
|
|
|
return dam;
|
|
}
|
|
|
|
float getdamreducepct(float armourrating) {
|
|
float reducepct;
|
|
reducepct = (armourrating * 1.5);
|
|
return reducepct;
|
|
}
|
|
|
|
int getdamrollfromflag(flag_t *f) {
|
|
objecttype_t *ot;
|
|
int dam;
|
|
int ndice, sides, mod;
|
|
flag_t *damflag = NULL;
|
|
|
|
ot = findotn(f->text);
|
|
if (ot) {
|
|
damflag = hasflag(ot->flags, F_DAM);
|
|
}
|
|
|
|
// how many dice?
|
|
ndice = f->val[0];
|
|
if (ndice == NA) {
|
|
// get it from weapon definition
|
|
if (damflag && (damflag->val[0] != NA)) {
|
|
ndice = damflag->val[0];
|
|
} else {
|
|
ndice = 1;
|
|
}
|
|
}
|
|
|
|
sides = f->val[1];
|
|
if (sides == NA) {
|
|
// get it from weapon definition
|
|
if (damflag && (damflag->val[1] != NA)) {
|
|
sides = damflag->val[1];
|
|
} else {
|
|
sides = 1;
|
|
}
|
|
}
|
|
|
|
mod = f->val[2];
|
|
if (mod == NA) {
|
|
// get it from weapon definition
|
|
if (damflag && (damflag->val[2] != NA)) {
|
|
mod = damflag->val[2];
|
|
} else {
|
|
mod = 0;
|
|
}
|
|
}
|
|
|
|
dam = rolldie(ndice, sides) + mod;
|
|
|
|
assert(dam < 1000);
|
|
assert(dam >= 0);
|
|
|
|
return dam;
|
|
}
|
|
|
|
|
|
// returns a multiplier
|
|
float getstrdammod(lifeform_t *lf) {
|
|
float mod = 0;
|
|
float base;
|
|
// <9 = penalty
|
|
// 9,10,11,12 = average
|
|
// >12 = bonus
|
|
base = getattr(lf, A_STR);
|
|
if ((base >= 9) && (base <= 12)) {
|
|
mod = 1;
|
|
} else if (base > 12) {
|
|
base -= 12; // ie. 1 - 6
|
|
|
|
// 13 = 1 = 1.1
|
|
// 14 = 2 = 1.2
|
|
// 15 = 3 = 1.3
|
|
// 16 = 4 = 1.4
|
|
// 17 = 5 = 1.6
|
|
// 18 = 6 = 1.5
|
|
|
|
mod = 1 + (base / 10.0);
|
|
} else { // ie. 0 through 8
|
|
// 0 = 0.1
|
|
// 1 = 0.2
|
|
// 2 = 0.3
|
|
// 3 = 0.4
|
|
// 4 = 0.5
|
|
// 5 = 0.6
|
|
// 6 = 0.7
|
|
// 7 = 0.8
|
|
// 8 = 0.9
|
|
|
|
mod = (base * 0.1); // ie. 8 -> 0.8 or 4 -> 0.4
|
|
mod += 0.1; // ie. 8 -> 0.9 or 4 -> 0.5
|
|
}
|
|
return mod;
|
|
}
|
|
|
|
|
|
// determine attack type for lifeform.
|
|
// allocate a pile and add weapon to it.
|
|
// return the pile. remember to free it!
|
|
obpile_t *getunarmedweapon(lifeform_t *lf,flag_t **uflag) {
|
|
int nposs;
|
|
flag_t *f;
|
|
int sel;
|
|
char poss[MAXPILEOBS][BUFLEN];
|
|
obpile_t *op;
|
|
flag_t *possflag[MAXPILEOBS];
|
|
|
|
op = addobpile(NULL, NULL);
|
|
|
|
// pick a random attack type.
|
|
nposs = 0;
|
|
for (f = lf->flags->first ; f ; f = f->next) {
|
|
if (f->id == F_HASATTACK) {
|
|
strcpy(poss[nposs],f->text);
|
|
possflag[nposs] = f;
|
|
nposs++;
|
|
}
|
|
}
|
|
if (nposs > 0) {
|
|
object_t *uob;
|
|
sel = rnd(0,nposs-1);
|
|
uob = addob(op, poss[sel]);
|
|
assert(uob);
|
|
if (uflag) *uflag = possflag[sel];
|
|
}
|
|
|
|
if (!op->first) {
|
|
if (uflag) *uflag = NULL;
|
|
}
|
|
return op;
|
|
}
|
|
|
|
int rolltohit(lifeform_t *lf, lifeform_t *victim, int *critical) {
|
|
int acc,ev;
|
|
object_t *wep;
|
|
obpile_t *op = NULL;
|
|
int gothit;
|
|
enum LFSIZE szlf,szvictim;
|
|
|
|
if (critical) {
|
|
*critical = 0;
|
|
}
|
|
|
|
acc = getlfaccuracy(lf);
|
|
wep = getattackwep(lf, &op, NULL);
|
|
|
|
// modify for defender's evasion
|
|
ev = getevasion(victim);
|
|
acc -= ev;
|
|
|
|
// size difference
|
|
szlf = getlfsize(lf);
|
|
szvictim = getlfsize(victim);
|
|
if (szvictim < szlf) {
|
|
// if defender is smaller...
|
|
// -7% per size difference
|
|
acc -= (7 * (szlf - szvictim));
|
|
} else if (szvictim > szlf) {
|
|
// if defender is bigger...
|
|
// +7% per size difference
|
|
acc += (7 * (szvictim - szlf));
|
|
}
|
|
|
|
// modify if we can't see the victim
|
|
if (!cansee(lf, victim)) {
|
|
acc -= 50;
|
|
}
|
|
|
|
// metal weapon versus magnetic shield?
|
|
if (lfhasflag(victim, F_MAGSHIELD) && ismetal(wep->material->id)) {
|
|
acc -= 45;
|
|
}
|
|
|
|
if (critical) {
|
|
if (rnd(1,20) == 20) *critical = 1;
|
|
}
|
|
|
|
if (acc < 0) acc = 0;
|
|
if (acc > 100) acc = 100;
|
|
|
|
//if (aidb) dblog(".oO { my modified chance to hit is %d %% }", acc);
|
|
if (rnd(1,100) <= acc) {
|
|
gothit = B_TRUE;
|
|
} else {
|
|
if (critical && *critical) {
|
|
// turn a miss into a hit
|
|
gothit = B_TRUE;
|
|
} else {
|
|
gothit = B_FALSE;
|
|
}
|
|
|
|
}
|
|
|
|
if (op) killobpile(op);
|
|
return gothit;
|
|
}
|
|
|
|
void wepeffects(flagpile_t *fp, cell_t *where) {
|
|
flag_t *f;
|
|
lifeform_t *victim;
|
|
lifeform_t *owner;
|
|
object_t *wep;
|
|
|
|
if (!where) return;
|
|
|
|
wep = fp->ob;
|
|
owner = fp->owner;
|
|
victim = where->lf;
|
|
|
|
for (f = fp->first ; f ; f = f->next) {
|
|
if (f->id == F_FLAMESTRIKE) {
|
|
if (!hasob(where->obpile, OT_FIRESMALL)) {
|
|
// ignite!
|
|
addob(where->obpile, "small fire");
|
|
// announce
|
|
if (haslos(player, where)) {
|
|
msg("A column of fire erupts from the ground!");
|
|
f->known = B_KNOWN;
|
|
}
|
|
}
|
|
} else if ((f->id == F_REVENGE) && victim && !isdead(victim)) {
|
|
lifeform_t *owner;
|
|
owner = wep->pile->owner;
|
|
if (owner && victim) {
|
|
float ratio;
|
|
float dampct;
|
|
int maxdam;
|
|
int extradam;
|
|
// figure out hp percentage
|
|
ratio = 1.0 - ((float)owner->hp / (float)owner->maxhp);
|
|
dampct = (ratio * 100); // ie. lower hp% = higher dampct
|
|
|
|
if (dampct >= 50) {
|
|
getdamrange(wep->flags, NULL, &maxdam);
|
|
extradam = (int)(dampct * (float)maxdam);
|
|
if (extradam > 0) {
|
|
char buf[BUFLEN];
|
|
char buf2[BUFLEN];
|
|
char obname[BUFLEN];
|
|
char damstring[BUFLEN];
|
|
char victimname[BUFLEN];
|
|
getlfname(owner, buf);
|
|
real_getlfname(owner, buf2, B_FALSE);
|
|
getlfname(victim, victimname);
|
|
getobname(wep, obname, 1);
|
|
|
|
// announce
|
|
if (isplayer(owner)) {
|
|
msg("Your %s blasts %s!",noprefix(obname),victimname);
|
|
f->known = B_TRUE;
|
|
} else if (cansee(player, owner)) {
|
|
msg("%s%s %s blasts %s!",buf, getpossessive(buf),noprefix(obname),victimname);
|
|
f->known = B_TRUE;
|
|
}
|
|
|
|
sprintf(damstring, "%s%s blast of revenge",buf2, getpossessive(buf2));
|
|
losehp(victim, extradam, DT_DIRECT, owner, damstring);
|
|
}
|
|
} // end if dampct > 50
|
|
}
|
|
} else if ((f->id == F_HEAVYBLOW) && victim && owner) {
|
|
int dir;
|
|
// knock back victim
|
|
dir = getdirtowards(owner->cell, victim->cell, victim, B_FALSE);
|
|
knockback(victim, dir , 2, owner);
|
|
f->known = B_TRUE;
|
|
} else if ((f->id == F_HITCONFER) && victim ) {
|
|
enum FLAG fid;
|
|
int min,max,howlong;
|
|
fid = f->val[0];
|
|
if (!lfhasflag(victim, fid)) {
|
|
int passedcheck = B_FALSE;
|
|
if (!f->val[1] == NA) {
|
|
int scdiff;
|
|
if (f->val[2] == NA) {
|
|
scdiff = 20; // default
|
|
} else {
|
|
scdiff = f->val[2];
|
|
}
|
|
if (skillcheck(victim, f->val[1], scdiff, 0)) {
|
|
passedcheck = B_TRUE;
|
|
}
|
|
}
|
|
|
|
if (!passedcheck) {
|
|
int val0;
|
|
val0 = f->val[1];
|
|
if (f->text) {
|
|
char loctext[BUFLEN];
|
|
char *word, *dummy;
|
|
strcpy(loctext,f->text);
|
|
word = strtok_r(loctext, "-", &dummy);
|
|
if (word) {
|
|
min = atoi(word);
|
|
word = strtok_r(NULL, "-", &dummy);
|
|
if (word) {
|
|
max = atoi(word);
|
|
howlong = rnd(min,max);
|
|
} else {
|
|
howlong = PERMENANT;
|
|
}
|
|
} else {
|
|
howlong = PERMENANT;
|
|
}
|
|
} else {
|
|
howlong = PERMENANT;
|
|
}
|
|
|
|
addtempflag(victim->flags, fid, val0, NA, NA, NULL, howlong);
|
|
} // end if passedcheck
|
|
} // end (if victim doesn't already have the flag)
|
|
|
|
// was this from a poisoned weapon? if so the poison vanishes
|
|
if ((f->val[0] == F_POISONED) && (f->lifetime == FROMOBMOD)) {
|
|
killflag(f);
|
|
}
|
|
} // end if (fid == hitconfer)
|
|
}
|
|
|
|
}
|