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

Comparing deliantra/server/server/shop.C (file contents):
Revision 1.85 by elmex, Wed May 5 09:42:52 2010 UTC vs.
Revision 1.95 by root, Sat Nov 17 23:40:04 2018 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>
  */
 #include <global.h>
 #include <spells.h>
 #include <sproto.h>
 /* this is a measure of how effective store specialisation is. A general store
  * will offer this proportion of the 'maximum' price, a specialised store will
  * offer a range of prices around it such that the maximum price is always one
  * therefore making this number higher, makes specialisation less effective.
  * setting this value above 1 or to a negative value would have interesting,
  * (though not useful) effects.
  */
 #define SPECIALISATION_EFFECT .5
  * would not be done.
  *
  * Added F_APPROX flag, which means that the price returned should be wrong by
  * an amount related to the player's bargaining skill.
  *
  * Added F_SHOP flag to mean that the specialisation of the shop on the player's
  * current map should be taken into account when determining the price. Shops that
  * specialise in what is being traded will give better prices than those that do not.
  *
  * CF 0.91.4 - This function got changed around a bit.  Now the
  * number of object is multiplied by the value early on.  This fixes problems
  * with items worth very little.  What happened before is that various
  * divisions took place, the value got rounded to 0 (Being an int), and
     {
       if (flag == F_SELL)
         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
            * the shop. If a player sold an item here, then his sale price was
            * multiplied by the specialisation ratio, to do the same to the buy
            * price will not generate extra money. However, the
            * same is not true of generated items, these have to /divide/ by the
            * specialisation, so that the price is never less than what they could
            * 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 (tmp->flag [FLAG_PLAYER_SOLD])
             val *= shop_specialisation_ratio (tmp, who->map);
           else
             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 *= 1 + .05f * cosf ((tmp->uuid.seq & 0xffff) * M_PI * 2. / 0x10000);
     }
   for (tmp = op->inv; tmp; tmp = tmp->below)
     if (tmp->type == MONEY)
       total += tmp->nrof * (sint64)tmp->value;
-    else if (tmp->type == CONTAINER && tmp->flag [FLAG_APPLIED] && (!tmp->race || tmp->race.contains ("gold")))
+    else if (tmp->type == CONTAINER && tmp->flag [FLAG_APPLIED] && (!tmp->race || tmp->race.contains (shstr_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 && pouch->flag [FLAG_APPLIED] && (!pouch->race || pouch->race.contains ("gold")))
+    if (pouch->type == CONTAINER && pouch->flag [FLAG_APPLIED] && (!pouch->race || pouch->race.contains (shstr_gold)))
       pay_from_container (pl, pouch, to_pay);
   pl->update_stats ();
   return 1;
 }
     change_exp (pl, saved_money, shstr_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 && pouch->flag [FLAG_APPLIED] && (!pouch->race || pouch->race.contains ("gold")))
+    if (pouch->type == CONTAINER && pouch->flag [FLAG_APPLIED] && (!pouch->race || pouch->race.contains (shstr_gold)))
       pay_from_container (pl, pouch, to_pay);
   pl->update_stats ();
   return 1;
       coin_objs[i]->destroy ();
 }
 /* Checks all unpaid items in op's inventory, adds up all the money they
  * have, and checks that they can actually afford what they want to buy.
  * Returns 1 if they can, and 0 if they can't. also prints an appropriate message
  * to the player
  */
 int
 can_pay (object *pl)
 {
 void
 pay_player (object *pl, sint64 amount)
 {
   int count = 0;
   archetype *at = 0;
-  object *pouch = 0, *tmp = 0;
+  object *pouch = 0;
   for (count = 0; coins[count]; count++)
     {
       at = archetype::find (coins[count]);
         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 && pouch->flag [FLAG_APPLIED] && pouch->race.contains ("gold"))
+              if (pouch->type == CONTAINER && pouch->flag [FLAG_APPLIED] && pouch->race.contains (shstr_gold))
                 {
                   int w = at->weight * (100 - pouch->stats.Str) / 100;
                   int n = amount / at->value;
                   if (w == 0)
   return true;
 }
 /* returns a double that is the ratio of the price that a shop will offer for
  * item based on the shops specialisation. Does not take account of greed,
  * returned value is between SPECIALISATION_EFFECT and 1.
  */
 static double
 shop_specialisation_ratio (const object *item, const maptile *map)
 {
       return 0;
     }
   if (!item->type)
     {
-      LOG (llevError, "shop_specialisation_ratio: passed an item with an invalid type\n");
+      LOG (llevError, "shop_specialisation_ratio: passed an item with an invalid type: %s\n", item->debug_desc ());
       /*
        * I'm not really sure what the /right/ thing to do here is, these types of
        * item shouldn't exist anyway, but returning the ratio is probably the best bet.."
        */
       return SPECIALISATION_EFFECT;
     }
   if (map->shopitems)
       if (items[i].typenum == item->type || (!items[i].typenum && !likedness))
         likedness = items[i].strength;
   if (likedness > 100)
     {                           /* someone has been rather silly with the map headers. */
-      LOG (llevDebug, "shop_specialisation ratio: item type %d on map %s is above 100%%\n", item->type, &map->path);
+      LOG (llevDebug, "shop_specialisation ratio: item %s on map %s is above 100%%\n", item->debug_desc (), &map->path);
       likedness = 100;
     }
   if (likedness < -100)
     {
-      LOG (llevDebug, "shop_specialisation ratio: item type %d on map %s is below -100%%\n", item->type, &map->path);
+      LOG (llevDebug, "shop_specialisation ratio: item %s on map %s is below -100%%\n", item->debug_desc (), &map->path);
       likedness = -100;
     }
   return lerp (double (likedness), -100., 100., SPECIALISATION_EFFECT, 1.);
 }
      ? DISLIKE_RATIO
      : 1.;
 }
 /* limit the value of items based on the wealth of the shop. If the item is close
  * to the maximum value a shop will offer, we start to reduce it, if the item is
  * below the minimum value the shop is prepared to trade in, then we don't
  * want it and offer nothing. If it isn't a shop, check whether we should do generic
  * value reduction.
  *
  */
 static sint64
 value_limit (sint64 val, int quantity, const object *who, int isshop)
 {
   sint64 newval, unit_price, tmpshopmax;
 {
   dynbuf_text buf;
   maptile *map = op->map;
   /*shopitems *items=map->shopitems; */
-  int pos = 0, i;
+  int i;
   double opinion = 0;
   if (op->type != PLAYER)
     return 0;
 void
 shop_listing (object *sign, object *op)
 {
   int i, j, x1, x2, y1, y2;
-  const char *shop_coords = sign->kv (shstr_shop_coords);
+  const char *shop_coords = sign->kv [shstr_shop_coords];
   object *stack;
   shopinv *items;
   /* Should never happen, but just in case a monster does apply a sign */
   if (!op->is_player ())

Diff Legend

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

Comparing deliantra/server/server/shop.C (file contents): Revision 1.85 by elmex, Wed May 5 09:42:52 2010 UTC vs. Revision 1.95 by root, Sat Nov 17 23:40:04 2018 UTC

Diff Legend

Comparing deliantra/server/server/shop.C (file contents):
Revision 1.85 by elmex, Wed May 5 09:42:52 2010 UTC vs.
Revision 1.95 by root, Sat Nov 17 23:40:04 2018 UTC