server/server/disease.C

/*
 * CrossFire, A Multiplayer game
 * 
 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
 * Copyright (C) 2002 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 to <crossfire@schmorp.de>
 */

/* This file contains all the code implementing diseases,
 * except for odds and ends in attack.c and in 
 * living.c
 */

/*

For DISEASES:
Stat            Property        Definition

attacktype      Attack effects  Attacktype of the disease. usu. AT_GODPOWER.
other_arch      Creation        object created and dropped when symptom moved.
title           Message         When the "disease" "infects" something, it will
                                print "title victim!!!" to the player who owns
                                the "disease".
wc+             Infectiousness  How well the plague spreads person-to-person
magic+          Range           range of infection 
Stats*          Disability      What stats are reduced by the disease (str con...)
maxhp+          Persistence     How long the disease can last OUTSIDE the host. 
value           TimeLeft        Counter for persistence 
dam^            Damage          How much damage it does (%?). 
maxgrace+       Duration        How long before the disease is naturally cured. 
food            DurCount        Counter for Duration 

speed           Speed           How often the disease moves. 
last_sp^        Lethargy        Percentage of max speed--10 = 10% speed. 

maxsp^          Mana deplete    Saps mana. 
ac^             Progressiveness How the diseases increases in severity.
last_eat*^      Deplete food    saps food if negative 
last_heal       GrantImmunity   If nonzero, disease does NOT grant immunity
                                when it runs out                              

exp             experience      experience awarded when plague cured 
hp*^            ReduceRegen     reduces regeneration of disease-bearer 
sp*^            ReduceSpRegen   reduces spellpoint regeneration 

name            Name            Name of the plague 
msg             message         What the plague says when it strikes.
race            those affected  species/race the plague strikes (* = everything) 
level           Plague Level    General description of the plague's deadliness
armour          Attenuation     reduction in wc per generation of disease.
                                This builds in a self-limiting factor.


Explanations:
* means this # should be negative to cause adverse effect.
+ means that this effect is modulated in spells by ldur
^ means that this effect is modulated in spells by ldam

attacktype is the attacktype used by the disease to smite "dam" damage with.

wc/127 is the chance of someone in range catching it.

magic is the range at which infection may occur.  If negative, the range is
NOT level dependent.

Stats are stat modifications.  These should typically be negative.

maxhp is how long the disease will persist if the host dies and "drops" it,
      in "disease moves", i.e., moves of the disease.  If negative, permanent.
      

value is the counter for maxhp, it starts at maxhp and drops...

dam     if positive, it is straight damage.  if negative, a %-age.

maxgrace  how long in "disease moves" the disease lasts in the host, if negative,
          permanent until cured.

food    if negative, disease is permanent.  otherwise, decreases at <speed>,
        disease goes away at food=0, set to "maxgrace" on infection.

speed is the speed of the disease, how fast "disease moves" occur.

last_sp is the lethargy imposed on the player by the disease.  A lethargy
       of "1" reduces the players speed to 1% of its normal value.

maxsp how much mana is sapped per "disease move".  if negative, a %-age is
     taken.

ac  every "disease move" the severity of the symptoms are increased by
    ac/100.  (severity = 1 + (accumlated_progression)/100)

last_eat  increases food usage if negative.


For SYMPTOMS:

Stats            modify stats
hp               modify regen
value            progression counter (multiplier = value/100)
food             modify food use (from last_eat in DISEASE)
maxsp            suck mana ( as noted for DISEASE)
last_sp          Lethargy
msg              What to say
speed            speed of movement, from DISEASE


*/


#include <global.h>
#include <object.h>
#include <living.h>
#include <sproto.h>
#include <spells.h>
#include <sounds.h>
#include <skills.h>

/*  IMPLEMENTATION NOTES  
         
         Diseases may be contageous.  They are objects which exist in a player's
inventory.  They themselves do nothing, except modify Symptoms, or 
spread to other live objects.  Symptoms are what actually damage the player:
these are their own object. */

/* check if victim is susceptible to disease. */
static int
is_susceptible_to_disease (object *victim, object *disease)
{
  if (!QUERY_FLAG (victim, FLAG_ALIVE))
    return 0;

  if (strstr (disease->race, "*") && !QUERY_FLAG (victim, FLAG_UNDEAD))
    return 1;

  if ((disease->race == undead_name) && QUERY_FLAG (victim, FLAG_UNDEAD))
    return 1;

  if ((victim->race && strstr (disease->race, victim->race)) || strstr (disease->race, victim->name))
    return 1;

  return 0;
}

int
move_disease (object *disease)
{
  /*  first task is to determine if the disease is inside or outside of someone.
   * If outside, we decrement 'value' until we're gone. 
   */

  if (disease->env == NULL)
    {                           /* we're outside of someone */
      if (disease->stats.maxhp > 0)
        disease->value--;

      if (disease->value == 0)
        {
          disease->destroy ();
          return 1;
        }
    }
  else
    {
      /* if we're inside a person, have the disease run its course */
      /* negative foods denote "perpetual" diseases. */
      if (disease->stats.food > 0)
        {
          disease->stats.food--;

          if (disease->stats.food == 0)
            {
              remove_symptoms (disease);        /* remove the symptoms of this disease */
              grant_immunity (disease);
              disease->destroy ();
              return 1;
            }
        }
    }

  /*  check to see if we infect others */
  check_infection (disease);

  /* impose or modify the symptoms of the disease */
  if (disease->env && is_susceptible_to_disease (disease->env, disease))
    do_symptoms (disease);

  return 0;
}

/* remove any symptoms of disease
 * Modified by MSW 2003-03-28 do try to find all the symptom the
 * player may have - I think through some odd interactoins with
 * disease level and player level and whatnot, a player could get
 * more than one symtpom to a disease.
 */

int
remove_symptoms (object *disease)
{
  object *symptom, *victim = NULL;

  while ((symptom = find_symptom (disease)) != NULL)
    {
      if (!victim)
        victim = symptom->env;

      symptom->destroy ();
    }

  if (victim)
    victim->update_stats ();
  return 0;
}

/* argument is a disease */
object *
find_symptom (object *disease)
{
  object *walk;

  /* check the inventory for symptoms */
  for (walk = disease->env->inv; walk; walk = walk->below)
    if (walk->name == disease->name && walk->type == SYMPTOM)
      return walk;
  return NULL;
}

/*  searches around for more victims to infect */
int
check_infection (object *disease)
{
  int x, y, range, mflags;
  maptile *map, *map2;
  object *tmp;

  range = abs (disease->magic);

  if (disease->env)
    {
      x   = disease->env->x;
      y   = disease->env->y;
      map = disease->env->map;
    }
  else
    {
      x   = disease->x;
      y   = disease->y;
      map = disease->map;
    }

  if (!map)
    return 0;

  for (int i = x - range; i <= x + range; i++)
    for (int j = y - range; j <= y + range; j++)
      {
        sint16 i2, j2;
        mflags = get_map_flags (map, &map2, i, j, &i2, &j2);

        if (!(mflags & P_OUT_OF_MAP) && (mflags & P_IS_ALIVE))
          for (tmp = GET_MAP_OB (map2, i2, j2); tmp; tmp = tmp->above)
            infect_object (tmp, disease, 0);
      }

  return 1;
}


/*  check to see if an object is infectable:
 *       objects with immunity aren't infectable.
 *       objects already infected aren't infectable.
 *       dead objects aren't infectable.
 *       undead objects are infectible only if specifically named.
*/
int
infect_object (object *victim, object *disease, int force)
{
  object *tmp;
  object *new_disease;

  /* don't infect inanimate objects */
  if (!QUERY_FLAG (victim, FLAG_MONSTER) && !(victim->type == PLAYER))
    return 0;

  /* check and see if victim can catch disease:  diseases
   *  are specific 
   */
  if (!is_susceptible_to_disease (victim, disease))
    return 0;

  /* roll the dice on infection before doing the inventory check!  */
  if (!force && (random_roll (0, 126, victim, PREFER_HIGH) >= disease->stats.wc))
    return 0;

  /* do an immunity check */
  if (victim->head)
    tmp = victim->head->inv;
  else
    tmp = victim->inv;

  /* There used to (IMO) be a flaw in the below - it used to be the case
   * that if level check was done for both immunity and disease. This could
   * result in a person with multiple afflictions of the same disease
   * (eg, level 1 cold, level 2 cold, level 3 cold, etc), as long as
   * they were cast in that same order.  Instead, change it so that
   * if you diseased, you can't get diseased more.
   */

  for ( /* tmp initialised in if, above */ ; tmp; tmp = tmp->below)
    {
      if (tmp->type == SIGN && tmp->name == disease->name && tmp->level >= disease->level)
        return 0;               /* Immune! */
      else if (tmp->type == DISEASE && tmp->name == disease->name)
        return 0;               /* already diseased */
    }

  /*  If we've gotten this far, go ahead and infect the victim.  */
  new_disease = disease->clone ();
  new_disease->stats.food = disease->stats.maxgrace;
  new_disease->value = disease->stats.maxhp;
  new_disease->stats.wc -= disease->last_grace; /* self-limiting factor */

  /* Unfortunately, set_owner does the wrong thing to the skills pointers
   *  resulting in exp going into the owners *current* chosen skill. 
   */

  if (disease->owner)
    {
      new_disease->set_owner (disease->owner);

      /* Only need to update skill if different */
      if (new_disease->skill != disease->skill)
        new_disease->skill = disease->skill;
    }
  else
    {                           /* for diseases which are passed by hitting, set owner and praying skill */
      if (disease->env && disease->env->type == PLAYER)
        {
          object *player = disease->env;

          new_disease->set_owner (player);

          /* the skill pointer for these diseases should already be set up -
           * hardcoding in 'praying' is not the right approach.
           */
        }
    }

  insert_ob_in_ob (new_disease, victim->head_ ());
  /* This appears to be a horrible case of overloading 'NO_PASS'
   * for meaning in the diseases.
   */
  new_disease->move_block = 0;
  if (new_disease->owner && new_disease->owner->type == PLAYER)
    {
      char buf[128];

      /* if the disease has a title, it has a special infection message
       * This messages is printed in the form MESSAGE victim 
       */
      if (new_disease->title)
        sprintf (buf, "%s %s!!", &disease->title, &victim->name);
      else
        sprintf (buf, "You infect %s with your disease, %s!", &victim->name, &new_disease->name);

      if (victim->type == PLAYER)
        new_draw_info (NDI_UNIQUE | NDI_RED, 0, new_disease->owner, buf);
      else
        new_draw_info (0, 4, new_disease->owner, buf);
    }
  if (victim->type == PLAYER)
    new_draw_info (NDI_UNIQUE | NDI_RED, 0, victim, "You suddenly feel ill.");

  return 1;

}


/*  this function monitors the symptoms caused by the disease (if any),
causes symptoms, and modifies existing symptoms in the case of
existing diseases.  */

int
do_symptoms (object *disease)
{
  object *symptom;
  object *victim;
  object *tmp;

  victim = disease->env;

  /* This is a quick hack - for whatever reason, disease->env will point
   * back to disease, causing endless loops.  Why this happens really needs
   * to be found, but this should at least prevent the infinite loops.
   */

  if (victim == NULL || victim == disease)
    return 0;                   /* no-one to inflict symptoms on */

  symptom = find_symptom (disease);
  if (symptom == NULL)
    {
      /* no symptom?  need to generate one! */
      object *new_symptom;

      /* first check and see if the carrier of the disease is immune.  If so, no symptoms!  */
      if (!is_susceptible_to_disease (victim, disease))
        return 0;

      /* check for an actual immunity */
      /* do an immunity check */
      if (victim->head)
        tmp = victim->head->inv;
      else
        tmp = victim->inv;

      for ( /* tmp initialised in if, above */ ; tmp; tmp = tmp->below)
        {
          if (tmp->type == SIGN)        /* possibly an immunity, or diseased */
            if (tmp->name == disease->name && tmp->level >= disease->level)
              return 0;         /*Immune! */
        }

      new_symptom = get_archetype (ARCH_SYMPTOM);

      /* Something special done with dam.  We want diseases to be more
       * random in what they'll kill, so we'll make the damage they
       * do random, note, this has a weird effect with progressive diseases.
       */
      if (disease->stats.dam != 0)
        {
          int dam = disease->stats.dam;

          /* reduce the damage, on average, 50%, and making things random. */

          dam = random_roll (1, abs (dam), victim, PREFER_LOW);
          if (disease->stats.dam < 0)
            dam = -dam;
          new_symptom->stats.dam = dam;
        }


      new_symptom->stats.maxsp = disease->stats.maxsp;
      new_symptom->stats.food = new_symptom->stats.maxgrace;

      new_symptom->name = new_symptom->name_pl = disease->name;

      new_symptom->level = disease->level;
      new_symptom->speed = disease->speed;
      new_symptom->value = 0;

      for (int i = 0; i < NUM_STATS; ++i)
        new_symptom->stats.stat (i) = disease->stats.stat (i);

      new_symptom->stats.sp = disease->stats.sp;
      new_symptom->stats.food = disease->last_eat;
      new_symptom->stats.maxsp = disease->stats.maxsp;
      new_symptom->last_sp = disease->last_sp;
      new_symptom->stats.exp = 0;
      new_symptom->stats.hp = disease->stats.hp;
      new_symptom->msg = disease->msg;
      new_symptom->attacktype = disease->attacktype;
      new_symptom->other_arch = disease->other_arch;

      new_symptom->set_owner (disease->owner);

      if (new_symptom->skill != disease->skill)
        new_symptom->skill = disease->skill;

      new_symptom->move_block = 0;
      insert_ob_in_ob (new_symptom, victim);
      return 1;
    }

  /* now deal with progressing diseases: we increase the debility
   * caused by the symptoms.
   */
  if (disease->stats.ac != 0)
    {
      symptom->value += disease->stats.ac;

      float scale = 1.f + symptom->value / 100.f;

      /* now rescale all the debilities */
      for (int i = 0; i < NUM_STATS; ++i)
        symptom->stats.stat (i) = scale * disease->stats.stat (i);

      symptom->stats.dam   = scale * disease->stats.dam;
      symptom->stats.sp    = scale * disease->stats.sp;
      symptom->stats.food  = scale * disease->last_eat;
      symptom->stats.maxsp = scale * disease->stats.maxsp;
      symptom->last_sp     = scale * disease->last_sp;
      symptom->stats.exp   = 0;
      symptom->stats.hp    = scale * disease->stats.hp;

      symptom->msg        = disease->msg;
      symptom->attacktype = disease->attacktype;
      symptom->other_arch = disease->other_arch;
    }

  SET_FLAG (symptom, FLAG_APPLIED);
  victim->update_stats ();

  return 1;
}

/*  grants immunity to plagues we've seen before.  */
int
grant_immunity (object *disease)
{
  object *immunity;
  object *walk;

  /* Don't give immunity to this disease if last_heal is set. */
  if (disease->last_heal)
    return 0;
  /*  first, search for an immunity of the same name */
  for (walk = disease->env->inv; walk; walk = walk->below)
    {
      if (walk->type == 98 && disease->name == walk->name)
        {
          walk->level = disease->level;
          return 1;             /* just update the existing immunity. */
        }
    }
  immunity = get_archetype ("immunity");
  immunity->name = disease->name;
  immunity->level = disease->level;
  immunity->move_block = 0;
  insert_ob_in_ob (immunity, disease->env);
  return 1;

}


/*  make the symptom do the nasty things it does  */

int
move_symptom (object *symptom)
{
  object *victim = symptom->env;
  object *new_ob;
  int sp_reduce;

  if (victim == NULL || victim->map == NULL)
    {                           /* outside a monster/player, die immediately */
      symptom->destroy ();
      return 0;
    }

  if (symptom->stats.dam > 0)
    hit_player (victim, symptom->stats.dam, symptom, symptom->attacktype, 1);
  else
    hit_player (victim, (int) MAX (1, -victim->stats.maxhp * symptom->stats.dam / 100.0), symptom, symptom->attacktype, 1);

  if (symptom->stats.maxsp > 0)
    sp_reduce = symptom->stats.maxsp;
  else
    sp_reduce = (int) MAX (1, victim->stats.maxsp * symptom->stats.maxsp / 100.0);
  victim->stats.sp = MAX (0, victim->stats.sp - sp_reduce);

  /* create the symptom "other arch" object and drop it here 
   * under every part of the monster
   * The victim may well have died. 
   */

  if (victim->map == NULL)
    return 0;
  if (symptom->other_arch)
    {
      object *tmp;

      tmp = victim;
      if (tmp->head != NULL)
        tmp = tmp->head;
      for ( /*tmp initialised above */ ; tmp != NULL; tmp = tmp->more)
        {
          new_ob = arch_to_object (symptom->other_arch);
          new_ob->x = tmp->x;
          new_ob->y = tmp->y;
          new_ob->map = victim->map;
          insert_ob_in_map (new_ob, victim->map, victim, 0);
        }
    }
  new_draw_info (NDI_UNIQUE | NDI_RED, 0, victim, symptom->msg);

  return 1;
}

/* possibly infect due to direct physical contact
 * i.e., AT_PHYSICAL-- called from "hit_player_attacktype" */
int
check_physically_infect (object *victim, object *hitter)
{
  /* search for diseases, give every disease a chance to infect */
  for (object *disease = hitter->inv; disease; disease = disease->below)
    if (disease->type == DISEASE)
      infect_object (victim, disease, 0);

  return 1;
}

// find a disease in someone
object *
find_disease (object *victim)
{
  for (object *disease = victim->inv; disease; disease = disease->below)
    if (disease->type == DISEASE)
      return disease;

  return 0;
}

/* do the cure disease stuff, from the spell "cure disease" */
int
cure_disease (object *sufferer, object *caster)
{
  object *disease, *next;
  int casting_level;
  int cure = 0;

  if (caster)
    casting_level = caster->level;
  else
    casting_level = 1000;       /* if null caster, CURE all.  */

  for (disease = sufferer->inv; disease; disease = next)
    {
      next = disease->below;

      if (disease->type == DISEASE)
        {                       /* attempt to cure this disease */
          /* If caster level is higher than disease level, cure chance
           * is automatic.  If lower, then the chance is basically
           * 1 in level_diff - if there is a 5 level difference, chance
           * is 1 in 5.
           */
          if ((casting_level >= disease->level) || (!(random_roll (0, (disease->level - casting_level - 1), caster, PREFER_LOW))))
            {
              remove_symptoms (disease);
              cure = 1;

              if (caster)
                change_exp (caster, disease->stats.exp, caster->chosen_skill ? caster->chosen_skill->skill : (const char *) 0, 0);

              disease->destroy ();
            }
        }
    }

  if (cure)
    {
      /* Only draw these messages once */
      if (caster)
        new_draw_info_format (NDI_UNIQUE, 0, caster, "You cure a disease!");

      new_draw_info (NDI_UNIQUE, 0, sufferer, "You no longer feel diseased.");
    }

  return 1;
}

/* reduces disease progression:  reduce_symptoms 
 * return true if we actually reduce a disease.
 */

int
reduce_symptoms (object *sufferer, int reduction)
{
  object *walk;
  int success = 0;

  for (walk = sufferer->inv; walk; walk = walk->below)
    {
      if (walk->type == SYMPTOM)
        {
          if (walk->value > 0)
            {
              success = 1;
              walk->value = MAX (0, walk->value - 2 * reduction);
              /* give the disease time to modify this symptom,
               * and reduce its severity.  */
              walk->speed_left = 0;
            }
        }
    }
  if (success)
    new_draw_info (NDI_UNIQUE, 0, sufferer, "Your illness seems less severe.");
  return success;
}
Revision:	1.24
Committed:	Tue May 22 21:35:26 2007 UTC (17 years ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-2_1
Changes since 1.23:	+1 -1 lines
Log Message:	* empty log message *
#	Content
1	/*
2	* CrossFire, A Multiplayer game
3	*
4	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
5	* Copyright (C) 2002 Mark Wedel & Crossfire Development Team
6	* Copyright (C) 1992 Frank Tore Johansen
7	*
8	* This program is free software; you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License as published by
10	* the Free Software Foundation; either version 2 of the License, or
11	* (at your option) any later version.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21	*
22	* The authors can be reached via e-mail to <crossfire@schmorp.de>
23	*/
24
25	/* This file contains all the code implementing diseases,
26	* except for odds and ends in attack.c and in
27	* living.c
28	*/
29
30	/*
31
32	For DISEASES:
33	Stat Property Definition
34
35	attacktype Attack effects Attacktype of the disease. usu. AT_GODPOWER.
36	other_arch Creation object created and dropped when symptom moved.
37	title Message When the "disease" "infects" something, it will
38	print "title victim!!!" to the player who owns
39	the "disease".
40	wc+ Infectiousness How well the plague spreads person-to-person
41	magic+ Range range of infection
42	Stats* Disability What stats are reduced by the disease (str con...)
43	maxhp+ Persistence How long the disease can last OUTSIDE the host.
44	value TimeLeft Counter for persistence
45	dam^ Damage How much damage it does (%?).
46	maxgrace+ Duration How long before the disease is naturally cured.
47	food DurCount Counter for Duration
48
49	speed Speed How often the disease moves.
50	last_sp^ Lethargy Percentage of max speed--10 = 10% speed.
51
52	maxsp^ Mana deplete Saps mana.
53	ac^ Progressiveness How the diseases increases in severity.
54	last_eat*^ Deplete food saps food if negative
55	last_heal GrantImmunity If nonzero, disease does NOT grant immunity
56	when it runs out
57
58	exp experience experience awarded when plague cured
59	hp*^ ReduceRegen reduces regeneration of disease-bearer
60	sp*^ ReduceSpRegen reduces spellpoint regeneration
61
62	name Name Name of the plague
63	msg message What the plague says when it strikes.
64	race those affected species/race the plague strikes (* = everything)
65	level Plague Level General description of the plague's deadliness
66	armour Attenuation reduction in wc per generation of disease.
67	This builds in a self-limiting factor.
68
69
70	Explanations:
71	* means this # should be negative to cause adverse effect.
72	+ means that this effect is modulated in spells by ldur
73	^ means that this effect is modulated in spells by ldam
74
75	attacktype is the attacktype used by the disease to smite "dam" damage with.
76
77	wc/127 is the chance of someone in range catching it.
78
79	magic is the range at which infection may occur. If negative, the range is
80	NOT level dependent.
81
82	Stats are stat modifications. These should typically be negative.
83
84	maxhp is how long the disease will persist if the host dies and "drops" it,
85	in "disease moves", i.e., moves of the disease. If negative, permanent.
86
87
88	value is the counter for maxhp, it starts at maxhp and drops...
89
90	dam if positive, it is straight damage. if negative, a %-age.
91
92	maxgrace how long in "disease moves" the disease lasts in the host, if negative,
93	permanent until cured.
94
95	food if negative, disease is permanent. otherwise, decreases at <speed>,
96	disease goes away at food=0, set to "maxgrace" on infection.
97
98	speed is the speed of the disease, how fast "disease moves" occur.
99
100	last_sp is the lethargy imposed on the player by the disease. A lethargy
101	of "1" reduces the players speed to 1% of its normal value.
102
103	maxsp how much mana is sapped per "disease move". if negative, a %-age is
104	taken.
105
106	ac every "disease move" the severity of the symptoms are increased by
107	ac/100. (severity = 1 + (accumlated_progression)/100)
108
109	last_eat increases food usage if negative.
110
111
112
113	For SYMPTOMS:
114
115	Stats modify stats
116	hp modify regen
117	value progression counter (multiplier = value/100)
118	food modify food use (from last_eat in DISEASE)
119	maxsp suck mana ( as noted for DISEASE)
120	last_sp Lethargy
121	msg What to say
122	speed speed of movement, from DISEASE
123
124
125	*/
126
127
128	#include <global.h>
129	#include <object.h>
130	#include <living.h>
131	#include <sproto.h>
132	#include <spells.h>
133	#include <sounds.h>
134	#include <skills.h>
135
136	/* IMPLEMENTATION NOTES
137
138	Diseases may be contageous. They are objects which exist in a player's
139	inventory. They themselves do nothing, except modify Symptoms, or
140	spread to other live objects. Symptoms are what actually damage the player:
141	these are their own object. */
142
143	/* check if victim is susceptible to disease. */
144	static int
145	is_susceptible_to_disease (object victim, object disease)
146	{
147	if (!QUERY_FLAG (victim, FLAG_ALIVE))
148	return 0;
149
150	if (strstr (disease->race, "*") && !QUERY_FLAG (victim, FLAG_UNDEAD))
151	return 1;
152
153	if ((disease->race == undead_name) && QUERY_FLAG (victim, FLAG_UNDEAD))
154	return 1;
155
156	if ((victim->race && strstr (disease->race, victim->race)) \|\| strstr (disease->race, victim->name))
157	return 1;
158
159	return 0;
160	}
161
162	int
163	move_disease (object *disease)
164	{
165	/* first task is to determine if the disease is inside or outside of someone.
166	* If outside, we decrement 'value' until we're gone.
167	*/
168
169	if (disease->env == NULL)
170	{ /* we're outside of someone */
171	if (disease->stats.maxhp > 0)
172	disease->value--;
173
174	if (disease->value == 0)
175	{
176	disease->destroy ();
177	return 1;
178	}
179	}
180	else
181	{
182	/* if we're inside a person, have the disease run its course */
183	/* negative foods denote "perpetual" diseases. */
184	if (disease->stats.food > 0)
185	{
186	disease->stats.food--;
187
188	if (disease->stats.food == 0)
189	{
190	remove_symptoms (disease); /* remove the symptoms of this disease */
191	grant_immunity (disease);
192	disease->destroy ();
193	return 1;
194	}
195	}
196	}
197
198	/* check to see if we infect others */
199	check_infection (disease);
200
201	/* impose or modify the symptoms of the disease */
202	if (disease->env && is_susceptible_to_disease (disease->env, disease))
203	do_symptoms (disease);
204
205	return 0;
206	}
207
208	/* remove any symptoms of disease
209	* Modified by MSW 2003-03-28 do try to find all the symptom the
210	* player may have - I think through some odd interactoins with
211	* disease level and player level and whatnot, a player could get
212	* more than one symtpom to a disease.
213	*/
214
215	int
216	remove_symptoms (object *disease)
217	{
218	object symptom, victim = NULL;
219
220	while ((symptom = find_symptom (disease)) != NULL)
221	{
222	if (!victim)
223	victim = symptom->env;
224
225	symptom->destroy ();
226	}
227
228	if (victim)
229	victim->update_stats ();
230	return 0;
231	}
232
233	/* argument is a disease */
234	object *
235	find_symptom (object *disease)
236	{
237	object *walk;
238
239	/* check the inventory for symptoms */
240	for (walk = disease->env->inv; walk; walk = walk->below)
241	if (walk->name == disease->name && walk->type == SYMPTOM)
242	return walk;
243	return NULL;
244	}
245
246	/* searches around for more victims to infect */
247	int
248	check_infection (object *disease)
249	{
250	int x, y, range, mflags;
251	maptile map, map2;
252	object *tmp;
253
254	range = abs (disease->magic);
255
256	if (disease->env)
257	{
258	x = disease->env->x;
259	y = disease->env->y;
260	map = disease->env->map;
261	}
262	else
263	{
264	x = disease->x;
265	y = disease->y;
266	map = disease->map;
267	}
268
269	if (!map)
270	return 0;
271
272	for (int i = x - range; i <= x + range; i++)
273	for (int j = y - range; j <= y + range; j++)
274	{
275	sint16 i2, j2;
276	mflags = get_map_flags (map, &map2, i, j, &i2, &j2);
277
278	if (!(mflags & P_OUT_OF_MAP) && (mflags & P_IS_ALIVE))
279	for (tmp = GET_MAP_OB (map2, i2, j2); tmp; tmp = tmp->above)
280	infect_object (tmp, disease, 0);
281	}
282
283	return 1;
284	}
285
286
287	/* check to see if an object is infectable:
288	* objects with immunity aren't infectable.
289	* objects already infected aren't infectable.
290	* dead objects aren't infectable.
291	* undead objects are infectible only if specifically named.
292	*/
293	int
294	infect_object (object victim, object disease, int force)
295	{
296	object *tmp;
297	object *new_disease;
298
299	/* don't infect inanimate objects */
300	if (!QUERY_FLAG (victim, FLAG_MONSTER) && !(victim->type == PLAYER))
301	return 0;
302
303	/* check and see if victim can catch disease: diseases
304	* are specific
305	*/
306	if (!is_susceptible_to_disease (victim, disease))
307	return 0;
308
309	/* roll the dice on infection before doing the inventory check! */
310	if (!force && (random_roll (0, 126, victim, PREFER_HIGH) >= disease->stats.wc))
311	return 0;
312
313	/* do an immunity check */
314	if (victim->head)
315	tmp = victim->head->inv;
316	else
317	tmp = victim->inv;
318
319	/* There used to (IMO) be a flaw in the below - it used to be the case
320	* that if level check was done for both immunity and disease. This could
321	* result in a person with multiple afflictions of the same disease
322	* (eg, level 1 cold, level 2 cold, level 3 cold, etc), as long as
323	* they were cast in that same order. Instead, change it so that
324	* if you diseased, you can't get diseased more.
325	*/
326
327	for ( /* tmp initialised in if, above */ ; tmp; tmp = tmp->below)
328	{
329	if (tmp->type == SIGN && tmp->name == disease->name && tmp->level >= disease->level)
330	return 0; /* Immune! */
331	else if (tmp->type == DISEASE && tmp->name == disease->name)
332	return 0; /* already diseased */
333	}
334
335	/* If we've gotten this far, go ahead and infect the victim. */
336	new_disease = disease->clone ();
337	new_disease->stats.food = disease->stats.maxgrace;
338	new_disease->value = disease->stats.maxhp;
339	new_disease->stats.wc -= disease->last_grace; /* self-limiting factor */
340
341	/* Unfortunately, set_owner does the wrong thing to the skills pointers
342	* resulting in exp going into the owners current chosen skill.
343	*/
344
345	if (disease->owner)
346	{
347	new_disease->set_owner (disease->owner);
348
349	/* Only need to update skill if different */
350	if (new_disease->skill != disease->skill)
351	new_disease->skill = disease->skill;
352	}
353	else
354	{ /* for diseases which are passed by hitting, set owner and praying skill */
355	if (disease->env && disease->env->type == PLAYER)
356	{
357	object *player = disease->env;
358
359	new_disease->set_owner (player);
360
361	/* the skill pointer for these diseases should already be set up -
362	* hardcoding in 'praying' is not the right approach.
363	*/
364	}
365	}
366
367	insert_ob_in_ob (new_disease, victim->head_ ());
368	/* This appears to be a horrible case of overloading 'NO_PASS'
369	* for meaning in the diseases.
370	*/
371	new_disease->move_block = 0;
372	if (new_disease->owner && new_disease->owner->type == PLAYER)
373	{
374	char buf[128];
375
376	/* if the disease has a title, it has a special infection message
377	* This messages is printed in the form MESSAGE victim
378	*/
379	if (new_disease->title)
380	sprintf (buf, "%s %s!!", &disease->title, &victim->name);
381	else
382	sprintf (buf, "You infect %s with your disease, %s!", &victim->name, &new_disease->name);
383
384	if (victim->type == PLAYER)
385	new_draw_info (NDI_UNIQUE \| NDI_RED, 0, new_disease->owner, buf);
386	else
387	new_draw_info (0, 4, new_disease->owner, buf);
388	}
389	if (victim->type == PLAYER)
390	new_draw_info (NDI_UNIQUE \| NDI_RED, 0, victim, "You suddenly feel ill.");
391
392	return 1;
393
394	}
395
396
397
398	/* this function monitors the symptoms caused by the disease (if any),
399	causes symptoms, and modifies existing symptoms in the case of
400	existing diseases. */
401
402	int
403	do_symptoms (object *disease)
404	{
405	object *symptom;
406	object *victim;
407	object *tmp;
408
409	victim = disease->env;
410
411	/* This is a quick hack - for whatever reason, disease->env will point
412	* back to disease, causing endless loops. Why this happens really needs
413	* to be found, but this should at least prevent the infinite loops.
414	*/
415
416	if (victim == NULL \|\| victim == disease)
417	return 0; /* no-one to inflict symptoms on */
418
419	symptom = find_symptom (disease);
420	if (symptom == NULL)
421	{
422	/* no symptom? need to generate one! */
423	object *new_symptom;
424
425	/* first check and see if the carrier of the disease is immune. If so, no symptoms! */
426	if (!is_susceptible_to_disease (victim, disease))
427	return 0;
428
429	/* check for an actual immunity */
430	/* do an immunity check */
431	if (victim->head)
432	tmp = victim->head->inv;
433	else
434	tmp = victim->inv;
435
436	for ( /* tmp initialised in if, above */ ; tmp; tmp = tmp->below)
437	{
438	if (tmp->type == SIGN) /* possibly an immunity, or diseased */
439	if (tmp->name == disease->name && tmp->level >= disease->level)
440	return 0; /Immune! /
441	}
442
443	new_symptom = get_archetype (ARCH_SYMPTOM);
444
445	/* Something special done with dam. We want diseases to be more
446	* random in what they'll kill, so we'll make the damage they
447	* do random, note, this has a weird effect with progressive diseases.
448	*/
449	if (disease->stats.dam != 0)
450	{
451	int dam = disease->stats.dam;
452
453	/* reduce the damage, on average, 50%, and making things random. */
454
455	dam = random_roll (1, abs (dam), victim, PREFER_LOW);
456	if (disease->stats.dam < 0)
457	dam = -dam;
458	new_symptom->stats.dam = dam;
459	}
460
461
462	new_symptom->stats.maxsp = disease->stats.maxsp;
463	new_symptom->stats.food = new_symptom->stats.maxgrace;
464
465	new_symptom->name = new_symptom->name_pl = disease->name;
466
467	new_symptom->level = disease->level;
468	new_symptom->speed = disease->speed;
469	new_symptom->value = 0;
470
471	for (int i = 0; i < NUM_STATS; ++i)
472	new_symptom->stats.stat (i) = disease->stats.stat (i);
473
474	new_symptom->stats.sp = disease->stats.sp;
475	new_symptom->stats.food = disease->last_eat;
476	new_symptom->stats.maxsp = disease->stats.maxsp;
477	new_symptom->last_sp = disease->last_sp;
478	new_symptom->stats.exp = 0;
479	new_symptom->stats.hp = disease->stats.hp;
480	new_symptom->msg = disease->msg;
481	new_symptom->attacktype = disease->attacktype;
482	new_symptom->other_arch = disease->other_arch;
483
484	new_symptom->set_owner (disease->owner);
485
486	if (new_symptom->skill != disease->skill)
487	new_symptom->skill = disease->skill;
488
489	new_symptom->move_block = 0;
490	insert_ob_in_ob (new_symptom, victim);
491	return 1;
492	}
493
494	/* now deal with progressing diseases: we increase the debility
495	* caused by the symptoms.
496	*/
497	if (disease->stats.ac != 0)
498	{
499	symptom->value += disease->stats.ac;
500
501	float scale = 1.f + symptom->value / 100.f;
502
503	/* now rescale all the debilities */
504	for (int i = 0; i < NUM_STATS; ++i)
505	symptom->stats.stat (i) = scale * disease->stats.stat (i);
506
507	symptom->stats.dam = scale * disease->stats.dam;
508	symptom->stats.sp = scale * disease->stats.sp;
509	symptom->stats.food = scale * disease->last_eat;
510	symptom->stats.maxsp = scale * disease->stats.maxsp;
511	symptom->last_sp = scale * disease->last_sp;
512	symptom->stats.exp = 0;
513	symptom->stats.hp = scale * disease->stats.hp;
514
515	symptom->msg = disease->msg;
516	symptom->attacktype = disease->attacktype;
517	symptom->other_arch = disease->other_arch;
518	}
519
520	SET_FLAG (symptom, FLAG_APPLIED);
521	victim->update_stats ();
522
523	return 1;
524	}
525
526	/* grants immunity to plagues we've seen before. */
527	int
528	grant_immunity (object *disease)
529	{
530	object *immunity;
531	object *walk;
532
533	/* Don't give immunity to this disease if last_heal is set. */
534	if (disease->last_heal)
535	return 0;
536	/* first, search for an immunity of the same name */
537	for (walk = disease->env->inv; walk; walk = walk->below)
538	{
539	if (walk->type == 98 && disease->name == walk->name)
540	{
541	walk->level = disease->level;
542	return 1; /* just update the existing immunity. */
543	}
544	}
545	immunity = get_archetype ("immunity");
546	immunity->name = disease->name;
547	immunity->level = disease->level;
548	immunity->move_block = 0;
549	insert_ob_in_ob (immunity, disease->env);
550	return 1;
551
552	}
553
554
555	/* make the symptom do the nasty things it does */
556
557	int
558	move_symptom (object *symptom)
559	{
560	object *victim = symptom->env;
561	object *new_ob;
562	int sp_reduce;
563
564	if (victim == NULL \|\| victim->map == NULL)
565	{ /* outside a monster/player, die immediately */
566	symptom->destroy ();
567	return 0;
568	}
569
570	if (symptom->stats.dam > 0)
571	hit_player (victim, symptom->stats.dam, symptom, symptom->attacktype, 1);
572	else
573	hit_player (victim, (int) MAX (1, -victim->stats.maxhp * symptom->stats.dam / 100.0), symptom, symptom->attacktype, 1);
574
575	if (symptom->stats.maxsp > 0)
576	sp_reduce = symptom->stats.maxsp;
577	else
578	sp_reduce = (int) MAX (1, victim->stats.maxsp * symptom->stats.maxsp / 100.0);
579	victim->stats.sp = MAX (0, victim->stats.sp - sp_reduce);
580
581	/* create the symptom "other arch" object and drop it here
582	* under every part of the monster
583	* The victim may well have died.
584	*/
585
586	if (victim->map == NULL)
587	return 0;
588	if (symptom->other_arch)
589	{
590	object *tmp;
591
592	tmp = victim;
593	if (tmp->head != NULL)
594	tmp = tmp->head;
595	for ( /tmp initialised above / ; tmp != NULL; tmp = tmp->more)
596	{
597	new_ob = arch_to_object (symptom->other_arch);
598	new_ob->x = tmp->x;
599	new_ob->y = tmp->y;
600	new_ob->map = victim->map;
601	insert_ob_in_map (new_ob, victim->map, victim, 0);
602	}
603	}
604	new_draw_info (NDI_UNIQUE \| NDI_RED, 0, victim, symptom->msg);
605
606	return 1;
607	}
608
609	/* possibly infect due to direct physical contact
610	* i.e., AT_PHYSICAL-- called from "hit_player_attacktype" */
611	int
612	check_physically_infect (object victim, object hitter)
613	{
614	/* search for diseases, give every disease a chance to infect */
615	for (object *disease = hitter->inv; disease; disease = disease->below)
616	if (disease->type == DISEASE)
617	infect_object (victim, disease, 0);
618
619	return 1;
620	}
621
622	// find a disease in someone
623	object *
624	find_disease (object *victim)
625	{
626	for (object *disease = victim->inv; disease; disease = disease->below)
627	if (disease->type == DISEASE)
628	return disease;
629
630	return 0;
631	}
632
633	/* do the cure disease stuff, from the spell "cure disease" */
634	int
635	cure_disease (object sufferer, object caster)
636	{
637	object disease, next;
638	int casting_level;
639	int cure = 0;
640
641	if (caster)
642	casting_level = caster->level;
643	else
644	casting_level = 1000; /* if null caster, CURE all. */
645
646	for (disease = sufferer->inv; disease; disease = next)
647	{
648	next = disease->below;
649
650	if (disease->type == DISEASE)
651	{ /* attempt to cure this disease */
652	/* If caster level is higher than disease level, cure chance
653	* is automatic. If lower, then the chance is basically
654	* 1 in level_diff - if there is a 5 level difference, chance
655	* is 1 in 5.
656	*/
657	if ((casting_level >= disease->level) \|\| (!(random_roll (0, (disease->level - casting_level - 1), caster, PREFER_LOW))))
658	{
659	remove_symptoms (disease);
660	cure = 1;
661
662	if (caster)
663	change_exp (caster, disease->stats.exp, caster->chosen_skill ? caster->chosen_skill->skill : (const char *) 0, 0);
664
665	disease->destroy ();
666	}
667	}
668	}
669
670	if (cure)
671	{
672	/* Only draw these messages once */
673	if (caster)
674	new_draw_info_format (NDI_UNIQUE, 0, caster, "You cure a disease!");
675
676	new_draw_info (NDI_UNIQUE, 0, sufferer, "You no longer feel diseased.");
677	}
678
679	return 1;
680	}
681
682	/* reduces disease progression: reduce_symptoms
683	* return true if we actually reduce a disease.
684	*/
685
686	int
687	reduce_symptoms (object *sufferer, int reduction)
688	{
689	object *walk;
690	int success = 0;
691
692	for (walk = sufferer->inv; walk; walk = walk->below)
693	{
694	if (walk->type == SYMPTOM)
695	{
696	if (walk->value > 0)
697	{
698	success = 1;
699	walk->value = MAX (0, walk->value - 2 * reduction);
700	/* give the disease time to modify this symptom,
701	* and reduce its severity. */
702	walk->speed_left = 0;
703	}
704	}
705	}
706	if (success)
707	new_draw_info (NDI_UNIQUE, 0, sufferer, "Your illness seems less severe.");
708	return success;
709	}