mirror of
https://github.com/SWG-Source/dsrc.git
synced 2026-07-31 00:15:54 -04:00
630 lines
19 KiB
Plaintext
630 lines
19 KiB
Plaintext
/***** INCLUDES ********************************************************/
|
|
include library.static_item;
|
|
include library.utils;
|
|
|
|
/***** CONSTANTS *******************************************************/
|
|
const string DATATABLE_SCHEDULE = "datatables/scheduled_drop/schedule.iff";
|
|
const string DATATABLE_PROMOTIONS = "datatables/scheduled_drop/promotions.iff";
|
|
const string DATATABLE_SERVER_PERCENTAGES = "datatables/scheduled_drop/server_percentages.iff";
|
|
|
|
const string DATATABLE_SCHEDULE_PROMO_NAME = "promotion_name";
|
|
const string DATATABLE_SCHEDULE_PROMO_LIST = "promotion_list";
|
|
const string DATATABLE_SCHEDULE_PROMO_TYPE = "promotion_type";
|
|
const string DATATABLE_SCHEDULE_PROMO_MAX_DROPS = "max_drops";
|
|
|
|
const string DATATABLE_SCHEDULE_PROMO_START_HOUR = "start_hour";
|
|
const string DATATABLE_SCHEDULE_PROMO_START_MINUTE = "start_minute";
|
|
const string DATATABLE_SCHEDULE_PROMO_START_SECOND = "start_second";
|
|
|
|
const string DATATABLE_SCHEDULE_PROMO_START_MONTH = "start_month";
|
|
const string DATATABLE_SCHEDULE_PROMO_START_DAY = "start_day";
|
|
const string DATATABLE_SCHEDULE_PROMO_START_YEAR = "start_year";
|
|
|
|
const string DATATABLE_SCHEDULE_PROMO_END_HOUR = "end_hour";
|
|
const string DATATABLE_SCHEDULE_PROMO_END_MINUTE = "end_minute";
|
|
const string DATATABLE_SCHEDULE_PROMO_END_SECOND = "end_second";
|
|
|
|
const string DATATABLE_SCHEDULE_PROMO_END_MONTH = "end_month";
|
|
const string DATATABLE_SCHEDULE_PROMO_END_DAY = "end_day";
|
|
const string DATATABLE_SCHEDULE_PROMO_END_YEAR = "end_year";
|
|
|
|
const string DATATABLE_SERVER_PERCENTAGES_MAX = "max_drop_percentage";
|
|
|
|
const string DATATABLE_PROMO_LIST = "promotion_list";
|
|
const string DATATABLE_PROMO_STATIC_ITEM_NAME = "card_name";
|
|
const string DATATABLE_PROMO_WEIGHT = "weight";
|
|
|
|
const string CLUSTER_OBJVAR_PROMOTIONS = "tcg.promotions";
|
|
const string CLUSTER_OBJVAR_PROMOTION_COUNTS = "tcg.counts";
|
|
const string CLUSTER_OBJVAR_LAST_UPDATE = "tcg.last_update_date";
|
|
|
|
const string PLAYER_SCRIPTVAR_DROP_TIME = "tcg.lastCardDropTime";
|
|
|
|
const int DROP_CHANCE_COMBAT_NORMAL = 400;
|
|
const int DROP_CHANCE_COMBAT_ELITE = 320;
|
|
const int DROP_CHANCE_COMBAT_BOSS = 200;
|
|
const int DROP_CHANCE_COMBAT_SPACE = 400;
|
|
const int DROP_CHANCE_ENTERTAINER = 400;
|
|
const int DROP_CHANCE_CRAFTER = 300;
|
|
|
|
const int SYSTEM_UNKNOWN = 0;
|
|
const int SYSTEM_COMBAT_NORMAL = 1;
|
|
const int SYSTEM_COMBAT_ELITE = 2;
|
|
const int SYSTEM_COMBAT_BOSS = 3;
|
|
const int SYSTEM_COMBAT_SPACE = 4;
|
|
const int SYSTEM_ENTERTAINER = 5;
|
|
const int SYSTEM_CRAFTER = 6;
|
|
|
|
const int CARD_DELAY_COMBAT_NORMAL = 10;
|
|
const int CARD_DELAY_COMBAT_ELITE = 12;
|
|
const int CARD_DELAY_COMBAT_BOSS = 20;
|
|
const int CARD_DELAY_COMBAT_SPACE = 10;
|
|
const int CARD_DELAY_ENTERTAINER = 20;
|
|
const int CARD_DELAY_CRAFTER = 20;
|
|
const int CARD_DELAY_DEFAULT = 20;
|
|
|
|
const string [] systemTypes = { "ERROR_unknown", "combat_normal", "combat_elite", "combat_boss", "combat_space", "entertainer", "crafter" };
|
|
|
|
void testingSpam(obj_id self, string str)
|
|
{
|
|
if(isIdValid(self) && isGod(self) && hasObjVar(self, "qa_tcg"))
|
|
sendSystemMessageTestingOnly(self, str);
|
|
}
|
|
|
|
string [] getPromotionList()
|
|
{
|
|
return dataTableGetStringColumn(DATATABLE_PROMOTIONS, DATATABLE_PROMO_LIST);
|
|
}
|
|
|
|
string [] getStaticItems()
|
|
{
|
|
return dataTableGetStringColumn(DATATABLE_PROMOTIONS, DATATABLE_PROMO_STATIC_ITEM_NAME);
|
|
}
|
|
|
|
int [] getStaticItemWeights()
|
|
{
|
|
return dataTableGetIntColumn(DATATABLE_PROMOTIONS, DATATABLE_PROMO_WEIGHT);
|
|
}
|
|
|
|
int getWeightTotal(dictionary [] promotionList)
|
|
{
|
|
int weight = 0;
|
|
|
|
if(promotionList == null || promotionList.length <= 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
for(int i = 0, j = promotionList.length; i < j; i++)
|
|
{
|
|
weight += promotionList[i].getInt("promotionWeight");
|
|
}
|
|
|
|
return weight;
|
|
}
|
|
|
|
int getRandomStaticItem(dictionary [] promotionList)
|
|
{
|
|
if(promotionList == null || promotionList.length <= 0)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
int weightTotal = getWeightTotal(promotionList);
|
|
int roll = rand(1, weightTotal);
|
|
int index = -1;
|
|
int currentWeight = 0;
|
|
|
|
for(int i = 0, j = promotionList.length; i < j; i++)
|
|
{
|
|
currentWeight += promotionList[i].getInt("promotionWeight");
|
|
|
|
if(currentWeight >= roll)
|
|
{
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return index;
|
|
}
|
|
|
|
dictionary [] getStaticItemsForAllPromotions(string [] promotionNames)
|
|
{
|
|
if(promotionNames == null || promotionNames.length <= 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// concatArrays
|
|
string [] allPromotionLists = getPromotionList();
|
|
string [] allItems = getStaticItems();
|
|
int [] allWeights = getStaticItemWeights();
|
|
|
|
if(allItems == null || allItems.length <= 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Now check to see what promotions are in the list versus what promotions are actually running
|
|
|
|
resizeable dictionary [] allStaticItems = new dictionary[0];
|
|
|
|
for(int i = 0, j = promotionNames.length; i < j; i++)
|
|
{
|
|
for(int k = 0, l = allItems.length; k < l; k++)
|
|
{
|
|
string promotionList = dataTableGetString(DATATABLE_SCHEDULE, promotionNames[i], DATATABLE_SCHEDULE_PROMO_LIST);
|
|
|
|
if(allPromotionLists[k] == promotionList)
|
|
{
|
|
dictionary cardEntry = new dictionary();
|
|
|
|
cardEntry.put("promotionName", promotionNames[i]);
|
|
cardEntry.put("promotionList", allPromotionLists[k]);
|
|
cardEntry.put("promotionItem", allItems[k]);
|
|
cardEntry.put("promotionWeight", allWeights[k]);
|
|
|
|
allStaticItems = utils.addElement(allStaticItems, cardEntry);
|
|
}
|
|
}
|
|
}
|
|
|
|
return allStaticItems;
|
|
}
|
|
|
|
string [] getSchedulerPromotions()
|
|
{
|
|
return dataTableGetStringColumn(DATATABLE_SCHEDULE, DATATABLE_SCHEDULE_PROMO_NAME);
|
|
}
|
|
|
|
int [] getSchedulerMaxDrops()
|
|
{
|
|
return dataTableGetIntColumn(DATATABLE_SCHEDULE, DATATABLE_SCHEDULE_PROMO_MAX_DROPS);
|
|
}
|
|
|
|
string [] getScheduledPromotions(string promotionType)
|
|
{
|
|
obj_id self = getSelf();
|
|
|
|
string [] promotions = getSchedulerPromotions();
|
|
|
|
if(promotions == null || promotions.length <= 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
resizeable string [] scheduledPromotions = new string[0];
|
|
|
|
int currentDate = getCalendarTime();
|
|
|
|
testingSpam(self, "currentDate: " + currentDate + " realTime: " + getCalendarTimeStringLocal(currentDate));
|
|
|
|
for(int i = 0, promotionsLength = promotions.length; i < promotionsLength; i++)
|
|
{
|
|
dictionary currentPromotion = dataTableGetRow(DATATABLE_SCHEDULE, promotions[i]);
|
|
|
|
if(!currentPromotion.getString(DATATABLE_SCHEDULE_PROMO_TYPE).equals(promotionType))
|
|
{
|
|
// LOG("tcg", "Promo invalid. " + currentPromotion.getString(DATATABLE_SCHEDULE_PROMO_TYPE) + " for type: " + promotionType + " result: " + currentPromotion.getString(DATATABLE_SCHEDULE_PROMO_TYPE).equals(promotionType));
|
|
continue;
|
|
}
|
|
|
|
int startHour = currentPromotion.getInt(DATATABLE_SCHEDULE_PROMO_START_HOUR);
|
|
int startMinute = currentPromotion.getInt(DATATABLE_SCHEDULE_PROMO_START_MINUTE);
|
|
int startSecond = currentPromotion.getInt(DATATABLE_SCHEDULE_PROMO_START_SECOND);
|
|
|
|
int startMonth = currentPromotion.getInt(DATATABLE_SCHEDULE_PROMO_START_MONTH);
|
|
int startDay = currentPromotion.getInt(DATATABLE_SCHEDULE_PROMO_START_DAY);
|
|
int startYear = currentPromotion.getInt(DATATABLE_SCHEDULE_PROMO_START_YEAR);
|
|
|
|
// Not all months are equal in length, so we must give some slack.
|
|
// getCalendarTime(int year, int month, int day, int hour, int minute, int second);
|
|
|
|
int startDate = getCalendarTime(startYear, startMonth, startDay, startHour, startMinute, startSecond);
|
|
|
|
int endHour = currentPromotion.getInt(DATATABLE_SCHEDULE_PROMO_END_HOUR);
|
|
int endMinute = currentPromotion.getInt(DATATABLE_SCHEDULE_PROMO_END_MINUTE);
|
|
int endSecond = currentPromotion.getInt(DATATABLE_SCHEDULE_PROMO_END_SECOND);
|
|
|
|
int endMonth = currentPromotion.getInt(DATATABLE_SCHEDULE_PROMO_END_MONTH);
|
|
int endDay = currentPromotion.getInt(DATATABLE_SCHEDULE_PROMO_END_DAY);
|
|
int endYear = currentPromotion.getInt(DATATABLE_SCHEDULE_PROMO_END_YEAR);
|
|
|
|
int endDate = getCalendarTime(endYear, endMonth, endDay, endHour, endMinute, endSecond);
|
|
|
|
testingSpam(self, "Scheduled Promotion: " + currentPromotion.getString(DATATABLE_SCHEDULE_PROMO_NAME) + " Start: " + startDate + " End: " + endDate);
|
|
|
|
if(startDate <= currentDate && endDate >= currentDate)
|
|
{
|
|
scheduledPromotions = utils.addElement(scheduledPromotions, currentPromotion.getString(DATATABLE_SCHEDULE_PROMO_NAME));
|
|
}
|
|
}
|
|
|
|
return scheduledPromotions;
|
|
}
|
|
|
|
// Cluster support
|
|
|
|
// Maximum amount of cards to drop in a promotion.
|
|
int getPromotionMaxDrop(string promotion)
|
|
{
|
|
return modifyPromotionCountByServer(dataTableGetInt(DATATABLE_SCHEDULE, promotion, DATATABLE_SCHEDULE_PROMO_MAX_DROPS));
|
|
}
|
|
|
|
// All promotions and their maximum drops from the schedule datatable.
|
|
dictionary [] getPromotionMaxDrops(string [] promotions)
|
|
{
|
|
obj_id self = getSelf();
|
|
|
|
resizeable int [] maxDrops = new int[0];
|
|
|
|
string [] allPromotions = getSchedulerPromotions();
|
|
int [] allDrops = getSchedulerMaxDrops();
|
|
|
|
resizeable dictionary [] promotionsWithDrops = new dictionary[0];
|
|
|
|
testingSpam(self, "getPromotionMaxDrops allPromotions.length: " + allPromotions.length + " promotions.length: " + promotions.length);
|
|
|
|
// Big O notation on this makes baby Monty cry...
|
|
for(int i = 0, j = promotions.length; i < j; i++)
|
|
{
|
|
for(int k = 0, l = allPromotions.length; k < l; k++)
|
|
{
|
|
testingSpam(self, "allPromotions[" + k + "]: " + allPromotions[k] + " promotions[" + i + "]: " + promotions[i] + " allDrops[" + k + "]: " + allDrops[k]);
|
|
|
|
if(promotions[i].equals(allPromotions[k]))
|
|
{
|
|
dictionary tempPromotion = new dictionary();
|
|
|
|
tempPromotion.put("promotion", promotions[i]);
|
|
tempPromotion.put("promotionMaxDrops", modifyPromotionCountByServer(allDrops[k]));
|
|
|
|
promotionsWithDrops = utils.addElement(promotionsWithDrops, tempPromotion);
|
|
}
|
|
}
|
|
}
|
|
|
|
return promotionsWithDrops;
|
|
}
|
|
|
|
int modifyPromotionCountByServer(int promotionCount)
|
|
{
|
|
string serverName = toLower(getConfigSetting("CentralServer", "clusterName"));
|
|
float percentOfCount = 0.0f;
|
|
|
|
if(serverName == null || serverName.length() <= 0)
|
|
{
|
|
percentOfCount = 0.01f;
|
|
}
|
|
else
|
|
{
|
|
percentOfCount = dataTableGetFloat(scheduled_drop.DATATABLE_SERVER_PERCENTAGES, serverName, scheduled_drop.DATATABLE_SERVER_PERCENTAGES_MAX);
|
|
|
|
if(percentOfCount <= 0.0f)
|
|
{
|
|
percentOfCount = 0.01f;
|
|
}
|
|
}
|
|
|
|
return (int)((float)promotionCount * percentOfCount);
|
|
}
|
|
|
|
// When did this last cluster get updated?
|
|
int getLastClusterUpdateTime()
|
|
{
|
|
obj_id planet = getPlanetByName("tatooine");
|
|
|
|
return getIntObjVar(planet, CLUSTER_OBJVAR_LAST_UPDATE);
|
|
}
|
|
|
|
void setLastClusterUpdateTime(int date)
|
|
{
|
|
obj_id planet = getPlanetByName("tatooine");
|
|
|
|
setObjVar(planet, CLUSTER_OBJVAR_LAST_UPDATE, date);
|
|
}
|
|
|
|
void removeLastClusterUpdateTime()
|
|
{
|
|
obj_id planet = getPlanetByName("tatooine");
|
|
|
|
if(!isIdValid(planet))
|
|
{
|
|
return;
|
|
}
|
|
|
|
removeObjVar(planet, CLUSTER_OBJVAR_LAST_UPDATE);
|
|
}
|
|
|
|
void removeClusterPromotions()
|
|
{
|
|
obj_id planet = getPlanetByName("tatooine");
|
|
|
|
string [] promotions = getSchedulerPromotions();
|
|
|
|
for(int i = 0, j = promotions.length; i < j; i++)
|
|
{
|
|
removeObjVar(planet, "tcg." + promotions[i] + ".count");
|
|
}
|
|
}
|
|
|
|
// Send a message to the cluster
|
|
void setClusterPromotions(dictionary [] promotionsWithMaxDrops)
|
|
{
|
|
// All our data is centralized on tatooine and then replicated automatically through proxy to the other planets
|
|
obj_id planet = getPlanetByName("tatooine");
|
|
|
|
if(!hasScript(planet, "systems.tcg.planet_scheduler"))
|
|
{
|
|
attachScript(planet, "systems.tcg.planet_scheduler");
|
|
}
|
|
|
|
// Message the cluster to erase the tcg objvar tree.
|
|
if(promotionsWithMaxDrops == null || promotionsWithMaxDrops.length <= 0)
|
|
{
|
|
messageTo(planet, "clearPromotions", null, 1.0f, false);
|
|
return;
|
|
}
|
|
|
|
for(int i = 0, j = promotionsWithMaxDrops.length; i < j; i++)
|
|
{
|
|
messageTo(planet, "setPromotion", promotionsWithMaxDrops[i], 1.0f, false);
|
|
}
|
|
}
|
|
|
|
// Determine if the cluster needs to be initialized or simply updated and place the data on the Tatooine planet object.
|
|
void instantiatePromotionsOnCluster()
|
|
{
|
|
int lastUpdate = getLastClusterUpdateTime();
|
|
int currentDate = getCalendarTime();
|
|
|
|
// If we have instantiated the data on the planet within the last thirty minutes, do not do anything.
|
|
if(currentDate - lastUpdate < 1800)
|
|
{
|
|
// LOG("planet", "instantiatePromotionsOnCluster already completed on this planet");
|
|
return;
|
|
}
|
|
|
|
// Setup cards
|
|
string [] currentPromotions = getScheduledPromotions("card");
|
|
|
|
obj_id self = getSelf();
|
|
|
|
testingSpam(self, "Card promotions length: " + currentPromotions.length);
|
|
|
|
// If no promotions are running, then erase the cluster promotions.
|
|
if(currentPromotions == null)
|
|
{
|
|
setClusterPromotions(null);
|
|
}
|
|
else
|
|
{
|
|
setClusterPromotions(getPromotionMaxDrops(currentPromotions));
|
|
}
|
|
|
|
// Setup boosters/starters
|
|
currentPromotions = getScheduledPromotions("item");
|
|
|
|
testingSpam(self, "Item promotions length: " + currentPromotions.length);
|
|
|
|
if(currentPromotions != null && currentPromotions.length > 0)
|
|
{
|
|
setClusterPromotions(getPromotionMaxDrops(currentPromotions));
|
|
}
|
|
}
|
|
|
|
// Make sure the promotions on the cluster have cards they can still drop. -1 is infinite drops.
|
|
string [] validatePromotionsVersusCluster(string [] promotionNames)
|
|
{
|
|
obj_id planet = getPlanetByName("tatooine");
|
|
|
|
if(!isIdValid(planet) || !exists(planet) || promotionNames == null || promotionNames.length <= 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
resizeable string [] validatedPromotions = new string[0];
|
|
|
|
for(int i = 0, j = promotionNames.length; i < j; i++)
|
|
{
|
|
int countLeft = getIntObjVar(planet, "tcg." + promotionNames[i] + ".count");
|
|
|
|
// There are still available cards to drop or the drop is infinite?
|
|
if(countLeft > 0 || countLeft == -1)
|
|
{
|
|
validatedPromotions = utils.addElement(validatedPromotions, promotionNames[i]);
|
|
}
|
|
}
|
|
|
|
return validatedPromotions;
|
|
}
|
|
|
|
int cardDelay(int systemToDrop)
|
|
{
|
|
switch(systemToDrop)
|
|
{
|
|
case SYSTEM_COMBAT_NORMAL: return CARD_DELAY_COMBAT_NORMAL;
|
|
case SYSTEM_COMBAT_ELITE: return CARD_DELAY_COMBAT_ELITE;
|
|
case SYSTEM_COMBAT_BOSS: return CARD_DELAY_COMBAT_BOSS;
|
|
case SYSTEM_COMBAT_SPACE: return CARD_DELAY_COMBAT_SPACE;
|
|
case SYSTEM_ENTERTAINER: return CARD_DELAY_ENTERTAINER;
|
|
case SYSTEM_CRAFTER: return CARD_DELAY_CRAFTER;
|
|
case SYSTEM_UNKNOWN: return CARD_DELAY_DEFAULT;
|
|
default: return CARD_DELAY_DEFAULT;
|
|
}
|
|
}
|
|
|
|
boolean hasCardDelay(obj_id player, int systemToDrop)
|
|
{
|
|
int gameTime = getGameTime();
|
|
|
|
if(!isIdValid(player))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if(isGod(player) && hasObjVar(player, "qa_tcg_always_drop"))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if(utils.hasScriptVar(player, PLAYER_SCRIPTVAR_DROP_TIME))
|
|
{
|
|
int lastDropTime = utils.getIntScriptVar(player, PLAYER_SCRIPTVAR_DROP_TIME);
|
|
|
|
if(gameTime < lastDropTime + cardDelay(systemToDrop))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
boolean isTCGTurnedOn()
|
|
{
|
|
// return utils.checkConfigFlag("ScriptFlags","TCGTurnedOn");
|
|
string config = getConfigSetting("GameServer", "TCGTurnedOn");
|
|
|
|
LOG("tcg", "config: " + config);
|
|
|
|
if(config != null && config.equals("off"))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
*/
|
|
|
|
// "can haz card?"
|
|
boolean canDropCard(int systemToDrop)
|
|
{
|
|
switch(systemToDrop)
|
|
{
|
|
case SYSTEM_COMBAT_NORMAL: return (rand(1, DROP_CHANCE_COMBAT_NORMAL) == 1 ? true : false);
|
|
case SYSTEM_COMBAT_ELITE: return (rand(1, DROP_CHANCE_COMBAT_ELITE) == 1 ? true : false);
|
|
case SYSTEM_COMBAT_BOSS: return (rand(1, DROP_CHANCE_COMBAT_BOSS) == 1 ? true : false);
|
|
case SYSTEM_COMBAT_SPACE: return (rand(1, DROP_CHANCE_COMBAT_SPACE) == 1 ? true : false);
|
|
case SYSTEM_ENTERTAINER: return (rand(1, DROP_CHANCE_ENTERTAINER) == 1 ? true : false);
|
|
case SYSTEM_CRAFTER: return (rand(1, DROP_CHANCE_CRAFTER) == 1 ? true : false);
|
|
case SYSTEM_UNKNOWN: return false;
|
|
default: return false;
|
|
}
|
|
}
|
|
|
|
obj_id dropCard(int systemToDrop, obj_id container)
|
|
{
|
|
obj_id self = getSelf();
|
|
|
|
obj_id card = null;
|
|
string typeName = "card";
|
|
string staticItemName = "";
|
|
string promotionName = "";
|
|
|
|
/*
|
|
if(!isTCGTurnedOn())
|
|
{
|
|
if(isIdValid(self) && isGod(self) && hasObjVar(self, "qa_tcg"))
|
|
{
|
|
sendSystemMessageTestingOnly(self, "TCG: Promotion is turned off on this server.");
|
|
}
|
|
|
|
return null;
|
|
}
|
|
*/
|
|
|
|
// Always check to see if the cluster has been updated.
|
|
instantiatePromotionsOnCluster();
|
|
|
|
if(!isIdValid(container) || !exists(container))
|
|
{
|
|
CustomerServiceLog("tcg", "ERROR: dropCard() Container to place card in is null.");
|
|
return null;
|
|
}
|
|
|
|
// LOG("tcg", "dropCard() typeName: " + typeName);
|
|
|
|
string [] scheduledPromotions = getScheduledPromotions(typeName);
|
|
|
|
// Switch to items, if no card promotions are running.
|
|
if(scheduledPromotions == null || scheduledPromotions.length <= 0)
|
|
{
|
|
typeName = "item";
|
|
scheduledPromotions = getScheduledPromotions(typeName);
|
|
|
|
if(scheduledPromotions == null || scheduledPromotions.length <= 0)
|
|
{
|
|
testingSpam(self, "Scheduled Drops: Promotion log is empty.");
|
|
|
|
CustomerServiceLog("tcg", "No promotions");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
string [] promotions = validatePromotionsVersusCluster(scheduledPromotions);
|
|
|
|
// LOG("tcg", "dropCard() promotions.length: " + promotions.length);
|
|
|
|
if(promotions == null || promotions.length <= 0)
|
|
{
|
|
testingSpam(self, "TCG: Promotions from cluster is empty.");
|
|
|
|
CustomerServiceLog("tcg", "No valid promotions left on cluster.");
|
|
return null;
|
|
}
|
|
|
|
dictionary [] promotionalItems = getStaticItemsForAllPromotions(promotions);
|
|
|
|
// LOG("tcg", "dropCard() promotions.length: " + promotions.length + " promotionalItems.length: " + promotionalItems.length);
|
|
|
|
int index = getRandomStaticItem(promotionalItems);
|
|
|
|
// LOG("tcg", "dropCard() promotions.length: " + promotions.length + " promotionalItems.length: " + promotionalItems.length + " index: " + index);
|
|
|
|
if(promotionalItems.length > index && index >= 0)
|
|
{
|
|
staticItemName = promotionalItems[index].getString("promotionItem");
|
|
promotionName = promotionalItems[index].getString("promotionName");
|
|
}
|
|
else
|
|
{
|
|
CustomerServiceLog("tcg", "ERROR dropCard() tcg.getRandomStaticItem(promotionalItems) out of bounds index for type: " + staticItemName + ".");
|
|
return null;
|
|
}
|
|
|
|
card = static_item.createNewItemFunction(staticItemName, container);
|
|
|
|
if(!isIdValid(card) || !exists(card))
|
|
{
|
|
if(isIdValid(self) && isGod(self) && hasObjVar(self, "qa_tcg"))
|
|
{
|
|
sendSystemMessageTestingOnly(self, "TCG: Static item creation failed: " + staticItemName);
|
|
}
|
|
|
|
CustomerServiceLog("tcg", "ERROR dropCard() could not create a " + typeName + " (" + staticItemName + ") with target container " + container);
|
|
return null;
|
|
}
|
|
|
|
|
|
// Log what was dropped in the "tcg_drop" file. This should be the only place we log anything to that file.
|
|
// The general "tcg" file is for errors and notifications.
|
|
obj_id planet = getPlanetByName("tatooine");
|
|
int remainder = getIntObjVar(planet, "tcg." + promotionName + ".count");
|
|
|
|
testingSpam(self, ",Source_system," + systemTypes[systemToDrop] + ",Dropped_type," + typeName + ",Remaining_left," + remainder +",Promotion," + promotionName + ",Dropped_static_item," + staticItemName + ",Container_dropped_in," + container + ",Container_name," + getName(container) + ",Time," + getCalendarTimeStringLocal(getCalendarTime()));
|
|
|
|
CustomerServiceLog("tcg_drop", ",Source_system," + systemTypes[systemToDrop] + ",Dropped_type," + typeName + ",Remaining_left," + remainder +",Promotion," + promotionName + ",Dropped_static_item," + staticItemName + ",Container_dropped_in," + container + ",Container_name," + getName(container) + ",Time," + getCalendarTimeStringLocal(getCalendarTime()));
|
|
|
|
// Decriment the promotion it's associated with.
|
|
dictionary params = new dictionary();
|
|
|
|
params.put("promotionName", promotionName);
|
|
|
|
messageTo(planet, "reducePromotion", params, 1.0f, true);
|
|
|
|
return card;
|
|
}
|