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

Comparing deliantra/server/server/alchemy.C (file contents):
Revision 1.52 by root, Thu Apr 15 02:51:39 2010 UTC vs.
Revision 1.66 by root, Fri Nov 26 17:43:04 2021 UTC

 /*
  * This file is part of Deliantra, the Roguelike Realtime MMORPG.
  *
+ * Copyright (©) 2017,2018 Marc Alexander Lehmann / the Deliantra team
- * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
+ * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
  * Copyright (©) 2002 Mark Wedel & Crossfire Development Team
  * Copyright (©) 1992 Frank Tore Johansen
  *
  * Deliantra is free software: you can redistribute it and/or modify it under
  * the terms of the Affero GNU General Public License as published by the
  * Free Software Foundation, either version 3 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 Affero GNU General Public License
  * and the GNU General Public License along with this program. If not, see
  * <http://www.gnu.org/licenses/>.
  *
  * The authors can be reached via e-mail to <support@deliantra.net>
  */
 /* March 96 - Laid down original code. -b.t. thomas@astro.psu.edu */
 /** Returns a random selection from cauldron_effect[] */
 static const char *
 cauldron_sound ()
 {
-  int size = sizeof (cauldron_effect) / sizeof (char *);
+  return cauldron_effect [rndm (ecb_array_length (cauldron_effect))];
-  return cauldron_effect[rndm (0, size - 1)];
 }
 /**
  * Recipe value of the entire contents of a container.
  * This appears to just generate a hash value, which I guess for now works
  * ok, but the possibility of duplicate hashes is certainly possible - msw
   */
 static int
 content_recipe_value (object *op)
 {
-  char name[MAX_BUF];
   object *tmp = op->inv;
-  int tval = 0, formula = 0;
+  int formula = 0;
   while (tmp)
     {
-      tval = 0;
+      const char *name = tmp->title
-      assign (name, tmp->name);
-      if (tmp->title)
-        sprintf (name, "%s %s", &tmp->name, &tmp->title);
+        ? (const char *)format ("%s %s", &tmp->name, &tmp->title)
+        : tmp->name;
-      tval = (strtoint (name) * (tmp->nrof ? tmp->nrof : 1));
+      int tval = strtoint (name) * tmp->number_of ();
 #ifdef ALCHEMY_DEBUG
       LOG (llevDebug, "Got ingredient %d %s(%d)\n", tmp->nrof ? tmp->nrof : 1, name, tval);
 #endif
       formula += tval;
       tmp = tmp->below;
     }
 #ifdef ALCHEMY_DEBUG
   LOG (llevDebug, " Formula value=%d\n", formula);
 #endif
   return formula;
 }
 /**
  * Returns total number of items in op
  */
 static object *
 find_transmution_ob (object *first_ingred, recipe *rp, size_t *rp_arch_index, int create_item)
 {
   object *prod_item = 0;
-  bool found        = false;
   *rp_arch_index    = 0;
   if (rp->transmute) /* look for matching ingredient/prod archs */
     for (object *item = first_ingred; item; item = item->below)
       {
              &prod_item->arch->archname, prod_item->nrof);
       }
 #endif
       if (!prod_item)
         *rp_arch_index = rndm (rp->arch_names);
-      prod_item = get_archetype (rp->arch_name[*rp_arch_index]);
+      prod_item = archetype::get (rp->arch_name[*rp_arch_index]);
     }
 #ifdef ALCHEMY_DEBUG
   LOG (llevDebug, "recipe calls for%stransmution.\n", rp->transmute ? " " : " no ");
   if (prod_item != NULL)
 }
 /*
  * All but object "save_item" are elimentated from
  * the container list. Note we have to becareful to remove the inventories
  * of objects in the cauldron inventory (ex icecube has stuff in it).
  */
 static void
 remove_contents (object *first_ob, object *save_item)
 {
   // this cries for a cleaner rewrite, removing save_item first possibly
       item->nrof = nrof;
     }
 }
 /**
  * Essentially a wrapper for make_item_from_recipe() and
  * insert_ob_in_ob. If the caster has some alchemy skill, then they might
  * gain some exp from (successfull) fabrication of the product.
  * If nbatches==-1, don't give exp for this creation (random generation/
  * failed recipe)
  */
 static object *
 attempt_recipe (object *caster, object *cauldron, int ability, recipe *rp, int nbatches)
     {
       remove_contents (cauldron->inv, item);
       /* Recalc carrying of the cauldron, in case recipe did not conserve mass */
       cauldron->update_weight ();
       /* adj lvl, nrof on caster level */
-      adjust_product (item, ability, rp->yield ? (rp->yield * batches) : batches);
+      adjust_product (item, ability, rp->yield ? rp->yield * batches : batches);
       if (!item->env && (item = insert_ob_in_ob (item, cauldron)) == NULL)
         {
           new_draw_info (NDI_UNIQUE, 0, caster, "Nothing happened.");
           /* new_draw_info_format(NDI_UNIQUE, 0,caster,
              "Your spell causes the %s to explode!",&cauldron->name); */
       if (rndm (0, 2))
         {                       /* slag created */
           object *tmp = cauldron->inv;
           int weight = 0;
-          tmp = get_archetype (shstr_rock);
+          tmp = archetype::get (shstr_rock);
           tmp->weight = weight;
           tmp->value = 0;
           tmp->material = name_to_material (shstr_stone);
           tmp->name = shstr_slag;
           tmp->name_pl = shstr_slags;
       remove_contents (cauldron->inv, NULL);
       switch (rndm (0, 2))
         {
           case 0:
-            tmp = get_archetype (shstr_bomb);
+            tmp = archetype::get (shstr_bomb);
             tmp->stats.dam = random_roll (1, level, op, PREFER_LOW);
             tmp->stats.hp = random_roll (1, level, op, PREFER_LOW);
             new_draw_info_format (NDI_UNIQUE, 0, op, "The %s creates a bomb!", &cauldron->name);
             break;
           default:
-            tmp = get_archetype (shstr_fireball);
+            tmp = archetype::get (shstr_fireball);
             tmp->stats.dam = random_roll (1, level, op, PREFER_LOW) / 5 + 1;
             tmp->stats.hp = random_roll (1, level, op, PREFER_LOW) / 10 + 2;
             new_draw_info_format (NDI_UNIQUE, 0, op, "The %s erupts in flame!", &cauldron->name);
             break;
         }
       new_draw_info_format (NDI_UNIQUE, 0, op, "The %s %s.", &cauldron->name, cauldron_sound ());
       remove_contents (cauldron->inv, NULL);
     }
   else if (level < 80)
     {                           /* MAJOR FIRE */
-      object *fb = get_archetype (SP_MED_FIREBALL);
+      object *fb = archetype::get (SP_MED_FIREBALL);
       remove_contents (cauldron->inv, NULL);
       fire_arch_from_position (cauldron, cauldron, cauldron->x, cauldron->y, 0, fb);
       fb->destroy ();
       new_draw_info_format (NDI_UNIQUE, 0, op, "The %s erupts in flame!", &cauldron->name);
     }
   else if (level == 151)
     {                           /* CREATE RANDOM ARTIFACT */
       object *tmp;
       /* this is meant to be better than prior possiblity,
        * in this one, we allow *any* valid alchemy artifact
        * to be made (rather than only those on the given
        * formulalist) */
       if (!rp)
         rp = get_random_recipe ((recipelist *) NULL);
-      if (rp && (tmp = get_archetype (rp->arch_name [rndm (rp->arch_names)])))
+      if (rp && (tmp = archetype::get (rp->arch_name [rndm (rp->arch_names)])))
         {
           generate_artifact (tmp, random_roll (1, op->level / 2 + 1, op, PREFER_HIGH) + 1);
           if ((tmp = insert_ob_in_ob (tmp, cauldron)))
             {
               remove_contents (cauldron->inv, tmp);
             }
         }
     }
   else
     {                           /* MANA STORM - watch out!! */
-      object *tmp = get_archetype (LOOSE_MANA);
+      object *tmp = archetype::get (LOOSE_MANA);
       new_draw_info (NDI_UNIQUE, 0, op, "You unwisely release potent forces!");
       remove_contents (cauldron->inv, NULL);
       cast_magic_storm (op, tmp, level);
     }
  * could be if the user fails to concoct a recipe properly. Factors include
  * the number of ingredients, the length of the name of each ingredient,
  * the user's effective level, the user's Int and the enchantment on the
  * mixing device (aka "cauldron"). Higher values of 'danger' indicate more
  * danger. Note that we assume that we have had the caster ready the alchemy
  * skill *before* this routine is called. (no longer auto-readies that skill)
  * -b.t.
  */
 static int
-calc_alch_danger (object *caster, object *cauldron, recipe *rp)
+calc_alch_danger (object *caster, object *cauldron, object *skill, recipe *rp)
 {
-  object *item;
-  char name[MAX_BUF];
-  int danger = 0, nrofi = 0;
+  int danger = 0;
   /* Knowing alchemy skill reduces yer risk */
-  danger -= caster->chosen_skill ? caster->chosen_skill->level : caster->level;
+  danger -= skill->level;
-  if (!caster->chosen_skill)
-    LOG (llevError | logBacktrace, "calc_alch_danger called without a chosen skill, caster %s, cauldron %s\n",
-         caster->debug_desc (), cauldron->debug_desc ());
   /* better cauldrons reduce risk */
   danger -= cauldron->magic;
   /* Higher Int, lower the risk */
   /* Ingredients. Longer names usually mean rarer stuff.
    * Thus the backfire is worse. Also, more ingredients
    * means we are attempting a more powerfull potion,
    * and thus the backfire will be worse.  */
-  for (item = cauldron->inv; item; item = item->below)
+  for (object *item = cauldron->inv; item; item = item->below)
     {
-      assign (name, item->name);
+      const char *name = item->title
-      if (item->title)
-        sprintf (name, "%s %s", &item->name, &item->title);
+         ? format ("%s %s", &item->name, &item->title)
+         : &item->name;
-      danger += (strtoint (name) / 1000) + 3;
+      danger += strtoint (name) / 1000 + 3;
-      nrofi++;
     }
-  if (rp == NULL)
+  if (!rp)
     danger += 110;
   else
     danger += rp->diff * 3;
   /* Using a bad device is *majorly* stupid */
-  if (cauldron->flag [FLAG_CURSED])
+  if (cauldron->flag [FLAG_CURSED]) danger +=  80;
-    danger += 80;
-  if (cauldron->flag [FLAG_DAMNED])
+  if (cauldron->flag [FLAG_DAMNED]) danger += 200;
-    danger += 200;
 #ifdef ALCHEMY_DEBUG
   LOG (llevDebug, "calc_alch_danger() returned danger=%d\n", danger);
 #endif
   return result;
 }
 /**
  * Main part of the ALCHEMY code. From this we call fctns
  * that take a look at the contents of the 'cauldron' and, using these ingredients,
  * we construct an integer formula value which is referenced (randomly) against a
  * formula list (the formula list chosen is based on the # contents of the cauldron).
  *
  * If we get a match between the recipe indicated in cauldron contents and a
  * randomly chosen one, an item is created and experience awarded. Otherwise
  * various failure effects are possible (getting worse and worse w/ # cauldron
  * ingredients). Note that the 'item' to be made can be *anything* listed on
  * the artifacts list in lib/artifacts which has a recipe listed in lib/formulae.
  *
  * To those wondering why I am using the funky formula index method:
  *   1) I want to match recipe to ingredients regardless of ordering.
  *   2) I want a fast search for the 'right' recipe.
  *
  * Note: it is just possible that a totally different combination of
  * ingredients will result in a match with a given recipe. This is not a bug!
  * There is no good reason (in my mind) why alchemical processes have to be
  * unique -- such a 'feature' is one reason why players might want to experiment
  * around. :)
   recipe *rp = NULL;
   float success_chance;
   int numb, ability = 1;
   int formula = 0;
   float ave_chance;
-  object *item, *skop;
+  object *item;
   if (caster->type != PLAYER)
     return;                     /* only players for now */
   if (get_map_flags (caster->map, NULL, caster->x, caster->y, NULL, NULL) & P_SAFE)
           /* create the object **FIRST**, then decide whether to keep it.     */
           if ((item = attempt_recipe (caster, cauldron, ability, rp, formula / rp->index)) != NULL)
             {
               /*  compute base chance of recipe success */
+              //TODO: (marc) diff is documenmted as percentage difficulty, not as divisor.
-              success_chance = ((float) ability / (float) (rp->diff * (item->level + 2)));
+              success_chance = ((float)ability / (float)(rp->diff * (item->level + 2)));
               if (ave_chance == 0)
                 ave_chance = 1;
 #ifdef ALCHEMY_DEBUG
               LOG (llevDebug, "percent success chance =  %f ab%d / diff%d*lev%d\n", success_chance, ability, rp->diff, item->level);
             }
         }
     }
   /* if we get here, we failed!! */
-  alchemy_failure_effect (caster, cauldron, rp, calc_alch_danger (caster, cauldron, rp));
+  alchemy_failure_effect (caster, cauldron, rp, calc_alch_danger (caster, cauldron, skill, rp));
 }

Diff Legend

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

Comparing deliantra/server/server/alchemy.C (file contents): Revision 1.52 by root, Thu Apr 15 02:51:39 2010 UTC vs. Revision 1.66 by root, Fri Nov 26 17:43:04 2021 UTC

Diff Legend

Comparing deliantra/server/server/alchemy.C (file contents):
Revision 1.52 by root, Thu Apr 15 02:51:39 2010 UTC vs.
Revision 1.66 by root, Fri Nov 26 17:43:04 2021 UTC