src/game/AuctionHouseBot.h

   1 #ifndef AUCTION_HOUSE_BOT_H
   2 #define AUCTION_HOUSE_BOT_H
   3 #include "Common.h"
   4 #include "Log.h"
   5 #include "Config/ConfigEnv.h"
   6 #define AHB_GREY        0
   7 #define AHB_WHITE       1
   8 #define AHB_GREEN       2
   9 #define AHB_BLUE        3
  10 #define AHB_PURPLE      4
  11 #define AHB_ORANGE      5
  12 #define AHB_YELLOW      6
  13 #define AHB_GREY_TG     0
  14 #define AHB_WHITE_TG    1
  15 #define AHB_GREEN_TG    2
  16 #define AHB_BLUE_TG     3
  17 #define AHB_PURPLE_TG   4
  18 #define AHB_ORANGE_TG   5
  19 #define AHB_YELLOW_TG   6
  20 #define AHB_GREY_I      7
  21 #define AHB_WHITE_I     8
  22 #define AHB_GREEN_I     9
  23 #define AHB_BLUE_I      10
  24 #define AHB_PURPLE_I    11
  25 #define AHB_ORANGE_I    12
  26 #define AHB_YELLOW_I    13
  27 #define AHBplayerAccount sConfig.GetIntDefault("AuctionHouseBot.Account", 0)
  28 #define AHBplayerGUID sConfig.GetIntDefault("AuctionHouseBot.GUID", 0)
  29 #define ItemsPerCycle sConfig.GetIntDefault("AuctionHouseBot.ItemsPerCycle", 200)
  30 #define SellMethod sConfig.GetIntDefault("AuctionHouseBot.UseBuyPriceForSeller", 1)
  31 #define BuyMethod sConfig.GetIntDefault("AuctionHouseBot.UseBuyPriceForBuyer", 0)
  32
  33 class AHBConfig
  34 {
  35    private:
  36      uint32 AHID;
  37      uint32 AHFID;
  38      uint32 minItems;
  39      uint32 maxItems;
  40      uint32 minTime;
  41      uint32 maxTime;
  42      uint32 percentGreyTradeGoods;
  43      uint32 percentWhiteTradeGoods;
  44      uint32 percentGreenTradeGoods;
  45      uint32 percentBlueTradeGoods;
  46      uint32 percentPurpleTradeGoods;
  47      uint32 percentOrangeTradeGoods;
  48      uint32 percentYellowTradeGoods;
  49      uint32 percentGreyItems;
  50      uint32 percentWhiteItems;
  51      uint32 percentGreenItems;
  52      uint32 percentBlueItems;
  53      uint32 percentPurpleItems;
  54      uint32 percentOrangeItems;
  55      uint32 percentYellowItems;
  56      uint32 minPriceGrey;
  57      uint32 maxPriceGrey;
  58      uint32 minBidPriceGrey;
  59      uint32 maxBidPriceGrey;
  60      uint32 maxStackGrey;
  61      uint32 minPriceWhite;
  62      uint32 maxPriceWhite;
  63      uint32 minBidPriceWhite;
  64      uint32 maxBidPriceWhite;
  65      uint32 maxStackWhite;
  66      uint32 minPriceGreen;
  67      uint32 maxPriceGreen;
  68      uint32 minBidPriceGreen;
  69      uint32 maxBidPriceGreen;
  70      uint32 maxStackGreen;
  71      uint32 minPriceBlue;
  72      uint32 maxPriceBlue;
  73      uint32 minBidPriceBlue;
  74      uint32 maxBidPriceBlue;
  75      uint32 maxStackBlue;
  76      uint32 minPricePurple;
  77      uint32 maxPricePurple;
  78      uint32 minBidPricePurple;
  79      uint32 maxBidPricePurple;
  80      uint32 maxStackPurple;
  81      uint32 minPriceOrange;
  82      uint32 maxPriceOrange;
  83      uint32 minBidPriceOrange;
  84      uint32 maxBidPriceOrange;
  85      uint32 maxStackOrange;
  86      uint32 minPriceYellow;
  87      uint32 maxPriceYellow;
  88      uint32 minBidPriceYellow;
  89      uint32 maxBidPriceYellow;
  90      uint32 maxStackYellow;
  91
  92      uint32 buyerPriceGrey;
  93      uint32 buyerPriceWhite;
  94      uint32 buyerPriceGreen;
  95      uint32 buyerPriceBlue;
  96      uint32 buyerPricePurple;
  97      uint32 buyerPriceOrange;
  98      uint32 buyerPriceYellow;
  99      uint32 buyerBiddingInterval;
 100      uint32 buyerBidsPerInterval;
 101
 102      uint32 greytgp;
 103      uint32 whitetgp;
 104      uint32 greentgp;
 105      uint32 bluetgp;
 106      uint32 purpletgp;
 107      uint32 orangetgp;
 108      uint32 yellowtgp;
 109      uint32 greyip;
 110      uint32 whiteip;
 111      uint32 greenip;
 112      uint32 blueip;
 113      uint32 purpleip;
 114      uint32 orangeip;
 115      uint32 yellowip;
 116     public:
 117     AHBConfig(uint32 ahid)
 118      {
 119          AHID = ahid;
 120          switch(ahid)
 121          {
 122          case 2:
 123              AHFID = 55;
 124              break;
 125          case 6:
 126             AHFID = 29;
 127              break;
 128          case 7:
 129             AHFID = 120;
 130              break;
 131          default:
 132             AHFID = 120;
 133              break;
 134          }
 135      }
 136      AHBConfig()
 137      {
 138      }
 139      uint32 GetAHID()
 140      {
 141          return AHID;
 142      }
 143      uint32 GetAHFID()
 144      {
 145          return AHFID;
 146      }
 147      void SetMinItems(uint32 value)
 148      {
 149              minItems = value;
 150      }
 151      uint32 GetMinItems()
 152      {
 153         if ((minItems  == 0) && (maxItems))
 154             return maxItems;
 155         else if ((maxItems) && (minItems > maxItems))
 156             return maxItems;
 157         else
 158             return minItems;
 159      }
 160      void SetMaxItems(uint32 value)
 161      {
 162              maxItems = value;
 163              CalculatePercents();
 164      }
 165      uint32 GetMaxItems()
 166      {
 167         return maxItems;
 168      }
 169      void SetMinTime(uint32 value)
 170      {
 171          minTime = value;
 172      }
 173      uint32 GetMinTime()
 174      {
 175         if (minTime < 1)
 176           return 1;
 177         else if ((maxTime) && (minTime > maxTime))
 178             return maxTime;
 179         else
 180             return minTime;
 181      }
 182      void SetMaxTime(uint32 value)
 183      {
 184          maxTime = value;
 185      }
 186      uint32 GetMaxTime()
 187      {
 188         return maxTime;
 189      }
 190      void SetPercentages(uint32 greytg, uint32 whitetg, uint32 greentg, uint32 bluetg, uint32 purpletg, uint32 orangetg, uint32 yellowtg, uint32 greyi, uint32 whitei, uint32 greeni, uint32 bluei, uint32 purplei, uint32 orangei, uint32 yellowi)
 191      {
 192         uint32 totalPercent = greytg + whitetg + greentg + bluetg + purpletg + orangetg + yellowtg + greyi + whitei + greeni + bluei + purplei + orangei + yellowi;
 193
 194         if (totalPercent == 0)
 195         {
 196           maxItems = 0;
 197         }
 198         else if (totalPercent != 100)
 199         {
 200             greytg = 0;
 201             whitetg = 27;
 202             greentg = 12;
 203             bluetg = 10;
 204             purpletg = 1;
 205             orangetg = 0;
 206             yellowtg = 0;
 207             greyi = 0;
 208             whitei = 10;
 209             greeni = 30;
 210             bluei = 8;
 211             purplei = 2;
 212             orangei = 0;
 213             yellowi = 0;
 214         }
 215         percentGreyTradeGoods = greytg;
 216         percentWhiteTradeGoods = whitetg;
 217         percentGreenTradeGoods = greentg;
 218         percentBlueTradeGoods = bluetg;
 219         percentPurpleTradeGoods = purpletg;
 220         percentOrangeTradeGoods = orangetg;
 221         percentYellowTradeGoods = yellowtg;
 222         percentGreyItems = greyi;
 223         percentWhiteItems = whitei;
 224         percentGreenItems = greeni;
 225         percentBlueItems = bluei;
 226         percentPurpleItems = purplei;
 227         percentOrangeItems = orangei;
 228         percentYellowItems = yellowi;
 229         CalculatePercents();
 230      }
 231      uint32 GetPercentages(uint32 color)
 232      {
 233          switch(color)
 234          {
 235          case AHB_GREY_TG:
 236             return percentGreyTradeGoods;
 237              break;
 238          case AHB_WHITE_TG:
 239             return percentWhiteTradeGoods;
 240              break;
 241          case AHB_GREEN_TG:
 242             return percentGreenTradeGoods;
 243              break;
 244          case AHB_BLUE_TG:
 245             return percentBlueTradeGoods;
 246              break;
 247          case AHB_PURPLE_TG:
 248             return percentPurpleTradeGoods;
 249              break;
 250          case AHB_ORANGE_TG:
 251             return percentOrangeTradeGoods;
 252              break;
 253          case AHB_YELLOW_TG:
 254             return percentYellowTradeGoods;
 255              break;
 256          case AHB_GREY_I:
 257             return percentGreyItems;
 258              break;
 259          case AHB_WHITE_I:
 260             return percentWhiteItems;
 261              break;
 262          case AHB_GREEN_I:
 263             return percentGreenItems;
 264              break;
 265          case AHB_BLUE_I:
 266             return percentBlueItems;
 267              break;
 268          case AHB_PURPLE_I:
 269             return percentPurpleItems;
 270              break;
 271          case AHB_ORANGE_I:
 272             return percentOrangeItems;
 273              break;
 274          case AHB_YELLOW_I:
 275             return percentYellowItems;
 276              break;
 277          default:
 278             return 0;
 279              break;
 280          }
 281      }
 282      void SetMinPrice(uint32 color, uint32 value)
 283      {
 284          switch(color)
 285          {
 286          case AHB_GREY:
 287             minPriceGrey = value;
 288              break;
 289          case AHB_WHITE:
 290             minPriceWhite = value;
 291              break;
 292          case AHB_GREEN:
 293             minPriceGreen = value;
 294              break;
 295          case AHB_BLUE:
 296             minPriceBlue = value;
 297              break;
 298          case AHB_PURPLE:
 299             minPricePurple = value;
 300              break;
 301          case AHB_ORANGE:
 302             minPriceOrange = value;
 303              break;
 304          case AHB_YELLOW:
 305             minPriceYellow = value;
 306              break;
 307          default:
 308              break;
 309          }
 310      }
 311      uint32 GetMinPrice(uint32 color)
 312      {
 313          switch(color)
 314          {
 315          case AHB_GREY:
 316             {
 317                 if (minPriceGrey == 0)
 318                     return 100;
 319                 else if (minPriceGrey > maxPriceGrey)
 320                     return maxPriceGrey;
 321                 else
 322                     return minPriceGrey;
 323                 break;
 324             }
 325          case AHB_WHITE:
 326             {
 327                 if (minPriceWhite == 0)
 328                     return 150;
 329                 else if (minPriceWhite > maxPriceWhite)
 330                     return maxPriceWhite;
 331                 else
 332                     return minPriceWhite;
 333                 break;
 334             }
 335          case AHB_GREEN:
 336             {
 337                 if (minPriceGreen == 0)
 338                     return 200;
 339                 else if (minPriceGreen > maxPriceGreen)
 340                     return maxPriceGreen;
 341                 else
 342                     return minPriceGreen;
 343                 break;
 344             }
 345          case AHB_BLUE:
 346             {
 347                 if (minPriceBlue == 0)
 348                     return 250;
 349                 else if (minPriceBlue > maxPriceBlue)
 350                     return maxPriceBlue;
 351                 else
 352                     return minPriceBlue;
 353                 break;
 354             }
 355          case AHB_PURPLE:
 356             {
 357                 if (minPricePurple == 0)
 358                     return 300;
 359                 else if (minPricePurple > maxPricePurple)
 360                     return maxPricePurple;
 361                 else
 362                     return minPricePurple;
 363                 break;
 364             }
 365          case AHB_ORANGE:
 366             {
 367                 if (minPriceOrange == 0)
 368                     return 400;
 369                 else if (minPriceOrange > maxPriceOrange)
 370                     return maxPriceOrange;
 371                 else
 372                     return minPriceOrange;
 373                 break;
 374             }
 375          case AHB_YELLOW:
 376             {
 377                 if (minPriceYellow == 0)
 378                     return 500;
 379                 else if (minPriceYellow > maxPriceYellow)
 380                     return maxPriceYellow;
 381                 else
 382                     return minPriceYellow;
 383                 break;
 384             }
 385          default:
 386              {
 387                  return 0;
 388                  break;
 389              }
 390         }
 391      }
 392      void SetMaxPrice(uint32 color, uint32 value)
 393      {
 394          switch(color)
 395          {
 396          case AHB_GREY:
 397             maxPriceGrey = value;
 398              break;
 399          case AHB_WHITE:
 400             maxPriceWhite = value;
 401              break;
 402          case AHB_GREEN:
 403             maxPriceGreen = value;
 404              break;
 405          case AHB_BLUE:
 406             maxPriceBlue = value;
 407              break;
 408          case AHB_PURPLE:
 409             maxPricePurple = value;
 410              break;
 411          case AHB_ORANGE:
 412             maxPriceOrange = value;
 413              break;
 414          case AHB_YELLOW:
 415             maxPriceYellow = value;
 416              break;
 417          default:
 418              break;
 419          }
 420      }
 421      uint32 GetMaxPrice(uint32 color)
 422      {
 423          switch(color)
 424          {
 425          case AHB_GREY:
 426             {
 427                 if (maxPriceGrey == 0)
 428                     return 150;
 429                 else
 430                     return maxPriceGrey;
 431                 break;
 432             }
 433          case AHB_WHITE:
 434             {
 435                 if (maxPriceWhite == 0)
 436                     return 250;
 437                 else
 438                     return maxPriceWhite;
 439                 break;
 440             }
 441          case AHB_GREEN:
 442             {
 443                 if (maxPriceGreen == 0)
 444                     return 300;
 445                 else
 446                     return maxPriceGreen;
 447                 break;
 448             }
 449          case AHB_BLUE:
 450             {
 451                 if (maxPriceBlue == 0)
 452                     return 350;
 453                 else
 454                     return maxPriceBlue;
 455                 break;
 456             }
 457          case AHB_PURPLE:
 458             {
 459                 if (maxPricePurple == 0)
 460                     return 450;
 461                 else
 462                     return maxPricePurple;
 463                 break;
 464             }
 465          case AHB_ORANGE:
 466             {
 467                 if (maxPriceOrange == 0)
 468                     return 550;
 469                 else
 470                     return maxPriceOrange;
 471                 break;
 472             }
 473          case AHB_YELLOW:
 474             {
 475                 if (maxPriceYellow == 0)
 476                     return 650;
 477                 else
 478                     return maxPriceYellow;
 479                 break;
 480             }
 481          default:
 482              {
 483                  return 0;
 484                  break;
 485              }
 486         }
 487      }
 488      void SetMinBidPrice(uint32 color, uint32 value)
 489      {
 490          switch(color)
 491          {
 492          case AHB_GREY:
 493             minBidPriceGrey = value;
 494              break;
 495          case AHB_WHITE:
 496             minBidPriceWhite = value;
 497              break;
 498          case AHB_GREEN:
 499             minBidPriceGreen = value;
 500              break;
 501          case AHB_BLUE:
 502             minBidPriceBlue = value;
 503              break;
 504          case AHB_PURPLE:
 505             minBidPricePurple = value;
 506              break;
 507          case AHB_ORANGE:
 508             minBidPriceOrange = value;
 509              break;
 510          case AHB_YELLOW:
 511             minBidPriceYellow = value;
 512              break;
 513          default:
 514              break;
 515          }
 516      }
 517      uint32 GetMinBidPrice(uint32 color)
 518      {
 519          switch(color)
 520          {
 521          case AHB_GREY:
 522             {
 523                 if (minBidPriceGrey > 100)
 524                     return 100;
 525                 else
 526                     return minBidPriceGrey;
 527                 break;
 528             }
 529          case AHB_WHITE:
 530             {
 531                 if (minBidPriceWhite > 100)
 532                     return 100;
 533                 else
 534                     return minBidPriceWhite;
 535                 break;
 536             }
 537          case AHB_GREEN:
 538             {
 539                 if (minBidPriceGreen > 100)
 540                     return 100;
 541                 else
 542                     return minBidPriceGreen;
 543                 break;
 544             }
 545          case AHB_BLUE:
 546             {
 547                 if (minBidPriceBlue > 100)
 548                     return 100;
 549                 else
 550                     return minBidPriceBlue;
 551                 break;
 552             }
 553          case AHB_PURPLE:
 554             {
 555                 if (minBidPricePurple > 100)
 556                     return 100;
 557                 else
 558                     return minBidPricePurple;
 559                 break;
 560             }
 561          case AHB_ORANGE:
 562             {
 563                 if (minBidPriceOrange > 100)
 564                     return 100;
 565                 else
 566                     return minBidPriceOrange;
 567                 break;
 568             }
 569          case AHB_YELLOW:
 570             {
 571                 if (minBidPriceYellow > 100)
 572                     return 100;
 573                 else
 574                     return minBidPriceYellow;
 575                 break;
 576             }
 577          default:
 578              {
 579                  return 0;
 580                  break;
 581              }
 582          }
 583      }
 584      void SetMaxBidPrice(uint32 color, uint32 value)
 585      {
 586          switch(color)
 587          {
 588          case AHB_GREY:
 589             maxBidPriceGrey = value;
 590              break;
 591          case AHB_WHITE:
 592             maxBidPriceWhite = value;
 593              break;
 594          case AHB_GREEN:
 595             maxBidPriceGreen = value;
 596              break;
 597          case AHB_BLUE:
 598             maxBidPriceBlue = value;
 599              break;
 600          case AHB_PURPLE:
 601             maxBidPricePurple = value;
 602              break;
 603          case AHB_ORANGE:
 604             maxBidPriceOrange = value;
 605              break;
 606          case AHB_YELLOW:
 607             maxBidPriceYellow = value;
 608              break;
 609          default:
 610              break;
 611          }
 612      }
 613      uint32 GetMaxBidPrice(uint32 color)
 614      {
 615          switch(color)
 616          {
 617          case AHB_GREY:
 618             {
 619                 if (maxBidPriceGrey > 100)
 620                     return 100;
 621                 else
 622                     return maxBidPriceGrey;
 623                 break;
 624             }
 625          case AHB_WHITE:
 626             {
 627                 if (maxBidPriceWhite > 100)
 628                     return 100;
 629                 else
 630                     return maxBidPriceWhite;
 631                 break;
 632             }
 633          case AHB_GREEN:
 634             {
 635                 if (maxBidPriceGreen > 100)
 636                     return 100;
 637                 else
 638                     return maxBidPriceGreen;
 639                 break;
 640             }
 641          case AHB_BLUE:
 642             {
 643                 if (maxBidPriceBlue > 100)
 644                     return 100;
 645                 else
 646                     return maxBidPriceBlue;
 647                 break;
 648             }
 649          case AHB_PURPLE:
 650             {
 651                 if (maxBidPricePurple > 100)
 652                     return 100;
 653                 else
 654                     return maxBidPricePurple;
 655                 break;
 656             }
 657          case AHB_ORANGE:
 658             {
 659                 if (maxBidPriceOrange > 100)
 660                     return 100;
 661                 else
 662                     return maxBidPriceOrange;
 663                 break;
 664             }
 665          case AHB_YELLOW:
 666             {
 667                 if (maxBidPriceYellow > 100)
 668                     return 100;
 669                 else
 670                     return maxBidPriceYellow;
 671                 break;
 672             }
 673          default:
 674              {
 675                  return 0;
 676                  break;
 677              }
 678          }
 679      }
 680      void SetMaxStack(uint32 color, uint32 value)
 681      {
 682          switch(color)
 683          {
 684          case AHB_GREY:
 685             maxStackGrey = value;
 686              break;
 687          case AHB_WHITE:
 688             maxStackWhite = value;
 689              break;
 690          case AHB_GREEN:
 691             maxStackGreen = value;
 692              break;
 693          case AHB_BLUE:
 694             maxStackBlue = value;
 695              break;
 696          case AHB_PURPLE:
 697             maxStackPurple = value;
 698              break;
 699          case AHB_ORANGE:
 700             maxStackOrange = value;
 701              break;
 702          case AHB_YELLOW:
 703             maxStackYellow = value;
 704              break;
 705          default:
 706              break;
 707          }
 708      }
 709      uint32 GetMaxStack(uint32 color)
 710      {
 711          switch(color)
 712          {
 713          case AHB_GREY:
 714             {
 715                 return maxStackGrey;
 716                 break;
 717             }
 718          case AHB_WHITE:
 719             {
 720                 return maxStackWhite;
 721                 break;
 722             }
 723          case AHB_GREEN:
 724             {
 725                 return maxStackGreen;
 726                 break;
 727             }
 728          case AHB_BLUE:
 729             {
 730                 return maxStackBlue;
 731                 break;
 732             }
 733          case AHB_PURPLE:
 734             {
 735                 return maxStackPurple;
 736                 break;
 737             }
 738          case AHB_ORANGE:
 739             {
 740                 return maxStackOrange;
 741                 break;
 742             }
 743          case AHB_YELLOW:
 744             {
 745                 return maxStackYellow;
 746                 break;
 747             }
 748          default:
 749              {
 750                  return 0;
 751                  break;
 752              }
 753          }
 754      }
 755      void SetBuyerPrice(uint32 color, uint32 value)
 756      {
 757          switch(color)
 758          {
 759          case AHB_GREY:
 760             buyerPriceGrey = value;
 761              break;
 762          case AHB_WHITE:
 763             buyerPriceWhite = value;
 764              break;
 765          case AHB_GREEN:
 766             buyerPriceGreen = value;
 767              break;
 768          case AHB_BLUE:
 769             buyerPriceBlue = value;
 770              break;
 771          case AHB_PURPLE:
 772             buyerPricePurple = value;
 773              break;
 774          case AHB_ORANGE:
 775             buyerPriceOrange = value;
 776              break;
 777          case AHB_YELLOW:
 778             buyerPriceYellow = value;
 779              break;
 780          default:
 781              break;
 782          }
 783      }
 784      uint32 GetBuyerPrice(uint32 color)
 785      {
 786          switch(color)
 787          {
 788          case AHB_GREY:
 789             return buyerPriceGrey;
 790              break;
 791          case AHB_WHITE:
 792             return buyerPriceWhite;
 793              break;
 794          case AHB_GREEN:
 795             return buyerPriceGreen;
 796              break;
 797          case AHB_BLUE:
 798             return buyerPriceBlue;
 799              break;
 800          case AHB_PURPLE:
 801             return buyerPricePurple;
 802              break;
 803          case AHB_ORANGE:
 804             return buyerPriceOrange;
 805              break;
 806          case AHB_YELLOW:
 807             return buyerPriceYellow;
 808              break;
 809          default:
 810              return 0;
 811              break;
 812          }
 813      }
 814      void SetBiddingInterval(uint32 value)
 815      {
 816          buyerBiddingInterval = value;
 817      }
 818      uint32 GetBiddingInterval()
 819      {
 820          return buyerBiddingInterval;
 821      }
 822      void CalculatePercents()
 823      {
 824         greytgp = (uint32) (((double)percentGreyTradeGoods / 100.0) * maxItems);
 825         whitetgp = (uint32) (((double)percentWhiteTradeGoods / 100.0) * maxItems);
 826         greentgp = (uint32) (((double)percentGreenTradeGoods / 100.0) * maxItems);
 827         bluetgp = (uint32) (((double)percentBlueTradeGoods / 100.0) * maxItems);
 828         purpletgp = (uint32) (((double)percentPurpleTradeGoods / 100.0) * maxItems);
 829         orangetgp = (uint32) (((double)percentOrangeTradeGoods / 100.0) * maxItems);
 830         yellowtgp = (uint32) (((double)percentYellowTradeGoods / 100.0) * maxItems);
 831         greyip = (uint32) (((double)percentGreyItems / 100.0) * maxItems);
 832         whiteip = (uint32) (((double)percentWhiteItems / 100.0) * maxItems);
 833         greenip = (uint32) (((double)percentGreenItems / 100.0) * maxItems);
 834         blueip = (uint32) (((double)percentBlueItems / 100.0) * maxItems);
 835         purpleip = (uint32) (((double)percentPurpleItems / 100.0) * maxItems);
 836         orangeip = (uint32) (((double)percentOrangeItems / 100.0) * maxItems);
 837         yellowip = (uint32) (((double)percentYellowItems / 100.0) * maxItems);
 838         uint32 total = greytgp + whitetgp + greentgp + bluetgp + purpletgp + orangetgp + yellowtgp + greyip + whiteip + greenip + blueip + purpleip + orangeip + yellowip;
 839         int32 diff = (maxItems - total);
 840         if (diff < 0)
 841         {
 842             if ((whiteip - diff) > 0)
 843                 whiteip -= diff;
 844             else if ((greenip - diff) > 0)
 845                 greenip -= diff;
 846         }
 847         else if (diff < 0)
 848         {
 849             whiteip += diff;
 850         }
 851      }
 852      uint32 GetPercents(uint32 color)
 853      {
 854          switch(color)
 855          {
 856          case AHB_GREY_TG:
 857             return greytgp;
 858              break;
 859          case AHB_WHITE_TG:
 860             return whitetgp;
 861              break;
 862          case AHB_GREEN_TG:
 863             return greentgp;
 864              break;
 865          case AHB_BLUE_TG:
 866             return bluetgp;
 867              break;
 868          case AHB_PURPLE_TG:
 869             return purpletgp;
 870              break;
 871          case AHB_ORANGE_TG:
 872             return orangetgp;
 873              break;
 874          case AHB_YELLOW_TG:
 875             return yellowtgp;
 876              break;
 877          case AHB_GREY_I:
 878              return greyip;
 879              break;
 880          case AHB_WHITE_I:
 881             return whiteip;
 882              break;
 883          case AHB_GREEN_I:
 884             return greenip;
 885              break;
 886          case AHB_BLUE_I:
 887             return blueip;
 888              break;
 889          case AHB_PURPLE_I:
 890             return purpleip;
 891              break;
 892          case AHB_ORANGE_I:
 893             return orangeip;
 894              break;
 895          case AHB_YELLOW_I:
 896             return yellowip;
 897              break;
 898          default:
 899              return 0;
 900              break;
 901          }
 902      }
 903      void SetBidsPerInterval(uint32 value)
 904      {
 905          buyerBidsPerInterval = value;
 906      }
 907      uint32 GetBidsPerInterval()
 908      {
 909          return buyerBidsPerInterval;
 910      }
 911    ~AHBConfig()
 912    {
 913    }
 914 };
 915 void AuctionHouseBot();
 916 void AuctionHouseBotInit();
 917 void AuctionHouseBotLoadValues(AHBConfig*);
 918 void AuctionHouseBotCommands(uint32, uint32, uint32, char*);
 919 #endif