1261 lines
31 KiB
C++
1261 lines
31 KiB
C++
/*
|
|
* Copyright (C) 2008-2010 Trinity <http://www.trinitycore.org/>
|
|
* Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 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 GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#ifndef AUCTION_HOUSE_BOT_H
|
|
#define AUCTION_HOUSE_BOT_H
|
|
|
|
#include "Common.h"
|
|
#include "ObjectGuid.h"
|
|
|
|
struct AuctionEntry;
|
|
class Player;
|
|
class WorldSession;
|
|
|
|
#include "ItemTemplate.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_MAX_QUALITY 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
|
|
|
|
class AHBConfig
|
|
{
|
|
private:
|
|
uint32 AHID;
|
|
uint32 AHFID;
|
|
uint32 minItems;
|
|
uint32 maxItems;
|
|
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;
|
|
|
|
uint32 greyTGoods;
|
|
uint32 whiteTGoods;
|
|
uint32 greenTGoods;
|
|
uint32 blueTGoods;
|
|
uint32 purpleTGoods;
|
|
uint32 orangeTGoods;
|
|
uint32 yellowTGoods;
|
|
|
|
uint32 greyItems;
|
|
uint32 whiteItems;
|
|
uint32 greenItems;
|
|
uint32 blueItems;
|
|
uint32 purpleItems;
|
|
uint32 orangeItems;
|
|
uint32 yellowItems;
|
|
|
|
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() needs to be called, but only if
|
|
// SetPercentages() has been called at least once already.
|
|
}
|
|
uint32 GetMaxItems()
|
|
{
|
|
return maxItems;
|
|
}
|
|
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 DecItemCounts(uint32 Class, uint32 Quality)
|
|
{
|
|
switch(Class)
|
|
{
|
|
case ITEM_CLASS_TRADE_GOODS:
|
|
DecItemCounts(Quality);
|
|
break;
|
|
default:
|
|
DecItemCounts(Quality + 7);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void DecItemCounts(uint32 color)
|
|
{
|
|
switch(color)
|
|
{
|
|
case AHB_GREY_TG:
|
|
--greyTGoods;
|
|
break;
|
|
case AHB_WHITE_TG:
|
|
--whiteTGoods;
|
|
break;
|
|
case AHB_GREEN_TG:
|
|
--greenTGoods;
|
|
break;
|
|
case AHB_BLUE_TG:
|
|
--blueTGoods;
|
|
break;
|
|
case AHB_PURPLE_TG:
|
|
--purpleTGoods;
|
|
break;
|
|
case AHB_ORANGE_TG:
|
|
--orangeTGoods;
|
|
break;
|
|
case AHB_YELLOW_TG:
|
|
--yellowTGoods;
|
|
break;
|
|
case AHB_GREY_I:
|
|
--greyItems;
|
|
break;
|
|
case AHB_WHITE_I:
|
|
--whiteItems;
|
|
break;
|
|
case AHB_GREEN_I:
|
|
--greenItems;
|
|
break;
|
|
case AHB_BLUE_I:
|
|
--blueItems;
|
|
break;
|
|
case AHB_PURPLE_I:
|
|
--purpleItems;
|
|
break;
|
|
case AHB_ORANGE_I:
|
|
--orangeItems;
|
|
break;
|
|
case AHB_YELLOW_I:
|
|
--yellowItems;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void IncItemCounts(uint32 Class, uint32 Quality)
|
|
{
|
|
switch(Class)
|
|
{
|
|
case ITEM_CLASS_TRADE_GOODS:
|
|
IncItemCounts(Quality);
|
|
break;
|
|
default:
|
|
IncItemCounts(Quality + 7);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void IncItemCounts(uint32 color)
|
|
{
|
|
switch(color)
|
|
{
|
|
case AHB_GREY_TG:
|
|
++greyTGoods;
|
|
break;
|
|
case AHB_WHITE_TG:
|
|
++whiteTGoods;
|
|
break;
|
|
case AHB_GREEN_TG:
|
|
++greenTGoods;
|
|
break;
|
|
case AHB_BLUE_TG:
|
|
++blueTGoods;
|
|
break;
|
|
case AHB_PURPLE_TG:
|
|
++purpleTGoods;
|
|
break;
|
|
case AHB_ORANGE_TG:
|
|
++orangeTGoods;
|
|
break;
|
|
case AHB_YELLOW_TG:
|
|
++yellowTGoods;
|
|
break;
|
|
case AHB_GREY_I:
|
|
++greyItems;
|
|
break;
|
|
case AHB_WHITE_I:
|
|
++whiteItems;
|
|
break;
|
|
case AHB_GREEN_I:
|
|
++greenItems;
|
|
break;
|
|
case AHB_BLUE_I:
|
|
++blueItems;
|
|
break;
|
|
case AHB_PURPLE_I:
|
|
++purpleItems;
|
|
break;
|
|
case AHB_ORANGE_I:
|
|
++orangeItems;
|
|
break;
|
|
case AHB_YELLOW_I:
|
|
++yellowItems;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void ResetItemCounts()
|
|
{
|
|
greyTGoods = 0;
|
|
whiteTGoods = 0;
|
|
greenTGoods = 0;
|
|
blueTGoods = 0;
|
|
purpleTGoods = 0;
|
|
orangeTGoods = 0;
|
|
yellowTGoods = 0;
|
|
|
|
greyItems = 0;
|
|
whiteItems = 0;
|
|
greenItems = 0;
|
|
blueItems = 0;
|
|
purpleItems = 0;
|
|
orangeItems = 0;
|
|
yellowItems = 0;
|
|
}
|
|
|
|
uint32 TotalItemCounts()
|
|
{
|
|
return(
|
|
greyTGoods +
|
|
whiteTGoods +
|
|
greenTGoods +
|
|
blueTGoods +
|
|
purpleTGoods +
|
|
orangeTGoods +
|
|
yellowTGoods +
|
|
|
|
greyItems +
|
|
whiteItems +
|
|
greenItems +
|
|
blueItems +
|
|
purpleItems +
|
|
orangeItems +
|
|
yellowItems);
|
|
}
|
|
|
|
uint32 GetItemCounts(uint32 color)
|
|
{
|
|
switch(color)
|
|
{
|
|
case AHB_GREY_TG:
|
|
return greyTGoods;
|
|
break;
|
|
case AHB_WHITE_TG:
|
|
return whiteTGoods;
|
|
break;
|
|
case AHB_GREEN_TG:
|
|
return greenTGoods;
|
|
break;
|
|
case AHB_BLUE_TG:
|
|
return blueTGoods;
|
|
break;
|
|
case AHB_PURPLE_TG:
|
|
return purpleTGoods;
|
|
break;
|
|
case AHB_ORANGE_TG:
|
|
return orangeTGoods;
|
|
break;
|
|
case AHB_YELLOW_TG:
|
|
return yellowTGoods;
|
|
break;
|
|
case AHB_GREY_I:
|
|
return greyItems;
|
|
break;
|
|
case AHB_WHITE_I:
|
|
return whiteItems;
|
|
break;
|
|
case AHB_GREEN_I:
|
|
return greenItems;
|
|
break;
|
|
case AHB_BLUE_I:
|
|
return blueItems;
|
|
break;
|
|
case AHB_PURPLE_I:
|
|
return purpleItems;
|
|
break;
|
|
case AHB_ORANGE_I:
|
|
return orangeItems;
|
|
break;
|
|
case AHB_YELLOW_I:
|
|
return yellowItems;
|
|
break;
|
|
default:
|
|
return 0;
|
|
break;
|
|
}
|
|
}
|
|
void SetBidsPerInterval(uint32 value)
|
|
{
|
|
buyerBidsPerInterval = value;
|
|
}
|
|
uint32 GetBidsPerInterval()
|
|
{
|
|
return buyerBidsPerInterval;
|
|
}
|
|
~AHBConfig()
|
|
{
|
|
}
|
|
};
|
|
class AuctionHouseBot
|
|
{
|
|
private:
|
|
|
|
bool debug_Out;
|
|
bool debug_Out_Filters;
|
|
|
|
bool AHBSeller;
|
|
bool AHBBuyer;
|
|
bool BuyMethod;
|
|
bool SellMethod;
|
|
|
|
uint32 AHBplayerAccount;
|
|
ObjectGuid::LowType AHBplayerGUID;
|
|
uint32 ItemsPerCycle;
|
|
|
|
//Begin Filters
|
|
|
|
bool Vendor_Items;
|
|
bool Loot_Items;
|
|
bool Other_Items;
|
|
bool Vendor_TGs;
|
|
bool Loot_TGs;
|
|
bool Other_TGs;
|
|
|
|
bool No_Bind;
|
|
bool Bind_When_Picked_Up;
|
|
bool Bind_When_Equipped;
|
|
bool Bind_When_Use;
|
|
bool Bind_Quest_Item;
|
|
|
|
bool DisablePermEnchant;
|
|
bool DisableConjured;
|
|
bool DisableGems;
|
|
bool DisableMoney;
|
|
bool DisableMoneyLoot;
|
|
bool DisableLootable;
|
|
bool DisableKeys;
|
|
bool DisableDuration;
|
|
bool DisableBOP_Or_Quest_NoReqLevel;
|
|
|
|
bool DisableWarriorItems;
|
|
bool DisablePaladinItems;
|
|
bool DisableHunterItems;
|
|
bool DisableRogueItems;
|
|
bool DisablePriestItems;
|
|
bool DisableDKItems;
|
|
bool DisableShamanItems;
|
|
bool DisableMageItems;
|
|
bool DisableWarlockItems;
|
|
bool DisableUnusedClassItems;
|
|
bool DisableDruidItems;
|
|
|
|
uint32 DisableItemsBelowLevel;
|
|
uint32 DisableItemsAboveLevel;
|
|
uint32 DisableTGsBelowLevel;
|
|
uint32 DisableTGsAboveLevel;
|
|
uint32 DisableItemsBelowGUID;
|
|
uint32 DisableItemsAboveGUID;
|
|
uint32 DisableTGsBelowGUID;
|
|
uint32 DisableTGsAboveGUID;
|
|
uint32 DisableItemsBelowReqLevel;
|
|
uint32 DisableItemsAboveReqLevel;
|
|
uint32 DisableTGsBelowReqLevel;
|
|
uint32 DisableTGsAboveReqLevel;
|
|
uint32 DisableItemsBelowReqSkillRank;
|
|
uint32 DisableItemsAboveReqSkillRank;
|
|
uint32 DisableTGsBelowReqSkillRank;
|
|
uint32 DisableTGsAboveReqSkillRank;
|
|
|
|
std::set<uint32> DisableItemStore;
|
|
|
|
//End Filters
|
|
|
|
AHBConfig AllianceConfig;
|
|
AHBConfig HordeConfig;
|
|
AHBConfig NeutralConfig;
|
|
|
|
time_t _lastrun_a;
|
|
time_t _lastrun_h;
|
|
time_t _lastrun_n;
|
|
|
|
inline uint32 minValue(uint32 a, uint32 b) { return a <= b ? a : b; };
|
|
void addNewAuctions(Player *AHBplayer, AHBConfig *config);
|
|
void addNewAuctionBuyerBotBid(Player *AHBplayer, AHBConfig *config, WorldSession *session);
|
|
|
|
// friend class ACE_Singleton<AuctionHouseBot, ACE_Null_Mutex>;
|
|
AuctionHouseBot();
|
|
|
|
public:
|
|
static AuctionHouseBot* instance()
|
|
{
|
|
static AuctionHouseBot instance;
|
|
return &instance;
|
|
}
|
|
|
|
~AuctionHouseBot();
|
|
void Update();
|
|
void Initialize();
|
|
void InitializeConfiguration();
|
|
void LoadValues(AHBConfig*);
|
|
void DecrementItemCounts(AuctionEntry* ah, uint32 itemEntry);
|
|
void IncrementItemCounts(AuctionEntry* ah);
|
|
void Commands(uint32, uint32, uint32, char*);
|
|
ObjectGuid::LowType GetAHBplayerGUID() { return AHBplayerGUID; };
|
|
};
|
|
|
|
#define auctionbot AuctionHouseBot::instance()
|
|
|
|
#endif
|