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

Comparing deliantra/server/server/shop.C (file contents):
Revision 1.76 by root, Fri Mar 26 01:04:45 2010 UTC vs.
Revision 1.80 by root, Wed Apr 28 19:01:01 2010 UTC

   not_cursed = flag & F_NOT_CURSED;
   approximate = flag & F_APPROX;
   shop = flag & F_SHOP;
   flag &= ~(F_NO_BARGAIN | F_IDENTIFIED | F_NOT_CURSED | F_APPROX | F_SHOP);
+  int number = tmp->number_of ();
   if (tmp->type == MONEY)
-    return tmp->nrof * tmp->value;
+    return number * tmp->value;
   if (tmp->type == GEM)
     {
       if (flag == F_TRUE)
-        return (tmp->nrof * tmp->value);
+        return number * tmp->value;
       if (flag == F_BUY)
-        return (sint64) (1.03 * tmp->nrof * tmp->value);
+        return 1.03 * number * tmp->value;
       if (flag == F_SELL)
-        return (sint64) (0.97 * tmp->nrof * tmp->value);
+        return 0.97 * number * tmp->value;
       LOG (llevError, "Query_cost: Gem type with unknown flag %d: %s\n", flag, tmp->debug_desc ());
       return 0;
     }
-  int number = tmp->number_of ();
-  if (QUERY_FLAG (tmp, FLAG_IDENTIFIED) || !need_identify (tmp) || identified)
+  if (tmp->flag [FLAG_IDENTIFIED] || !tmp->need_identify () || identified)
     {
-      if (!not_cursed && (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))
+      if (!not_cursed && (tmp->flag [FLAG_CURSED] || tmp->flag [FLAG_DAMNED]))
         return 0;
       else
-        val = tmp->value * number;
+        val = number * tmp->value;
     }
   /* This area deals with objects that are not identified, but can be */
   else
     {
       if (flag == F_BUY)
           else
             {
               /* Get 2/3'rd value for applied objects, 1/3'rd for totally
                * unknown objects
                */
-              if (QUERY_FLAG (tmp, FLAG_BEEN_APPLIED))
+              if (tmp->flag [FLAG_BEEN_APPLIED])
                 val = number * tmp->arch->value * 2 / 3;
               else
-                val = number * tmp->arch->value / 3;
+                val = number * tmp->arch->value     / 3;
             }
         }
     }
   /* If the item has been applied or identifed or does not need to be
    * tmp->arch->magic for any magic.  The check for archetype
    * magic is to not give extra money for archetypes that are by
    * default magical.  This is because the archetype value should have
    * already figured in that value.
    */
-  if ((QUERY_FLAG (tmp, FLAG_IDENTIFIED) || !need_identify (tmp) || identified ||
+  if ((tmp->flag [FLAG_IDENTIFIED] || !tmp->need_identify () || identified || tmp->flag [FLAG_BEEN_APPLIED])
-       QUERY_FLAG (tmp, FLAG_BEEN_APPLIED)) && tmp->magic && (tmp->arch == NULL || !tmp->arch->magic))
+      && tmp->magic && (!tmp->arch || !tmp->arch->magic))
     {
       if (tmp->magic > 0)
-        val *= (3 * tmp->magic * tmp->magic * tmp->magic);
+        val *= 3 * tmp->magic * tmp->magic * tmp->magic;
       else
         /* Note that tmp->magic is negative, so that this
          * will actually be something like val /=2, /=3, etc.
          */
-        val /= (1 - tmp->magic);
+        val /= 1 - tmp->magic;
     }
   if (tmp->type == WAND)
     {
       /* Value of the wand is multiplied by the number of
        * charges.  the treasure code already sets up the value
        * 50 charges is used as the baseline.
        */
-      if (QUERY_FLAG (tmp, FLAG_IDENTIFIED) || !need_identify (tmp) || identified)
+      if (tmp->flag [FLAG_IDENTIFIED] || !tmp->need_identify () || identified)
-        val = (val * tmp->stats.food) / 50;
+        val *= tmp->stats.food / 50;
       else                      /* if not identified, presume one charge */
         val /= 50;
     }
   /* Limit amount of money you can get for really great items. */
   if (flag == F_SELL)
-    val = value_limit ((sint64) val, number, who, shop);
+    val = value_limit (val, number, who, shop);
   // use a nonlinear price adjustment. as my predecessor said, don't change
   // the archetypes, its work required for balancing, and we don't care.
   //val = pow (val, 1.05);
        * will come from the basic stat charisma
        * the rest will come from the level in bargaining skill
        */
       const double cha_ratio = 0.40;
-      diff = no_bargain ? 1.0 : 1. - pow (lev_bargain / (double) settings.max_level, 0.25);
+      diff = no_bargain ? 1.0 : 1. - pow (lev_bargain / MAXLEVEL_TREASURE, 0.25);
       diff = (1. - cha_ratio) * diff + cha_ratio * (cha_bonus[who->stats.Cha] - 1.) / (cha_bonus[who->stats.Cha] + 1.);
       diff = .02 + (.80 - .02) * diff;
       if (flag == F_BUY)
         val += val * diff;
         val -= val * diff;
       // now find a price range. the less good we can judge, the larger the range is
       // then the range is adjusted randomly around the correct value
       if (approximate)
-        approx_range = sint64 (val / sqrt (lev_identify * 3 + 1));
+        approx_range = val / sqrt (lev_identify * 3 + 1);
     }
   /* I don't think this should really happen - if it does, it indicates and
    * overflow of diff above.  That should only happen if
    * we are selling objects - in that case, the person just
    * gets no money.
    */
   if ((sint64) val < 0)
     val = 0;
-  /* Unidentified stuff won't sell for more than 60gp */
+  /* Unidentified stuff won't sell for more than 10gp */
-  if (flag == F_SELL && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && need_identify (tmp) && !identified)
+  if (flag == F_SELL && !tmp->flag [FLAG_IDENTIFIED] && tmp->need_identify () && !identified)
-    {
+    min_it (val, 1000);
-      val = (val > 600) ? 600 : val;
-    }
   /* if we are in a shop, check how the type of shop should affect the price */
   if (shop && who)
     {
       if (flag == F_SELL)
-        val = (val * shop_specialisation_ratio (tmp, who->map) * shopkeeper_approval (who->map, who) / shop_greed (who->map));
+        val *= shop_specialisation_ratio (tmp, who->map) * shopkeeper_approval (who->map, who) / shop_greed (who->map);
       else if (flag == F_BUY)
         {
           /*
            * when buying, if the item was sold by another player, it is ok to
            * let the item be sold cheaper, according to the specialisation of
            * be sold for (otherwise players could camp map resets to make money).
            * In game terms, a non-specialist shop, might not recognise the true
            * value of the items they sell (much like how people sometimes find
            * antiques in a junk shop in real life).
            */
-          if (QUERY_FLAG (tmp, FLAG_PLAYER_SOLD))
+          if (tmp->flag [FLAG_PLAYER_SOLD])
-            val = (val * shop_greed (who->map) * shop_specialisation_ratio (tmp, who->map) / shopkeeper_approval (who->map, who));
+            val *= shop_specialisation_ratio (tmp, who->map);
           else
-            val = (val * shop_greed (who->map) / (shop_specialisation_ratio (tmp, who->map) * shopkeeper_approval (who->map, who)));
+            val /= shop_specialisation_ratio (tmp, who->map);
+          val *= shop_greed (who->map) / shopkeeper_approval (who->map, who);
         }
       /* we will also have an extra 0-5% variation between shops of the same type
        * for valuable items (below a value of 50 this effect wouldn't be very
        * pointful, and could give fun with rounding.
        */
       //TODO: why use cosf at all, just % and scale linearly, gives more even distribution
       if (val > 50)
-        val += float (val) * .05f * cosf ((tmp->uuid.seq & 0xffff) * float (M_PI * 2. / 0x10000));
+        val *= 1 + .05f * cosf ((tmp->uuid.seq & 0xffff) * M_PI * 2. / 0x10000);
     }
-  return (sint64) val;
+  return val;
 }
 /* Find the coin type that is worth more the 'c'.  Starts at the
  * cointype placement.
  */
 {
   archetype *coin;
   do
     {
-      if (coins[*cointype] == NULL)
+      if (!coins [*cointype])
-        return NULL;
+        return 0;
-      coin = archetype::find (coins[*cointype]);
+      coin = archetype::find (coins [*cointype]);
-      if (coin == NULL)
+      if (!coin)
-        return NULL;
+        return 0;
       *cointype += 1;
     }
   while (coin->value > c);
   return coin;
     }
   for (tmp = op->inv; tmp; tmp = tmp->below)
     if (tmp->type == MONEY)
       total += tmp->nrof * (sint64)tmp->value;
-    else if (tmp->type == CONTAINER && QUERY_FLAG (tmp, FLAG_APPLIED) && (!tmp->race || tmp->race.contains ("gold")))
+    else if (tmp->type == CONTAINER && tmp->flag [FLAG_APPLIED] && (!tmp->race || tmp->race.contains ("gold")))
       total += query_money (tmp);
   return total;
 }
     return 0;
   pay_from_container (pl, pl, to_pay);
   for (pouch = pl->inv; pouch && to_pay; pouch = pouch->below)
-    if (pouch->type == CONTAINER && QUERY_FLAG (pouch, FLAG_APPLIED) && (!pouch->race || pouch->race.contains ("gold")))
+    if (pouch->type == CONTAINER && pouch->flag [FLAG_APPLIED] && (!pouch->race || pouch->race.contains ("gold")))
       pay_from_container (pl, pouch, to_pay);
   pl->update_stats ();
   return 1;
 }
     change_exp (pl, saved_money, "bargaining", SK_EXP_NONE);
   pay_from_container (pl, pl, to_pay);
   for (pouch = pl->inv; pouch && to_pay; pouch = pouch->below)
-    if (pouch->type == CONTAINER && QUERY_FLAG (pouch, FLAG_APPLIED) && (!pouch->race || pouch->race.contains ("gold")))
+    if (pouch->type == CONTAINER && pouch->flag [FLAG_APPLIED] && (!pouch->race || pouch->race.contains ("gold")))
       pay_from_container (pl, pouch, to_pay);
   pl->update_stats ();
   return 1;
       LOG (llevError, "can_pay(): called against something that isn't a player\n");
       return 0;
     }
   for (object::depth_iterator item = pl->begin (); item != pl->end (); ++item)
-    if (QUERY_FLAG (item, FLAG_UNPAID))
+    if (item->flag [FLAG_UNPAID])
       {
         unpaid_count++;
         unpaid_price += query_cost (item, pl, F_BUY | F_SHOP);
       }
     {
       next_item:
       for (object::depth_iterator op = pl->begin (); op != pl->end (); ++op)
         {
-          if (QUERY_FLAG (op, FLAG_UNPAID))
+          if (op->flag [FLAG_UNPAID])
             {
               char buf[MAX_BUF];
               snprintf (buf, MAX_BUF, "%s", query_cost_string (op, pl, F_BUY | F_SHOP));
               if (!pay_for_item (op, pl))
                 {
                   sint64 i = query_cost (op, pl, F_BUY | F_SHOP) - query_money (pl);
-                  CLEAR_FLAG (op, FLAG_UNPAID);
+                  op->clr_flag (FLAG_UNPAID);
                   new_draw_info_format (NDI_UNIQUE, 0, pl, "You lack %s to buy %s.", cost_string_from_value (i, 0), query_name (op));
-                  SET_FLAG (op, FLAG_UNPAID);
+                  op->set_flag (FLAG_UNPAID);
                   return 0;
                 }
               else
                 {
-                  CLEAR_FLAG (op, FLAG_UNPAID);
+                  op->clr_flag (FLAG_UNPAID);
-                  CLEAR_FLAG (op, FLAG_PLAYER_SOLD);
+                  op->clr_flag (FLAG_PLAYER_SOLD);
                   new_draw_info_format (NDI_UNIQUE, 0, op, "You paid %s for %s.", buf, query_name (op));
                   if (!merge_ob (op, op->env->inv))
                     esrv_update_item (UPD_FLAGS, pl, op);
         LOG (llevError, "Could not find %s archetype\n", coins[count]);
       else if ((amount / at->value) > 0)
         {
           for (pouch = pl->inv; pouch; pouch = pouch->below)
             {
-              if (pouch->type == CONTAINER && QUERY_FLAG (pouch, FLAG_APPLIED) && pouch->race.contains ("gold"))
+              if (pouch->type == CONTAINER && pouch->flag [FLAG_APPLIED] && pouch->race.contains ("gold"))
                 {
                   int w = at->weight * (100 - pouch->stats.Str) / 100;
                   int n = amount / at->value;
                   if (w == 0)
   new_draw_info_format (NDI_UNIQUE, 0, pl, "You receive %s for %s.",
                         query_cost_string (op, pl, F_SELL | F_SHOP), query_name (op));
   pl->play_sound (sound_find ("shop_sell"));
-  SET_FLAG (op, FLAG_UNPAID);
+  op->set_flag (FLAG_UNPAID);
   identify (op);
   return true;
 }
   /* clear unpaid flag so that doesn't come up in query
    * string.  We clear nrof so that we can better sort
    * the object names.
    */
-  CLEAR_FLAG (tmp, FLAG_UNPAID);
+  tmp->clr_flag (FLAG_UNPAID);
   items[*numitems].nrof = tmp->nrof;
   /* Non mergable items have nrof of 0, but count them as one
    * so the display is properly.
    */
   if (tmp->nrof == 0)
           items[*numitems].item_real = strdup (query_base_name (tmp, 1));
           (*numitems)++;
           break;
     }
-  SET_FLAG (tmp, FLAG_UNPAID);
+  tmp->set_flag (FLAG_UNPAID);
 }
 void
 shop_listing (object *sign, object *op)
 {
   items = (shopinv *)malloc (sizeof (shopinv) * numallocated);
   /* Find all the appropriate items */
   for (i = x1; i <= x2; i++)
     for (j = y1; j < y2; j++)
-      if (is_in_shop (op->map, i, j))
+      if (op->map->is_in_shop (i, j))
         {
           stack = GET_MAP_OB (op->map, i, j);
           while (stack)
             {
-              if (QUERY_FLAG (stack, FLAG_UNPAID))
+              if (stack->flag [FLAG_UNPAID])
                 {
                   if (numitems == numallocated)
                     items = (shopinv *)realloc (items, sizeof (shopinv) * (numallocated *= 2));
                   add_shop_item (stack, items, &numitems, &numallocated);
   op->contr->infobox (MSG_CHANNEL ("shopitems"), buf);
   free (items);
 }
-/* elmex: this function checks whether the object is in a shop */
-bool
-is_in_shop (object *o)
-{
-  if (!o->is_on_map ())
-    return false;
-  return is_in_shop (o->map, o->x, o->y);
-}
 /* elmex: this function checks whether we are in a shop or not
    - change 2007-11-26: enhanced the O(n) case by stopping at the first
      floor tile. this possibly will make map bugs where shopfloors are above
      floors more obvious.
 */
 bool
-is_in_shop (maptile *map, int x, int y)
+maptile::is_in_shop (int x, int y) const
 {
-  for (object *floor = GET_MAP_OB (map, x, y); floor; floor = floor->above)
+  for (object *floor = at (x, y).bot; floor; floor = floor->above)
-    if (QUERY_FLAG (floor, FLAG_IS_FLOOR))
+    if (floor->flag [FLAG_IS_FLOOR])
       return floor->type == SHOP_FLOOR;
   return false;
 }

Diff Legend

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

Comparing deliantra/server/server/shop.C (file contents): Revision 1.76 by root, Fri Mar 26 01:04:45 2010 UTC vs. Revision 1.80 by root, Wed Apr 28 19:01:01 2010 UTC

Diff Legend

Comparing deliantra/server/server/shop.C (file contents):
Revision 1.76 by root, Fri Mar 26 01:04:45 2010 UTC vs.
Revision 1.80 by root, Wed Apr 28 19:01:01 2010 UTC