mirror of
https://github.com/TrinityCore/TrinityCore.git
synced 2026-01-20 17:27:36 +01:00
920 lines
24 KiB
C++
920 lines
24 KiB
C++
#ifndef AUCTION_HOUSE_BOT_H
|
|
#define AUCTION_HOUSE_BOT_H
|
|
#include "Common.h"
|
|
#include "Log.h"
|
|
#include "Config/ConfigEnv.h"
|
|
#define AHB_GREY 0
|
|
#define AHB_WHITE 1
|
|
#define AHB_GREEN 2
|
|
#define AHB_BLUE 3
|
|
#define AHB_PURPLE 4
|
|
#define AHB_ORANGE 5
|
|
#define AHB_YELLOW 6
|
|
#define AHB_GREY_TG 0
|
|
#define AHB_WHITE_TG 1
|
|
#define AHB_GREEN_TG 2
|
|
#define AHB_BLUE_TG 3
|
|
#define AHB_PURPLE_TG 4
|
|
#define AHB_ORANGE_TG 5
|
|
#define AHB_YELLOW_TG 6
|
|
#define AHB_GREY_I 7
|
|
#define AHB_WHITE_I 8
|
|
#define AHB_GREEN_I 9
|
|
#define AHB_BLUE_I 10
|
|
#define AHB_PURPLE_I 11
|
|
#define AHB_ORANGE_I 12
|
|
#define AHB_YELLOW_I 13
|
|
#define AHBplayerAccount sConfig.GetIntDefault("AuctionHouseBot.Account", 0)
|
|
#define AHBplayerGUID sConfig.GetIntDefault("AuctionHouseBot.GUID", 0)
|
|
#define ItemsPerCycle sConfig.GetIntDefault("AuctionHouseBot.ItemsPerCycle", 200)
|
|
#define SellMethod sConfig.GetIntDefault("AuctionHouseBot.UseBuyPriceForSeller", 1)
|
|
#define BuyMethod sConfig.GetIntDefault("AuctionHouseBot.UseBuyPriceForBuyer", 0)
|
|
|
|
class AHBConfig
|
|
{
|
|
private:
|
|
uint32 AHID;
|
|
uint32 AHFID;
|
|
uint32 minItems;
|
|
uint32 maxItems;
|
|
uint32 minTime;
|
|
uint32 maxTime;
|
|
uint32 percentGreyTradeGoods;
|
|
uint32 percentWhiteTradeGoods;
|
|
uint32 percentGreenTradeGoods;
|
|
uint32 percentBlueTradeGoods;
|
|
uint32 percentPurpleTradeGoods;
|
|
uint32 percentOrangeTradeGoods;
|
|
uint32 percentYellowTradeGoods;
|
|
uint32 percentGreyItems;
|
|
uint32 percentWhiteItems;
|
|
uint32 percentGreenItems;
|
|
uint32 percentBlueItems;
|
|
uint32 percentPurpleItems;
|
|
uint32 percentOrangeItems;
|
|
uint32 percentYellowItems;
|
|
uint32 minPriceGrey;
|
|
uint32 maxPriceGrey;
|
|
uint32 minBidPriceGrey;
|
|
uint32 maxBidPriceGrey;
|
|
uint32 maxStackGrey;
|
|
uint32 minPriceWhite;
|
|
uint32 maxPriceWhite;
|
|
uint32 minBidPriceWhite;
|
|
uint32 maxBidPriceWhite;
|
|
uint32 maxStackWhite;
|
|
uint32 minPriceGreen;
|
|
uint32 maxPriceGreen;
|
|
uint32 minBidPriceGreen;
|
|
uint32 maxBidPriceGreen;
|
|
uint32 maxStackGreen;
|
|
uint32 minPriceBlue;
|
|
uint32 maxPriceBlue;
|
|
uint32 minBidPriceBlue;
|
|
uint32 maxBidPriceBlue;
|
|
uint32 maxStackBlue;
|
|
uint32 minPricePurple;
|
|
uint32 maxPricePurple;
|
|
uint32 minBidPricePurple;
|
|
uint32 maxBidPricePurple;
|
|
uint32 maxStackPurple;
|
|
uint32 minPriceOrange;
|
|
uint32 maxPriceOrange;
|
|
uint32 minBidPriceOrange;
|
|
uint32 maxBidPriceOrange;
|
|
uint32 maxStackOrange;
|
|
uint32 minPriceYellow;
|
|
uint32 maxPriceYellow;
|
|
uint32 minBidPriceYellow;
|
|
uint32 maxBidPriceYellow;
|
|
uint32 maxStackYellow;
|
|
|
|
uint32 buyerPriceGrey;
|
|
uint32 buyerPriceWhite;
|
|
uint32 buyerPriceGreen;
|
|
uint32 buyerPriceBlue;
|
|
uint32 buyerPricePurple;
|
|
uint32 buyerPriceOrange;
|
|
uint32 buyerPriceYellow;
|
|
uint32 buyerBiddingInterval;
|
|
uint32 buyerBidsPerInterval;
|
|
|
|
uint32 greytgp;
|
|
uint32 whitetgp;
|
|
uint32 greentgp;
|
|
uint32 bluetgp;
|
|
uint32 purpletgp;
|
|
uint32 orangetgp;
|
|
uint32 yellowtgp;
|
|
uint32 greyip;
|
|
uint32 whiteip;
|
|
uint32 greenip;
|
|
uint32 blueip;
|
|
uint32 purpleip;
|
|
uint32 orangeip;
|
|
uint32 yellowip;
|
|
public:
|
|
AHBConfig(uint32 ahid)
|
|
{
|
|
AHID = ahid;
|
|
switch(ahid)
|
|
{
|
|
case 2:
|
|
AHFID = 55;
|
|
break;
|
|
case 6:
|
|
AHFID = 29;
|
|
break;
|
|
case 7:
|
|
AHFID = 120;
|
|
break;
|
|
default:
|
|
AHFID = 120;
|
|
break;
|
|
}
|
|
}
|
|
AHBConfig()
|
|
{
|
|
}
|
|
uint32 GetAHID()
|
|
{
|
|
return AHID;
|
|
}
|
|
uint32 GetAHFID()
|
|
{
|
|
return AHFID;
|
|
}
|
|
void SetMinItems(uint32 value)
|
|
{
|
|
minItems = value;
|
|
}
|
|
uint32 GetMinItems()
|
|
{
|
|
if ((minItems == 0) && (maxItems))
|
|
return maxItems;
|
|
else if ((maxItems) && (minItems > maxItems))
|
|
return maxItems;
|
|
else
|
|
return minItems;
|
|
}
|
|
void SetMaxItems(uint32 value)
|
|
{
|
|
maxItems = value;
|
|
CalculatePercents();
|
|
}
|
|
uint32 GetMaxItems()
|
|
{
|
|
return maxItems;
|
|
}
|
|
void SetMinTime(uint32 value)
|
|
{
|
|
minTime = value;
|
|
}
|
|
uint32 GetMinTime()
|
|
{
|
|
if (minTime < 1)
|
|
return 1;
|
|
else if ((maxTime) && (minTime > maxTime))
|
|
return maxTime;
|
|
else
|
|
return minTime;
|
|
}
|
|
void SetMaxTime(uint32 value)
|
|
{
|
|
maxTime = value;
|
|
}
|
|
uint32 GetMaxTime()
|
|
{
|
|
return maxTime;
|
|
}
|
|
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)
|
|
{
|
|
uint32 totalPercent = greytg + whitetg + greentg + bluetg + purpletg + orangetg + yellowtg + greyi + whitei + greeni + bluei + purplei + orangei + yellowi;
|
|
|
|
if (totalPercent == 0)
|
|
{
|
|
maxItems = 0;
|
|
}
|
|
else if (totalPercent != 100)
|
|
{
|
|
greytg = 0;
|
|
whitetg = 27;
|
|
greentg = 12;
|
|
bluetg = 10;
|
|
purpletg = 1;
|
|
orangetg = 0;
|
|
yellowtg = 0;
|
|
greyi = 0;
|
|
whitei = 10;
|
|
greeni = 30;
|
|
bluei = 8;
|
|
purplei = 2;
|
|
orangei = 0;
|
|
yellowi = 0;
|
|
}
|
|
percentGreyTradeGoods = greytg;
|
|
percentWhiteTradeGoods = whitetg;
|
|
percentGreenTradeGoods = greentg;
|
|
percentBlueTradeGoods = bluetg;
|
|
percentPurpleTradeGoods = purpletg;
|
|
percentOrangeTradeGoods = orangetg;
|
|
percentYellowTradeGoods = yellowtg;
|
|
percentGreyItems = greyi;
|
|
percentWhiteItems = whitei;
|
|
percentGreenItems = greeni;
|
|
percentBlueItems = bluei;
|
|
percentPurpleItems = purplei;
|
|
percentOrangeItems = orangei;
|
|
percentYellowItems = yellowi;
|
|
CalculatePercents();
|
|
}
|
|
uint32 GetPercentages(uint32 color)
|
|
{
|
|
switch(color)
|
|
{
|
|
case AHB_GREY_TG:
|
|
return percentGreyTradeGoods;
|
|
break;
|
|
case AHB_WHITE_TG:
|
|
return percentWhiteTradeGoods;
|
|
break;
|
|
case AHB_GREEN_TG:
|
|
return percentGreenTradeGoods;
|
|
break;
|
|
case AHB_BLUE_TG:
|
|
return percentBlueTradeGoods;
|
|
break;
|
|
case AHB_PURPLE_TG:
|
|
return percentPurpleTradeGoods;
|
|
break;
|
|
case AHB_ORANGE_TG:
|
|
return percentOrangeTradeGoods;
|
|
break;
|
|
case AHB_YELLOW_TG:
|
|
return percentYellowTradeGoods;
|
|
break;
|
|
case AHB_GREY_I:
|
|
return percentGreyItems;
|
|
break;
|
|
case AHB_WHITE_I:
|
|
return percentWhiteItems;
|
|
break;
|
|
case AHB_GREEN_I:
|
|
return percentGreenItems;
|
|
break;
|
|
case AHB_BLUE_I:
|
|
return percentBlueItems;
|
|
break;
|
|
case AHB_PURPLE_I:
|
|
return percentPurpleItems;
|
|
break;
|
|
case AHB_ORANGE_I:
|
|
return percentOrangeItems;
|
|
break;
|
|
case AHB_YELLOW_I:
|
|
return percentYellowItems;
|
|
break;
|
|
default:
|
|
return 0;
|
|
break;
|
|
}
|
|
}
|
|
void SetMinPrice(uint32 color, uint32 value)
|
|
{
|
|
switch(color)
|
|
{
|
|
case AHB_GREY:
|
|
minPriceGrey = value;
|
|
break;
|
|
case AHB_WHITE:
|
|
minPriceWhite = value;
|
|
break;
|
|
case AHB_GREEN:
|
|
minPriceGreen = value;
|
|
break;
|
|
case AHB_BLUE:
|
|
minPriceBlue = value;
|
|
break;
|
|
case AHB_PURPLE:
|
|
minPricePurple = value;
|
|
break;
|
|
case AHB_ORANGE:
|
|
minPriceOrange = value;
|
|
break;
|
|
case AHB_YELLOW:
|
|
minPriceYellow = value;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
uint32 GetMinPrice(uint32 color)
|
|
{
|
|
switch(color)
|
|
{
|
|
case AHB_GREY:
|
|
{
|
|
if (minPriceGrey == 0)
|
|
return 100;
|
|
else if (minPriceGrey > maxPriceGrey)
|
|
return maxPriceGrey;
|
|
else
|
|
return minPriceGrey;
|
|
break;
|
|
}
|
|
case AHB_WHITE:
|
|
{
|
|
if (minPriceWhite == 0)
|
|
return 150;
|
|
else if (minPriceWhite > maxPriceWhite)
|
|
return maxPriceWhite;
|
|
else
|
|
return minPriceWhite;
|
|
break;
|
|
}
|
|
case AHB_GREEN:
|
|
{
|
|
if (minPriceGreen == 0)
|
|
return 200;
|
|
else if (minPriceGreen > maxPriceGreen)
|
|
return maxPriceGreen;
|
|
else
|
|
return minPriceGreen;
|
|
break;
|
|
}
|
|
case AHB_BLUE:
|
|
{
|
|
if (minPriceBlue == 0)
|
|
return 250;
|
|
else if (minPriceBlue > maxPriceBlue)
|
|
return maxPriceBlue;
|
|
else
|
|
return minPriceBlue;
|
|
break;
|
|
}
|
|
case AHB_PURPLE:
|
|
{
|
|
if (minPricePurple == 0)
|
|
return 300;
|
|
else if (minPricePurple > maxPricePurple)
|
|
return maxPricePurple;
|
|
else
|
|
return minPricePurple;
|
|
break;
|
|
}
|
|
case AHB_ORANGE:
|
|
{
|
|
if (minPriceOrange == 0)
|
|
return 400;
|
|
else if (minPriceOrange > maxPriceOrange)
|
|
return maxPriceOrange;
|
|
else
|
|
return minPriceOrange;
|
|
break;
|
|
}
|
|
case AHB_YELLOW:
|
|
{
|
|
if (minPriceYellow == 0)
|
|
return 500;
|
|
else if (minPriceYellow > maxPriceYellow)
|
|
return maxPriceYellow;
|
|
else
|
|
return minPriceYellow;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
return 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
void SetMaxPrice(uint32 color, uint32 value)
|
|
{
|
|
switch(color)
|
|
{
|
|
case AHB_GREY:
|
|
maxPriceGrey = value;
|
|
break;
|
|
case AHB_WHITE:
|
|
maxPriceWhite = value;
|
|
break;
|
|
case AHB_GREEN:
|
|
maxPriceGreen = value;
|
|
break;
|
|
case AHB_BLUE:
|
|
maxPriceBlue = value;
|
|
break;
|
|
case AHB_PURPLE:
|
|
maxPricePurple = value;
|
|
break;
|
|
case AHB_ORANGE:
|
|
maxPriceOrange = value;
|
|
break;
|
|
case AHB_YELLOW:
|
|
maxPriceYellow = value;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
uint32 GetMaxPrice(uint32 color)
|
|
{
|
|
switch(color)
|
|
{
|
|
case AHB_GREY:
|
|
{
|
|
if (maxPriceGrey == 0)
|
|
return 150;
|
|
else
|
|
return maxPriceGrey;
|
|
break;
|
|
}
|
|
case AHB_WHITE:
|
|
{
|
|
if (maxPriceWhite == 0)
|
|
return 250;
|
|
else
|
|
return maxPriceWhite;
|
|
break;
|
|
}
|
|
case AHB_GREEN:
|
|
{
|
|
if (maxPriceGreen == 0)
|
|
return 300;
|
|
else
|
|
return maxPriceGreen;
|
|
break;
|
|
}
|
|
case AHB_BLUE:
|
|
{
|
|
if (maxPriceBlue == 0)
|
|
return 350;
|
|
else
|
|
return maxPriceBlue;
|
|
break;
|
|
}
|
|
case AHB_PURPLE:
|
|
{
|
|
if (maxPricePurple == 0)
|
|
return 450;
|
|
else
|
|
return maxPricePurple;
|
|
break;
|
|
}
|
|
case AHB_ORANGE:
|
|
{
|
|
if (maxPriceOrange == 0)
|
|
return 550;
|
|
else
|
|
return maxPriceOrange;
|
|
break;
|
|
}
|
|
case AHB_YELLOW:
|
|
{
|
|
if (maxPriceYellow == 0)
|
|
return 650;
|
|
else
|
|
return maxPriceYellow;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
return 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
void SetMinBidPrice(uint32 color, uint32 value)
|
|
{
|
|
switch(color)
|
|
{
|
|
case AHB_GREY:
|
|
minBidPriceGrey = value;
|
|
break;
|
|
case AHB_WHITE:
|
|
minBidPriceWhite = value;
|
|
break;
|
|
case AHB_GREEN:
|
|
minBidPriceGreen = value;
|
|
break;
|
|
case AHB_BLUE:
|
|
minBidPriceBlue = value;
|
|
break;
|
|
case AHB_PURPLE:
|
|
minBidPricePurple = value;
|
|
break;
|
|
case AHB_ORANGE:
|
|
minBidPriceOrange = value;
|
|
break;
|
|
case AHB_YELLOW:
|
|
minBidPriceYellow = value;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
uint32 GetMinBidPrice(uint32 color)
|
|
{
|
|
switch(color)
|
|
{
|
|
case AHB_GREY:
|
|
{
|
|
if (minBidPriceGrey > 100)
|
|
return 100;
|
|
else
|
|
return minBidPriceGrey;
|
|
break;
|
|
}
|
|
case AHB_WHITE:
|
|
{
|
|
if (minBidPriceWhite > 100)
|
|
return 100;
|
|
else
|
|
return minBidPriceWhite;
|
|
break;
|
|
}
|
|
case AHB_GREEN:
|
|
{
|
|
if (minBidPriceGreen > 100)
|
|
return 100;
|
|
else
|
|
return minBidPriceGreen;
|
|
break;
|
|
}
|
|
case AHB_BLUE:
|
|
{
|
|
if (minBidPriceBlue > 100)
|
|
return 100;
|
|
else
|
|
return minBidPriceBlue;
|
|
break;
|
|
}
|
|
case AHB_PURPLE:
|
|
{
|
|
if (minBidPricePurple > 100)
|
|
return 100;
|
|
else
|
|
return minBidPricePurple;
|
|
break;
|
|
}
|
|
case AHB_ORANGE:
|
|
{
|
|
if (minBidPriceOrange > 100)
|
|
return 100;
|
|
else
|
|
return minBidPriceOrange;
|
|
break;
|
|
}
|
|
case AHB_YELLOW:
|
|
{
|
|
if (minBidPriceYellow > 100)
|
|
return 100;
|
|
else
|
|
return minBidPriceYellow;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
return 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
void SetMaxBidPrice(uint32 color, uint32 value)
|
|
{
|
|
switch(color)
|
|
{
|
|
case AHB_GREY:
|
|
maxBidPriceGrey = value;
|
|
break;
|
|
case AHB_WHITE:
|
|
maxBidPriceWhite = value;
|
|
break;
|
|
case AHB_GREEN:
|
|
maxBidPriceGreen = value;
|
|
break;
|
|
case AHB_BLUE:
|
|
maxBidPriceBlue = value;
|
|
break;
|
|
case AHB_PURPLE:
|
|
maxBidPricePurple = value;
|
|
break;
|
|
case AHB_ORANGE:
|
|
maxBidPriceOrange = value;
|
|
break;
|
|
case AHB_YELLOW:
|
|
maxBidPriceYellow = value;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
uint32 GetMaxBidPrice(uint32 color)
|
|
{
|
|
switch(color)
|
|
{
|
|
case AHB_GREY:
|
|
{
|
|
if (maxBidPriceGrey > 100)
|
|
return 100;
|
|
else
|
|
return maxBidPriceGrey;
|
|
break;
|
|
}
|
|
case AHB_WHITE:
|
|
{
|
|
if (maxBidPriceWhite > 100)
|
|
return 100;
|
|
else
|
|
return maxBidPriceWhite;
|
|
break;
|
|
}
|
|
case AHB_GREEN:
|
|
{
|
|
if (maxBidPriceGreen > 100)
|
|
return 100;
|
|
else
|
|
return maxBidPriceGreen;
|
|
break;
|
|
}
|
|
case AHB_BLUE:
|
|
{
|
|
if (maxBidPriceBlue > 100)
|
|
return 100;
|
|
else
|
|
return maxBidPriceBlue;
|
|
break;
|
|
}
|
|
case AHB_PURPLE:
|
|
{
|
|
if (maxBidPricePurple > 100)
|
|
return 100;
|
|
else
|
|
return maxBidPricePurple;
|
|
break;
|
|
}
|
|
case AHB_ORANGE:
|
|
{
|
|
if (maxBidPriceOrange > 100)
|
|
return 100;
|
|
else
|
|
return maxBidPriceOrange;
|
|
break;
|
|
}
|
|
case AHB_YELLOW:
|
|
{
|
|
if (maxBidPriceYellow > 100)
|
|
return 100;
|
|
else
|
|
return maxBidPriceYellow;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
return 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
void SetMaxStack(uint32 color, uint32 value)
|
|
{
|
|
switch(color)
|
|
{
|
|
case AHB_GREY:
|
|
maxStackGrey = value;
|
|
break;
|
|
case AHB_WHITE:
|
|
maxStackWhite = value;
|
|
break;
|
|
case AHB_GREEN:
|
|
maxStackGreen = value;
|
|
break;
|
|
case AHB_BLUE:
|
|
maxStackBlue = value;
|
|
break;
|
|
case AHB_PURPLE:
|
|
maxStackPurple = value;
|
|
break;
|
|
case AHB_ORANGE:
|
|
maxStackOrange = value;
|
|
break;
|
|
case AHB_YELLOW:
|
|
maxStackYellow = value;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
uint32 GetMaxStack(uint32 color)
|
|
{
|
|
switch(color)
|
|
{
|
|
case AHB_GREY:
|
|
{
|
|
return maxStackGrey;
|
|
break;
|
|
}
|
|
case AHB_WHITE:
|
|
{
|
|
return maxStackWhite;
|
|
break;
|
|
}
|
|
case AHB_GREEN:
|
|
{
|
|
return maxStackGreen;
|
|
break;
|
|
}
|
|
case AHB_BLUE:
|
|
{
|
|
return maxStackBlue;
|
|
break;
|
|
}
|
|
case AHB_PURPLE:
|
|
{
|
|
return maxStackPurple;
|
|
break;
|
|
}
|
|
case AHB_ORANGE:
|
|
{
|
|
return maxStackOrange;
|
|
break;
|
|
}
|
|
case AHB_YELLOW:
|
|
{
|
|
return maxStackYellow;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
return 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
void SetBuyerPrice(uint32 color, uint32 value)
|
|
{
|
|
switch(color)
|
|
{
|
|
case AHB_GREY:
|
|
buyerPriceGrey = value;
|
|
break;
|
|
case AHB_WHITE:
|
|
buyerPriceWhite = value;
|
|
break;
|
|
case AHB_GREEN:
|
|
buyerPriceGreen = value;
|
|
break;
|
|
case AHB_BLUE:
|
|
buyerPriceBlue = value;
|
|
break;
|
|
case AHB_PURPLE:
|
|
buyerPricePurple = value;
|
|
break;
|
|
case AHB_ORANGE:
|
|
buyerPriceOrange = value;
|
|
break;
|
|
case AHB_YELLOW:
|
|
buyerPriceYellow = value;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
uint32 GetBuyerPrice(uint32 color)
|
|
{
|
|
switch(color)
|
|
{
|
|
case AHB_GREY:
|
|
return buyerPriceGrey;
|
|
break;
|
|
case AHB_WHITE:
|
|
return buyerPriceWhite;
|
|
break;
|
|
case AHB_GREEN:
|
|
return buyerPriceGreen;
|
|
break;
|
|
case AHB_BLUE:
|
|
return buyerPriceBlue;
|
|
break;
|
|
case AHB_PURPLE:
|
|
return buyerPricePurple;
|
|
break;
|
|
case AHB_ORANGE:
|
|
return buyerPriceOrange;
|
|
break;
|
|
case AHB_YELLOW:
|
|
return buyerPriceYellow;
|
|
break;
|
|
default:
|
|
return 0;
|
|
break;
|
|
}
|
|
}
|
|
void SetBiddingInterval(uint32 value)
|
|
{
|
|
buyerBiddingInterval = value;
|
|
}
|
|
uint32 GetBiddingInterval()
|
|
{
|
|
return buyerBiddingInterval;
|
|
}
|
|
void CalculatePercents()
|
|
{
|
|
greytgp = (uint32) (((double)percentGreyTradeGoods / 100.0) * maxItems);
|
|
whitetgp = (uint32) (((double)percentWhiteTradeGoods / 100.0) * maxItems);
|
|
greentgp = (uint32) (((double)percentGreenTradeGoods / 100.0) * maxItems);
|
|
bluetgp = (uint32) (((double)percentBlueTradeGoods / 100.0) * maxItems);
|
|
purpletgp = (uint32) (((double)percentPurpleTradeGoods / 100.0) * maxItems);
|
|
orangetgp = (uint32) (((double)percentOrangeTradeGoods / 100.0) * maxItems);
|
|
yellowtgp = (uint32) (((double)percentYellowTradeGoods / 100.0) * maxItems);
|
|
greyip = (uint32) (((double)percentGreyItems / 100.0) * maxItems);
|
|
whiteip = (uint32) (((double)percentWhiteItems / 100.0) * maxItems);
|
|
greenip = (uint32) (((double)percentGreenItems / 100.0) * maxItems);
|
|
blueip = (uint32) (((double)percentBlueItems / 100.0) * maxItems);
|
|
purpleip = (uint32) (((double)percentPurpleItems / 100.0) * maxItems);
|
|
orangeip = (uint32) (((double)percentOrangeItems / 100.0) * maxItems);
|
|
yellowip = (uint32) (((double)percentYellowItems / 100.0) * maxItems);
|
|
uint32 total = greytgp + whitetgp + greentgp + bluetgp + purpletgp + orangetgp + yellowtgp + greyip + whiteip + greenip + blueip + purpleip + orangeip + yellowip;
|
|
int32 diff = (maxItems - total);
|
|
if (diff < 0)
|
|
{
|
|
if ((whiteip - diff) > 0)
|
|
whiteip -= diff;
|
|
else if ((greenip - diff) > 0)
|
|
greenip -= diff;
|
|
}
|
|
else if (diff < 0)
|
|
{
|
|
whiteip += diff;
|
|
}
|
|
}
|
|
uint32 GetPercents(uint32 color)
|
|
{
|
|
switch(color)
|
|
{
|
|
case AHB_GREY_TG:
|
|
return greytgp;
|
|
break;
|
|
case AHB_WHITE_TG:
|
|
return whitetgp;
|
|
break;
|
|
case AHB_GREEN_TG:
|
|
return greentgp;
|
|
break;
|
|
case AHB_BLUE_TG:
|
|
return bluetgp;
|
|
break;
|
|
case AHB_PURPLE_TG:
|
|
return purpletgp;
|
|
break;
|
|
case AHB_ORANGE_TG:
|
|
return orangetgp;
|
|
break;
|
|
case AHB_YELLOW_TG:
|
|
return yellowtgp;
|
|
break;
|
|
case AHB_GREY_I:
|
|
return greyip;
|
|
break;
|
|
case AHB_WHITE_I:
|
|
return whiteip;
|
|
break;
|
|
case AHB_GREEN_I:
|
|
return greenip;
|
|
break;
|
|
case AHB_BLUE_I:
|
|
return blueip;
|
|
break;
|
|
case AHB_PURPLE_I:
|
|
return purpleip;
|
|
break;
|
|
case AHB_ORANGE_I:
|
|
return orangeip;
|
|
break;
|
|
case AHB_YELLOW_I:
|
|
return yellowip;
|
|
break;
|
|
default:
|
|
return 0;
|
|
break;
|
|
}
|
|
}
|
|
void SetBidsPerInterval(uint32 value)
|
|
{
|
|
buyerBidsPerInterval = value;
|
|
}
|
|
uint32 GetBidsPerInterval()
|
|
{
|
|
return buyerBidsPerInterval;
|
|
}
|
|
~AHBConfig()
|
|
{
|
|
}
|
|
};
|
|
void AuctionHouseBot();
|
|
void AuctionHouseBotInit();
|
|
void AuctionHouseBotLoadValues(AHBConfig*);
|
|
void AuctionHouseBotCommands(uint32, uint32, uint32, char*);
|
|
#endif
|