[ViewVC] Diff of: cvs/deliantra/server/server/rune.C

Comparing deliantra/server/server/rune.C (file contents):
Revision 1.26 by root, Mon Jun 4 12:19:09 2007 UTC vs.
Revision 1.55 by root, Mon Oct 29 23:55:55 2012 UTC

 /*
- * This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
+ * This file is part of Deliantra, the Roguelike Realtime MMORPG.
  *
- * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
+ * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
- * Copyright (©) 2003,2007 Mark Wedel & Crossfire Development Team
+ * Copyright (©) 2003 Mark Wedel & Crossfire Development Team
- * Copyright (©) 1992,2007 Frank Tore Johansen
+ * Copyright (©) 1992 Frank Tore Johansen
  *
- * Crossfire TRT is free software; you can redistribute it and/or modify it
+ * Deliantra is free software: you can redistribute it and/or modify it under
- * under the terms of the GNU General Public License as published by the Free
+ * the terms of the Affero GNU General Public License as published by the
- * Software Foundation; either version 2 of the License, or (at your option)
+ * Free Software Foundation, either version 3 of the License, or (at your
- * any later version.
+ * option) any later version.
  *
- * This program is distributed in the hope that it will be useful, but
+ * This program is distributed in the hope that it will be useful,
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * for more details.
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License along
+ * You should have received a copy of the Affero GNU General Public License
- * with Crossfire TRT; if not, write to the Free Software Foundation, Inc. 51
+ * and the GNU General Public License along with this program. If not, see
- * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * <http://www.gnu.org/licenses/>.
  *
- * The authors can be reached via e-mail to <crossfire@schmorp.de>
+ * The authors can be reached via e-mail to <support@deliantra.net>
  */
 #include <global.h>
 #include <sproto.h>
 #include <spells.h>
  *  write_rune:
  *  op:  rune writer
  *  skop: skill object used for casting this rune
  *  dir:  orientation of rune, direction rune's contained spell will
  *	    be cast in, if applicable
- *  inspell: spell object to put into the rune, can be null if doing
+ *  spell: spell object to put into the rune
- *    a marking rune.
  *  level:  level of casting of the rune
  *  runename:  name of the rune or message displayed by the rune for
  *		a rune of marking
  */
 int
 write_rune (object *op, object *caster, object *spell, int dir, const char *runename)
 {
   object *tmp, *rune_spell, *rune;
-  char buf[MAX_BUF];
   maptile *m;
   sint16 nx, ny;
   if (!dir)
     dir = 1;
       new_draw_info (NDI_UNIQUE, 0, op, "You can't write a rune on top of another rune.");
       return 0;
     }
   if (spell->other_arch)
-    rune_spell = arch_to_object (spell->other_arch);
+    rune_spell = spell->other_arch->instance ();
   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.
               }
           }
       if (!rune_spell)
         {
-          new_draw_info_format (NDI_UNIQUE, 0, op, "You don't know any spell named %s", runename);
+          new_draw_info_format (NDI_UNIQUE, 0, op, "You don't know any spell named %s.", runename);
           return 0;
         }
       if (rune_spell->skill != spell->skill)
         {
-          new_draw_info_format (NDI_UNIQUE, 0, op, "You can't cast %s with %s", &rune_spell->name, &spell->name);
+          new_draw_info_format (NDI_UNIQUE, 0, op, "You can't cast %s with %s. H<The spell must be of the %s spell school.>", &rune_spell->name, &spell->name, &spell->skill);
           return 0;
         }
       if (caster->path_denied & spell->path_attuned && !caster->flag [FLAG_WIZCAST])
         {
           new_draw_info_format (NDI_UNIQUE, 0, op, "%s belongs to a spell path denied to you.", &rune_spell->name);
           return 0;
         }
-      if (caster_level (caster, rune_spell) < rune_spell->level && !caster->flag [FLAG_WIZCAST])
+      if (casting_level (caster, rune_spell) < rune_spell->level && !caster->flag [FLAG_WIZCAST])
         {
-          new_draw_info_format (NDI_UNIQUE, 0, op, "%s is beyond your ability to cast!", &rune_spell->name);
+          new_draw_info_format (NDI_UNIQUE, 0, op, "%s is beyond your ability to cast! H<Your effetcive casting level is too low.>", &rune_spell->name);
           return 0;
         }
       if (SP_level_spellpoint_cost (caster, rune_spell, SPELL_MANA) > op->stats.sp)
         {
           new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough grace.");
           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);
+      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 = get_archetype (GENERIC_RUNE);
+      rune = archetype::get (GENERIC_RUNE);
-      sprintf (buf, "You set off a rune of %s\n", &rune_spell->name);
+      rune->msg = format ("You set off a rune of %s\n", &rune_spell->name);
-      rune->msg = buf;
       rune->insert (rune_spell->clone ());
       if (spell->face != blank_face)
         rune->face = spell->face;
     }
-  rune->level = caster_level (caster, spell);
+  rune->level = casting_level (caster, spell);
   rune->stats.Cha = rune->level / 2;    /* the invisibility parameter */
   rune->direction = dir;        /* where any spell will go upon detonation */
   rune->set_owner (op);         /* runes without need no owner */
   set_spell_skill (op, caster, spell, rune);
   if (!op->level)
     return;
   int det = op->invisible;
-  if (!(rndm (0, MAX (1, (op->stats.Cha)) - 1)))
+  if (!(rndm (0, max (0, op->stats.Cha - 1))))
     {
       op->invisible = 0;
       op->speed_left -= 1;
     }
   else
 }
 /*  peterm: rune_attack
  * function handles those runes which detonate but do not cast spells.
  */
-void
+static void
 rune_attack (object *op, object *victim)
 {
   if (victim)
     {
       hit_player (victim, op->stats.dam, op, op->attacktype, 1);
   /* Prevent recursion */
   if (trap->stats.hp <= 0)
     return;
-  if (QUERY_FLAG (trap, FLAG_IS_LINKED))
+  if (trap->flag [FLAG_IS_LINKED])
-    use_trigger (trap);
+    use_trigger (trap, victim);
   /* 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) && !trap->inv && !trap->other_arch)
+  if (!victim->flag [FLAG_ALIVE] && !trap->inv && !trap->other_arch)
     return;
   trap->stats.hp--;             /*decrement detcount */
   if (victim && victim->type == PLAYER)
     new_draw_info (NDI_UNIQUE, 0, victim, trap->msg);
   /*  Flash an image of the trap on the map so the poor sod
    *   knows what hit him.
    */
-  env = object_get_env_recursive (trap);
+  env = trap->outer_env_or_self ();
   /* If the victim is not next to this trap, don't set it off.
    * players shouldn't get hit by firing arrows at a door for example.
    * At the same time, the trap will stick around until detonated
    */
   get_rangevector (env, victim, &rv, 0);
   if (rv.distance > 1)
     return;
+  env->play_sound (trap->sound ? trap->sound : sound_find ("trap_spring"));
   trap_show (trap, env);
   if (victim->type == PLAYER) // only count players as enemies
     trap->enemy = victim; // set the victim as the traps enemy, so that summoned
                           // creatures know who to attack.
   /* Only if it is a spell do we proceed here */
-  if ((trap->inv && trap->inv->type == SPELL) || (trap->other_arch && trap->other_arch->clone.type == SPELL))
+  if ((trap->inv && trap->inv->type == SPELL) || (trap->other_arch && trap->other_arch->type == SPELL))
     {
       if (trap->destroyed ())
         return;
       // breaks summon golem spells, which, for inexplicable reasons,
       // do not work like summon golem spells at all but still require
       // direction "0" to work at all.
       //if (trap->direction)
       //  rv.direction = trap->direction;
-      for (i = 0; i < MAX (1, trap->stats.maxhp); i++)
+      for (i = 0; i < max (1, trap->stats.maxhp); i++)
         {
           if (trap->inv)
             cast_spell (env, trap, trap->direction, trap->inv, NULL);
           else
             {
-              object *spell = arch_to_object (trap->other_arch);
+              object *spell = trap->other_arch->instance ();
               cast_spell (env, trap, trap->direction, spell, NULL);
               spell->destroy ();
             }
         }
   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);
+      trap->set_flag (FLAG_IS_USED_UP);
     }
 }
 /* dispel_rune:  by peterm
  * dispels the target rune, depending on the level of the actor
     {
       new_draw_info (NDI_UNIQUE, 0, op, "There's nothing there!");
       return 0;
     }
-  for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
+  for (tmp = GET_MAP_OB (m, x, y); tmp; 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->archname, "rune_mark"))
+      if (tmp->type == SIGN && tmp->arch->archname == shstr_rune_mark)
         {
           tmp->destroy ();
           new_draw_info (NDI_UNIQUE, 0, op, "You wipe out the rune of marking!");
           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)
+      for (tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
         {
           if (tmp2->type == RUNE || tmp2->type == TRAP)
             {
               tmp = tmp2;
               searchflag = 0;
               break;
             }
         }
       if (!searchflag)
         break;
     }
   /* no rune there. */
   if (tmp == NULL)
     {
       new_draw_info (NDI_UNIQUE, 0, op, "There's nothing there!");
       return 0;
     }
   trap_disarm (op, tmp, 0, skill);
   return 1;
 }
 int
 trap_see (object *op, object *trap)
 {
-  int chance;
-  chance = random_roll (0, 99, op, PREFER_HIGH);;
+  int 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
+  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))))))
     {
       new_draw_info_format (NDI_UNIQUE, 0, op, "You spot a %s!", &trap->name);
       return 1;
     }
   return 0;
 }
 int
 trap_show (object *trap, object *where)
 {
   if (where == NULL)
     return 0;
-  object *tmp = get_archetype ("runedet");
+  object *tmp = archetype::get (shstr_runedet);
-  tmp->face = GET_ANIMATION (trap, 0);
+  tmp->face = trap->get_anim_frame (0);
   tmp->insert_at (where, 0);
   return 1;
 }
 int
 trap_disarm (object *disarmer, object *trap, int risk, object *skill)
 {
-  int trapworth;                /* need to compute the experience worth of the trap
+  int trapworth; /* need to compute the experience worth of the trap before we kill it */
-                                   before we kill it */
   /* this formula awards a more reasonable amount of exp */
-  trapworth = MAX (1, trap->level) * disarmer->map->difficulty *
+  trapworth = max (1, trap->level)
+            * disarmer->map->difficulty
-    sqr (MAX (trap->stats.dam, trap->inv ? trap->inv->level : 1)) / skill->level;
+            * 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)))
+  if (!(random_roll (0, (max (2, min (20, trap->level - skill->level + 5 - disarmer->stats.Dex / 2)) - 1), disarmer, PREFER_LOW)))
     {
       new_draw_info_format (NDI_UNIQUE, 0, disarmer, "You successfully disarm the %s!", &trap->name);
-      trap->destroy (1);
+      trap->destroy ();
       /* 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 1;               /* give minimal exp and say success */
     }
   else
     {
       new_draw_info_format (NDI_UNIQUE, 0, disarmer, "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)
+      if (!(random_roll (0, (max (2, skill->level - trap->level + disarmer->stats.Dex / 2 - 6)) - 1, disarmer, PREFER_LOW)) && risk)
         {
           new_draw_info (NDI_UNIQUE, 0, disarmer, "In fact, you set it off!");
           spring_trap (trap, disarmer);
         }
       return 0;
     }
 }
 /*  traps need to be adjusted for the difficulty of the map.  The
  * default traps are too strong for wimpy level 1 players, and
  * unthreatening to anyone of high level
  */
 void
 trap_adjust (object *trap, int difficulty)
 {
   int i;

Diff Legend

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

Comparing deliantra/server/server/rune.C (file contents): Revision 1.26 by root, Mon Jun 4 12:19:09 2007 UTC vs. Revision 1.55 by root, Mon Oct 29 23:55:55 2012 UTC

Diff Legend

Comparing deliantra/server/server/rune.C (file contents):
Revision 1.26 by root, Mon Jun 4 12:19:09 2007 UTC vs.
Revision 1.55 by root, Mon Oct 29 23:55:55 2012 UTC