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_GREY_TG             0
  12 #define AHB_WHITE_TG    1
  13 #define AHB_GREEN_TG    2
  14 #define AHB_BLUE_TG             3
  15 #define AHB_PURPLE_TG   4
  16 #define AHB_GREY_I              5
  17 #define AHB_WHITE_I             6
  18 #define AHB_GREEN_I             7
  19 #define AHB_BLUE_I              8
  20 #define AHB_PURPLE_I    9
  21 #define AHBplayerAccount sConfig.GetIntDefault("AuctionHouseBot.Account", 0)
  22 #define AHBplayerGUID sConfig.GetIntDefault("AuctionHouseBot.GUID", 0)
  23 #define ItemsPerCycle sConfig.GetIntDefault("AuctionHouseBot.ItemsPerCycle", 200)
  24
  25 class AHBConfig
  26 {
  27    private:
  28      uint32 AHID;
  29          uint32 minItems;
  30          uint32 maxItems;
  31          uint32 minTime;
  32          uint32 maxTime;
  33          uint32 percentWhiteTradeGoods;
  34          uint32 percentGreenTradeGoods;
  35          uint32 percentBlueTradeGoods;
  36          uint32 percentPurpleTradeGoods;
  37          uint32 percentWhiteItems;
  38          uint32 percentGreenItems;
  39          uint32 percentBlueItems;
  40          uint32 percentPurpleItems;
  41          uint32 minPriceWhite;
  42          uint32 maxPriceWhite;
  43          uint32 minBidPriceWhite;
  44          uint32 maxBidPriceWhite;
  45          uint32 maxStackWhite;
  46          uint32 minPriceGreen;
  47          uint32 maxPriceGreen;
  48          uint32 minBidPriceGreen;
  49          uint32 maxBidPriceGreen;
  50          uint32 maxStackGreen;
  51          uint32 minPriceBlue;
  52          uint32 maxPriceBlue;
  53          uint32 minBidPriceBlue;
  54          uint32 maxBidPriceBlue;
  55          uint32 maxStackBlue;
  56          uint32 minPricePurple;
  57          uint32 maxPricePurple;
  58          uint32 minBidPricePurple;
  59          uint32 maxBidPricePurple;
  60          uint32 maxStackPurple;
  61
  62          uint32 buyerPriceGrey;
  63          uint32 buyerPriceWhite;
  64          uint32 buyerPriceGreen;
  65          uint32 buyerPriceBlue;
  66          uint32 buyerPricePurple;
  67          uint32 buyerBiddingInterval;
  68          uint32 buyerBidsPerInterval;
  69
  70          uint32 wtgp;
  71          uint32 gtgp;
  72          uint32 btgp;
  73          uint32 ptgp;
  74          uint32 wip;
  75          uint32 gip;
  76          uint32 bip;
  77          uint32 pip;
  78     public:
  79     AHBConfig(uint32 ahid)
  80      {
  81                  AHID = ahid;
  82      }
  83      AHBConfig()
  84      {
  85      }
  86          uint32 GetAHID()
  87          {
  88                  return AHID;
  89          }
  90          void SetMinItems(uint32 value)
  91          {
  92                          minItems = value;
  93          }
  94          uint32 GetMinItems()
  95          {
  96                 if ((minItems  == 0) && (maxItems))
  97                         return maxItems;
  98                 else if ((maxItems) && (minItems > maxItems))
  99                         return maxItems;
 100                 else
 101                         return minItems;
 102          }
 103          void SetMaxItems(uint32 value)
 104          {
 105                          maxItems = value;
 106                          CalculatePercents();
 107          }
 108          uint32 GetMaxItems()
 109          {
 110                 return maxItems;
 111          }
 112          void SetMinTime(uint32 value)
 113          {
 114                  minTime = value;
 115          }
 116          uint32 GetMinTime()
 117          {
 118                 if (minTime < 1)
 119                   return 1;
 120                 else if ((maxTime) && (minTime > maxTime))
 121                         return maxTime;
 122                 else
 123                         return minTime;
 124          }
 125          void SetMaxTime(uint32 value)
 126          {
 127                  maxTime = value;
 128          }
 129          uint32 GetMaxTime()
 130          {
 131                 return maxTime;
 132          }
 133          void SetPercentages(uint32 wtg, uint32 gtg, uint32 btg, uint32 ptg, uint32 wi, uint32 gi, uint32 bi, uint32 pi)
 134          {
 135                 uint32 totalPercent = wtg + gtg + btg + ptg + wi + gi + bi + pi;
 136
 137                 if (totalPercent == 0)
 138                 {
 139                   maxItems = 0;
 140                 }
 141                 else if (totalPercent != 100)
 142                 {
 143                   double scale = (double) 100 / (double) totalPercent;
 144
 145                   wtg = (uint32) (scale * (double) pi);
 146                   gtg = (uint32) (scale * (double) gtg);
 147                   btg = (uint32) (scale * (double) btg);
 148                   ptg = (uint32) (scale * (double) ptg);
 149                   wi = (uint32) (scale * (double) wi);
 150                   gi = (uint32) (scale * (double) gi);
 151                   bi = (uint32) (scale * (double) bi);
 152                   pi = 100 - wtg - gtg - btg - ptg - wi - gi - bi;
 153
 154                 }
 155                 percentWhiteTradeGoods = wtg;
 156                 percentGreenTradeGoods = gtg;
 157                 percentBlueTradeGoods = btg;
 158                 percentPurpleTradeGoods = ptg;
 159                 percentWhiteItems = wi;
 160                 percentGreenItems = gi;
 161                 percentBlueItems = bi;
 162                 percentPurpleItems = pi;
 163                 CalculatePercents();
 164          }
 165          uint32 GetPercentages(uint32 color)
 166          {
 167                  switch(color)
 168                  {
 169                  case AHB_GREY_TG:
 170                          return 0;
 171                          break;
 172                  case AHB_WHITE_TG:
 173                         return percentWhiteTradeGoods;
 174                          break;
 175                  case AHB_GREEN_TG:
 176                         return percentGreenTradeGoods;
 177                          break;
 178                  case AHB_BLUE_TG:
 179                         return percentBlueTradeGoods;
 180                          break;
 181                  case AHB_PURPLE_TG:
 182                         return percentPurpleTradeGoods;
 183                          break;
 184                  case AHB_GREY_I:
 185                         return 0;
 186                          break;
 187                  case AHB_WHITE_I:
 188                         return percentWhiteItems;
 189                          break;
 190                  case AHB_GREEN_I:
 191                         return percentGreenItems;
 192                          break;
 193                  case AHB_BLUE_I:
 194                         return percentBlueItems;
 195                          break;
 196                  case AHB_PURPLE_I:
 197                         return percentPurpleItems;
 198                          break;
 199                  default:
 200                         return 0;
 201                          break;
 202                  }
 203          }
 204          void SetMinPrice(uint32 color, uint32 value)
 205          {
 206                  switch(color)
 207                  {
 208                  case AHB_GREY:
 209                          break;
 210                  case AHB_WHITE:
 211                         minPriceWhite = value;
 212                          break;
 213                  case AHB_GREEN:
 214                         minPriceGreen = value;
 215                          break;
 216                  case AHB_BLUE:
 217                         minPriceBlue = value;
 218                          break;
 219                  case AHB_PURPLE:
 220                         minPricePurple = value;
 221                          break;
 222                  default:
 223                          break;
 224                  }
 225          }
 226          uint32 GetMinPrice(uint32 color)
 227          {
 228                  switch(color)
 229                  {
 230                  case AHB_GREY:
 231                         {
 232                                 return 0;
 233                                 break;
 234                         }
 235                  case AHB_WHITE:
 236                         {
 237                                 if (minPriceWhite == 0)
 238                                         return 150;
 239                                 else if (minPriceWhite > maxPriceWhite)
 240                                         return maxPriceWhite;
 241                                 else
 242                                         return minPriceWhite;
 243                                 break;
 244                         }
 245                  case AHB_GREEN:
 246                         {
 247                                 if (minPriceGreen == 0)
 248                                         return 200;
 249                                 else if (minPriceGreen > maxPriceGreen)
 250                                         return maxPriceGreen;
 251                                 else
 252                                         return minPriceGreen;
 253                                 break;
 254                         }
 255                  case AHB_BLUE:
 256                         {
 257                                 if (minPriceBlue == 0)
 258                                         return 250;
 259                                 else if (minPriceBlue > maxPriceBlue)
 260                                         return maxPriceBlue;
 261                                 else
 262                                         return minPriceBlue;
 263                                 break;
 264                         }
 265                  case AHB_PURPLE:
 266                         {
 267                                 if (minPricePurple == 0)
 268                                         return 300;
 269                                 else if (minPricePurple > maxPricePurple)
 270                                         return maxPricePurple;
 271                                 else
 272                                         return minPricePurple;
 273                                 break;
 274                         }
 275                  default:
 276                          {
 277                                  return 0;
 278                                  break;
 279                          }
 280                 }
 281          }
 282          void SetMaxPrice(uint32 color, uint32 value)
 283          {
 284                  switch(color)
 285                  {
 286                  case AHB_GREY:
 287                          break;
 288                  case AHB_WHITE:
 289                         maxPriceWhite = value;
 290                          break;
 291                  case AHB_GREEN:
 292                         maxPriceGreen = value;
 293                          break;
 294                  case AHB_BLUE:
 295                         maxPriceBlue = value;
 296                          break;
 297                  case AHB_PURPLE:
 298                         maxPricePurple = value;
 299                          break;
 300                  default:
 301                          break;
 302                  }
 303          }
 304          uint32 GetMaxPrice(uint32 color)
 305          {
 306                  switch(color)
 307                  {
 308                  case AHB_GREY:
 309                         {
 310                                 return 0;
 311                                 break;
 312                         }
 313                  case AHB_WHITE:
 314                         {
 315                                 if (maxPriceWhite == 0)
 316                                         return 250;
 317                                 else
 318                                         return maxPriceWhite;
 319                                 break;
 320                         }
 321                  case AHB_GREEN:
 322                         {
 323                                 if (maxPriceGreen == 0)
 324                                         return 300;
 325                                 else
 326                                         return maxPriceGreen;
 327                                 break;
 328                         }
 329                  case AHB_BLUE:
 330                         {
 331                                 if (maxPriceBlue == 0)
 332                                         return 350;
 333                                 else
 334                                         return maxPriceBlue;
 335                                 break;
 336                         }
 337                  case AHB_PURPLE:
 338                         {
 339                                 if (maxPricePurple == 0)
 340                                         return 450;
 341                                 else
 342                                         return maxPricePurple;
 343                                 break;
 344                         }
 345                  default:
 346                          {
 347                                  return 0;
 348                                  break;
 349                          }
 350                 }
 351          }
 352          void SetMinBidPrice(uint32 color, uint32 value)
 353          {
 354                  switch(color)
 355                  {
 356                  case AHB_GREY:
 357                          break;
 358                  case AHB_WHITE:
 359                         minBidPriceWhite = value;
 360                          break;
 361                  case AHB_GREEN:
 362                         minBidPriceGreen = value;
 363                          break;
 364                  case AHB_BLUE:
 365                         minBidPriceBlue = value;
 366                          break;
 367                  case AHB_PURPLE:
 368                         minBidPricePurple = value;
 369                          break;
 370                  default:
 371                          break;
 372                  }
 373          }
 374          uint32 GetMinBidPrice(uint32 color)
 375          {
 376                  switch(color)
 377                  {
 378                  case AHB_GREY:
 379                         {
 380                                 return 0;
 381                                 break;
 382                         }
 383                  case AHB_WHITE:
 384                         {
 385                                 if (minBidPriceWhite > 100)
 386                                         return 100;
 387                                 else
 388                                         return minBidPriceWhite;
 389                                 break;
 390                         }
 391                  case AHB_GREEN:
 392                         {
 393                                 if (minBidPriceGreen > 100)
 394                                         return 100;
 395                                 else
 396                                         return minBidPriceGreen;
 397                                 break;
 398                         }
 399                  case AHB_BLUE:
 400                         {
 401                                 if (minBidPriceBlue > 100)
 402                                         return 100;
 403                                 else
 404                                         return minBidPriceBlue;
 405                                 break;
 406                         }
 407                  case AHB_PURPLE:
 408                         {
 409                                 if (minBidPricePurple > 100)
 410                                         return 100;
 411                                 else
 412                                         return minBidPricePurple;
 413                                 break;
 414                         }
 415                  default:
 416                          {
 417                                  return 0;
 418                                  break;
 419                          }
 420                  }
 421          }
 422          void SetMaxBidPrice(uint32 color, uint32 value)
 423          {
 424                  switch(color)
 425                  {
 426                  case AHB_GREY:
 427                          break;
 428                  case AHB_WHITE:
 429                         maxBidPriceWhite = value;
 430                          break;
 431                  case AHB_GREEN:
 432                         maxBidPriceGreen = value;
 433                          break;
 434                  case AHB_BLUE:
 435                         maxBidPriceBlue = value;
 436                          break;
 437                  case AHB_PURPLE:
 438                         maxBidPricePurple = value;
 439                          break;
 440                  default:
 441                          break;
 442                  }
 443          }
 444          uint32 GetMaxBidPrice(uint32 color)
 445          {
 446                  switch(color)
 447                  {
 448                  case AHB_GREY:
 449                         {
 450                                 return 0;
 451                                 break;
 452                         }
 453                  case AHB_WHITE:
 454                         {
 455                                 if (maxBidPriceWhite > 100)
 456                                         return 100;
 457                                 else
 458                                         return maxBidPriceWhite;
 459                                 break;
 460                         }
 461                  case AHB_GREEN:
 462                         {
 463                                 if (maxBidPriceGreen > 100)
 464                                         return 100;
 465                                 else
 466                                         return maxBidPriceGreen;
 467                                 break;
 468                         }
 469                  case AHB_BLUE:
 470                         {
 471                                 if (maxBidPriceBlue > 100)
 472                                         return 100;
 473                                 else
 474                                         return maxBidPriceBlue;
 475                                 break;
 476                         }
 477                  case AHB_PURPLE:
 478                         {
 479                                 if (maxBidPricePurple > 100)
 480                                         return 100;
 481                                 else
 482                                         return maxBidPricePurple;
 483                                 break;
 484                         }
 485                  default:
 486                          {
 487                                  return 0;
 488                                  break;
 489                          }
 490                  }
 491          }
 492          void SetMaxStack(uint32 color, uint32 value)
 493          {
 494                  switch(color)
 495                  {
 496                  case AHB_GREY:
 497                          break;
 498                  case AHB_WHITE:
 499                         maxStackWhite = value;
 500                          break;
 501                  case AHB_GREEN:
 502                         maxStackGreen = value;
 503                          break;
 504                  case AHB_BLUE:
 505                         maxStackBlue = value;
 506                          break;
 507                  case AHB_PURPLE:
 508                         maxStackPurple = value;
 509                          break;
 510                  default:
 511                          break;
 512                  }
 513          }
 514          uint32 GetMaxStack(uint32 color)
 515          {
 516                  switch(color)
 517                  {
 518                  case AHB_GREY:
 519                         {
 520                                 return 0;
 521                                 break;
 522                         }
 523                  case AHB_WHITE:
 524                         {
 525                                 return maxStackWhite;
 526                                 break;
 527                         }
 528                  case AHB_GREEN:
 529                         {
 530                                 return maxStackGreen;
 531                                 break;
 532                         }
 533                  case AHB_BLUE:
 534                         {
 535                                 return maxStackBlue;
 536                                 break;
 537                         }
 538                  case AHB_PURPLE:
 539                         {
 540                                 return maxStackPurple;
 541                                 break;
 542                         }
 543                  default:
 544                          {
 545                                  return 0;
 546                                  break;
 547                          }
 548                  }
 549          }
 550          void SetBuyerPrice(uint32 color, uint32 value)
 551          {
 552                  switch(color)
 553                  {
 554                  case AHB_GREY:
 555                         buyerPriceGrey = value;
 556                          break;
 557                  case AHB_WHITE:
 558                         buyerPriceWhite = value;
 559                          break;
 560                  case AHB_GREEN:
 561                         buyerPriceGreen = value;
 562                          break;
 563                  case AHB_BLUE:
 564                         buyerPriceBlue = value;
 565                          break;
 566                  case AHB_PURPLE:
 567                         buyerPricePurple = value;
 568                          break;
 569                  default:
 570                          break;
 571                  }
 572          }
 573          uint32 GetBuyerPrice(uint32 color)
 574          {
 575                  switch(color)
 576                  {
 577                  case AHB_GREY:
 578                         return buyerPriceGrey;
 579                          break;
 580                  case AHB_WHITE:
 581                         return buyerPriceWhite;
 582                          break;
 583                  case AHB_GREEN:
 584                         return buyerPriceGreen;
 585                          break;
 586                  case AHB_BLUE:
 587                         return buyerPriceBlue;
 588                          break;
 589                  case AHB_PURPLE:
 590                         return buyerPricePurple;
 591                          break;
 592                  default:
 593                          return 0;
 594                          break;
 595                  }
 596          }
 597          void SetBiddingInterval(uint32 value)
 598          {
 599                  buyerBiddingInterval = value;
 600          }
 601          uint32 GetBiddingInterval()
 602          {
 603                  return buyerBiddingInterval;
 604          }
 605          void CalculatePercents()
 606          {
 607                 wtgp = (uint32) (((double)percentWhiteTradeGoods / 100.0) * maxItems);
 608                 gtgp = (uint32) (((double)percentGreenTradeGoods / 100.0) * maxItems);
 609                 btgp = (uint32) (((double)percentBlueTradeGoods / 100.0) * maxItems);
 610                 ptgp = (uint32) (((double)percentPurpleTradeGoods / 100.0) * maxItems);
 611                 wip = (uint32) (((double)percentWhiteItems / 100.0) * maxItems);
 612                 gip = (uint32) (((double)percentGreenItems / 100.0) * maxItems);
 613                 bip = (uint32) (((double)percentBlueItems / 100.0) * maxItems);
 614                 pip = (uint32) (((double)percentPurpleItems / 100.0) * maxItems);
 615                 uint32 total = wtgp + gtgp + btgp + ptgp + wip + gip + bip + pip;
 616                 if (total != maxItems)
 617                 {
 618                   wtgp = (uint32) (maxItems * (double) wtgp);
 619                   gtgp = (uint32) (maxItems * (double) gtgp);
 620                   btgp = (uint32) (maxItems * (double) btgp);
 621                   ptgp = (uint32) (maxItems * (double) ptgp);
 622                   wip = (uint32) (maxItems * (double) wip);
 623                   gip = (uint32) (maxItems * (double) gip);
 624                   bip = (uint32) (maxItems * (double) bip);
 625                   pip = (maxItems - (wtgp + gtgp + btgp + ptgp + wip + gip + bip));
 626                   total = wtgp + gtgp + btgp + ptgp + wip + gip + bip + pip;
 627                 }
 628                 //sLog.outString("%u %u %u %u %u %u %u %u", wtgp, gtgp, btgp, ptgp, wip, gip, bip, pip);
 629          }
 630          uint32 GetPercents(uint32 color)
 631          {
 632                  switch(color)
 633                  {
 634                  case AHB_GREY_TG:
 635                          return 0;
 636                          break;
 637                  case AHB_WHITE_TG:
 638                         return wtgp;
 639                          break;
 640                  case AHB_GREEN_TG:
 641                         return gtgp;
 642                          break;
 643                  case AHB_BLUE_TG:
 644                         return btgp;
 645                          break;
 646                  case AHB_PURPLE_TG:
 647                         return ptgp;
 648                          break;
 649                  case AHB_GREY_I:
 650                          return 0;
 651                          break;
 652                  case AHB_WHITE_I:
 653                         return wip;
 654                          break;
 655                  case AHB_GREEN_I:
 656                         return gip;
 657                          break;
 658                  case AHB_BLUE_I:
 659                         return bip;
 660                          break;
 661                  case AHB_PURPLE_I:
 662                         return pip;
 663                          break;
 664                  default:
 665                          return 0;
 666                          break;
 667                  }
 668          }
 669          void SetBidsPerInterval(uint32 value)
 670          {
 671                  buyerBidsPerInterval = value;
 672          }
 673          uint32 GetBidsPerInterval()
 674          {
 675                  return buyerBidsPerInterval;
 676          }
 677    ~AHBConfig()
 678    {
 679    }
 680 };
 681 void AuctionHouseBot();
 682 void AuctionHouseBotInit();
 683 void AuctionHouseBotLoadValues(AHBConfig*);
 684 void AuctionHouseBotCommands(uint32, uint32, uint32, char*);
 685 #endif