public void ApplyTo(StatBase stat)
{
if (AppliesTo(stat.Name))
{
stat.AddModifier(this.Clone() as ModifierBase);
}
}
protected override void DrawSlot(int par1, int par2, int par3, int par4, Tessellator par5Tessellator)
{
StatBase statbase = (StatBase)StatList.GeneralStats[par1];
Field_27276_a.DrawString(GuiStats.GetFontRenderer(Field_27276_a), StatCollector.TranslateToLocal(statbase.GetName()), par2 + 2, par3 + 1, par1 % 2 != 0 ? 0x909090 : 0xffffff);
string s = statbase.Func_27084_a(GuiStats.GetStatsFileWriter(Field_27276_a).WriteStat(statbase));
Field_27276_a.DrawString(GuiStats.GetFontRenderer(Field_27276_a), s, (par2 + 2 + 213) - (int)GuiStats.GetFontRenderer(Field_27276_a).GetStringWidth(s), par3 + 1, par1 % 2 != 0 ? 0x909090 : 0xffffff);
}
private void Awake()
{
statsSys = statsSysBehav.StatsSystem;
thisStat = statsSys.GetStat(thisStatKey);
thisStat.statWasModified += OnStatUpdate;
OnStatUpdate();
}
private bool statChannel(ChannelInfo info)
{
if (!StatBase.canStat(info))
{
return(false);
}
ParamStat param = new ParamStat();
param.m_channel = info;
StatResult result = new StatResult();
foreach (var stat in m_statModule.Values)
{
stat.doStat(param, result);
}
Dictionary <string, object> newData = new Dictionary <string, object>();
newData.Add("genTime", info.m_statDay.Date.AddDays(-1));
newData.Add("channel", info.m_channelNum);
newData.Add("regeditCount", result.m_regeditCount);
newData.Add("deviceActivationCount", result.m_deviceActivationCount);
newData.Add("activeCount", result.m_activeCount);
newData.Add("totalIncome", result.m_totalIncome);
newData.Add("rechargePersonNum", result.m_rechargePersonNum);
newData.Add("rechargeCount", result.m_rechargeCount);
// newData.Add("2DayRegeditCount", result.m_2DayRegeditCount);
newData.Add("2DayRemainCount", result.m_2DayRemainCount);
// newData.Add("3DayRegeditCount", result.m_3DayRegeditCount);
newData.Add("3DayRemainCount", result.m_3DayRemainCount);
// newData.Add("7DayRegeditCount", result.m_7DayRegeditCount);
newData.Add("7DayRemainCount", result.m_7DayRemainCount);
//newData.Add("30DayRegeditCount", result.m_30DayRegeditCount);
newData.Add("30DayRemainCount", result.m_30DayRemainCount);
IMongoQuery imq1 = Query.EQ("genTime", BsonValue.Create(info.m_statDay.Date.AddDays(-1)));
IMongoQuery imq2 = Query.EQ("channel", BsonValue.Create(info.m_channelNum));
IMongoQuery imq = Query.And(imq1, imq2);
updateRemain(info, 1, result);
updateRemain(info, 3, result);
updateRemain(info, 7, result);
updateRemain(info, 30, result);
string str = MongodbAccount.Instance.ExecuteStoreByQuery(TableName.CHANNEL_TD, imq, newData);
return(str == string.Empty);
}
void OnStatChange(StatBase stat)
{
PlayerStat playerStat = (PlayerStat)stat;
hp.sliderValue = playerStat.HPScale;
hpLabel.text = Mathf.RoundToInt(playerStat.curHP).ToString();
energy.sliderValue = playerStat.curResourceScale;
energyLabel.text = Mathf.RoundToInt(playerStat.curResource).ToString();
}
protected override void Awake()
{
base.Awake();
mSprite = GetComponentInChildren<tk2dAnimatedSprite>();
mStats = GetComponentInChildren<StatBase>();
mActTarget = GetComponentInChildren<ActionTarget>();
//hook calls up
}
private void Init(StatsSystem statsSys)
{
sb = new StringBuilder();
this.statsSys = statsSys;
maxHealthStat = this.statsSys.GetStat(StatTypeFactory.GetType("Max Health"));
currentHealth = MaxHealth;
}
public static object Get(StatBase thisStatBase)
{
StatHelperData thisHelper = GetHelper(thisStatBase.StatTypeSystem);
object valueAsObject = new object();
if (thisHelper.OnGetPrintable != null)
valueAsObject = thisHelper.OnGet(thisStatBase);
return valueAsObject;
}
/// <summary>
/// Used by NetClientHandler.handleStatistic
/// </summary>
public virtual void IncrementStat(StatBase par1StatBase, int par2)
{
if (par1StatBase == null)
{
return;
}
if (!par1StatBase.IsIndependent)
{
base.AddStat(par1StatBase, par2);
}
}
/// <summary>
/// Adds a value to a statistic field.
/// </summary>
public override void AddStat(StatBase par1StatBase, int par2)
{
if (par1StatBase == null)
{
return;
}
if (par1StatBase.IsIndependent)
{
base.AddStat(par1StatBase, par2);
}
}
public void TestGetBonus()
{
StatBase stat = CreateStat(15);
Assert.AreEqual(0, stat.GetBonus(BonusType.Drain));
stat.SetBonus(BonusType.Drain, 12);
Assert.AreEqual(12, stat.GetBonus(BonusType.Drain));
stat.AddBonus(BonusType.Drain, 2);
Assert.AreEqual(14, stat.GetBonus(BonusType.Drain));
}
public void GenerateStatBaseObjects(System.Object obj, Dictionary <string, StatBaseValuesSet> defaults)
{
Dictionary <string, StatBase> objDict = BuiltObjectClasses[obj];
foreach (StatHandleObject sho in PropertiesToGenerate)
{
var objName = sho.Name;
StatBase sb = new StatBase(objName, FindHandleObjectByName(objName));
sb.SetFromSet(defaults[objName]);
objDict.Add(objName, sb);
}
}
public void TestHasBonus()
{
StatBase stat = CreateStat(15);
Assert.IsFalse(stat.HasBonus(BonusType.Drain));
stat.SetBonus(BonusType.Drain, 12);
Assert.IsTrue(stat.HasBonus(BonusType.Drain));
stat.AddBonus(BonusType.Drain, -12);
Assert.IsFalse(stat.HasBonus(BonusType.Drain));
}
public void TestBonusChangedEvent()
{
StatBase stat = CreateStat(15);
stat.BonusChanged += Stat_BonusChanged;
// set base
stat.Base = 13;
AssertNoBonusChangedReceived();
// set no bonus
stat.SetBonus(BonusType.Haste, 0);
AssertNoBonusChangedReceived();
// set a bonus
stat.SetBonus(BonusType.Haste, 3);
AssertBonusChangedReceived();
// set no bonus
stat.SetBonus(BonusType.Haste, 3);
AssertNoBonusChangedReceived();
// add no bonus
stat.AddBonus(BonusType.Haste, 0);
AssertNoBonusChangedReceived();
// add a bonus
stat.AddBonus(BonusType.Haste, 3);
AssertBonusChangedReceived();
// drain
stat.AddBonus(BonusType.Drain, -3);
AssertBonusChangedReceived();
// restore
stat.Restore();
AssertBonusChangedReceived();
// restore when not needed
stat.Restore();
AssertNoBonusChangedReceived();
stat.BonusChanged -= Stat_BonusChanged;
// set to different value after unregistering
stat.AddBonus(BonusType.Drain, -3);
AssertNoBonusChangedReceived();
}
private static bool OnHeal(StatBase __instance, ref float value)
{
try
{
var player = __instance.Hub.GetPlayer();
var allow = true;
SynapseController.Server.Events.Player.InvokePlayerHealEvent(player, ref value, ref allow);
return(allow);
}
catch (Exception e)
{
SynapseController.Server.Logger.Error($"Synapse-Event: PlayerHeal failed!!\n{e}");
}
return(true);
}
public void Calculate()
{
var statobj = StatManager.Instance.FindHandleObjectByName(statName);
StatBase sBase = StatManager.Instance.GetStatBase(this, statName);
if (sBase != null)
{
StatManager.Instance.SetStat(this, statName, StatBase.Stat.BASE, baseValue);
StatManager.Instance.SetStat(this, statName, StatBase.Stat.MULT, multiplier);
StatManager.Instance.SetStat(this, statName, StatBase.Stat.FLAT, flatAdded);
StatManager.Instance.SetStat(this, statName, StatBase.Stat.FLTMLT, flatMultiplier);
StatManager.Instance.SetStat(this, statName, StatBase.Stat.INC, increase);
var rs = StatManager.Instance.GetStat(this, statName);
Debug.Log(rs);
}
}
// 查询2个列表，1是dt这一天的注册用户，2是注册账号并且付费的账号
protected void queryAccList(ParamStat param, int days)
{
m_regeditAccList.Clear();
m_regeditWithRecharge.Clear();
DateTime dt = StatBase.getRemainRegTime(param.m_channel, days);
queryRegeditAcc(param, dt);
foreach (var acc in m_regeditAccList)
{
if (isRecharge(param, dt, acc))
{
m_regeditWithRecharge.Add(acc);
}
}
}
public long GetStat(StatBase s)
{
switch (s)
{
case StatBase.None:
return(0);
case StatBase.HP:
return(GetmHP());
case StatBase.STR:
return(GetSTR());
case StatBase.DEF:
return(GetDEF());
case StatBase.INT:
return(GetINT());
case StatBase.SPR:
return(GetSPR());
case StatBase.DEX:
return(GetDEX());
case StatBase.AGI:
return(GetAGI());
case StatBase.Speed:
return((long)GetSpeed());
case StatBase.Flat:
return(1);
case StatBase.CurrentHP:
return(cHP);
case StatBase.MissingHP:
return(GetmHP() - cHP);
}
//Default to STR.
Debug.Log("Somehow got a stat that wasn't really there?");
return(GetSTR());
}
// 更新往日留存
private void updateRemain(ChannelInfo info, int days, StatResult result)
{
IMongoQuery imq1 = Query.EQ("genTime", StatBase.getRemainRegTime(info, days));
IMongoQuery imq2 = Query.EQ("channel", BsonValue.Create(info.m_channelNum));
IMongoQuery imq = Query.And(imq1, imq2);
bool res = MongodbAccount.Instance.KeyExistsByQuery(TableName.CHANNEL_TD, imq);
if (res)
{
Dictionary <string, object> data = new Dictionary <string, object>();
switch (days)
{
case 1:
{
data.Add("2DayRemainCount", result.m_2DayRemainCountTmp);
data.Add("2DayRemainCountRecharge", result.m_2DayRemainCountRechargeTmp);
}
break;
case 3:
{
data.Add("3DayRemainCount", result.m_3DayRemainCountTmp);
data.Add("3DayRemainCountRecharge", result.m_3DayRemainCountRechargeTmp);
}
break;
case 7:
{
data.Add("7DayRemainCount", result.m_7DayRemainCountTmp);
data.Add("7DayRemainCountRecharge", result.m_7DayRemainCountRechargeTmp);
}
break;
case 30:
{
data.Add("30DayRemainCount", result.m_30DayRemainCountTmp);
data.Add("30DayRemainCountRecharge", result.m_30DayRemainCountRechargeTmp);
}
break;
}
MongodbAccount.Instance.ExecuteUpdateByQuery(TableName.CHANNEL_TD, imq, data);
}
}
private string StatModifiersToDisplayString(StatBase statBase)
{
var modifiers = statBase.StatModifiers;
modifiers = modifiers.OrderByDescending(x => x.Source).ToList();
// sort list by source?
sb.Clear();
sb.Append("Name: ").Append(statBase.Name).AppendLine();
sb.Append("Actual value: ").Append(statBase.ActualValue).AppendLine();
sb.Append("Base value: ").Append(statBase.BaseValue).AppendLine();
sb.Append("Growth rate: ").Append(statBase.GrowthRate).AppendLine();
if (modifiers.Count > 0)
{
sb.Append("Modifiers: ").AppendLine();
sb.Append("Source Value Modifier Type");
sb.AppendLine();
foreach (var mod in modifiers)
{
sb.Append("• ");
if (mod.Source == null)
{
sb.Append("N/A");
}
else
{
sb.Append(mod.Source);
}
sb.Append(" ");
sb.Append(mod.Value).Append(" ");
sb.Append(mod.Type).Append(" ");
sb.AppendLine();
}
}
return(sb.ToString());
}
public float GetStatStatus(StatBase s)
{
float r = 1;
for (int i = 0; i < myStatusEffects.Count; i++)
{
switch (s)
{
case StatBase.HP:
r *= myStatusEffects[i].HPmod;
break;
case StatBase.STR:
r *= myStatusEffects[i].STRmod;
break;
case StatBase.DEF:
r *= myStatusEffects[i].DEFmod;
break;
case StatBase.INT:
r *= myStatusEffects[i].INTmod;
break;
case StatBase.SPR:
r *= myStatusEffects[i].SPRmod;
break;
case StatBase.DEX:
r *= myStatusEffects[i].DEXmod;
break;
case StatBase.AGI:
r *= myStatusEffects[i].AGImod;
break;
case StatBase.Speed:
r *= myStatusEffects[i].speedMod;
break;
}
}
return(r);
}
private bool statChannel(ChannelInfo info)
{
if (!StatBase.canStat(info))
{
return(false);
}
beginStat("渠道[{0}]开始统计", info.m_channelName);
ParamStat param = new ParamStat();
param.m_channel = info;
StatResult result = new StatResult();
foreach (var stat in m_statModule.Values)
{
stat.doStat(param, result);
}
IMongoQuery imq = null;
Dictionary <string, object> newData = getData(result, info, ref imq);
foreach (var d in s_remain)
{
updateRemain(info, d, result);
updateDevRemain(info, d, result);
}
foreach (var d in s_totalRecharge)
{
updateTotalRecharge(info, d, result);
}
string str = MongodbAccount.Instance.ExecuteStoreByQuery(TableName.CHANNEL_TD, imq, newData);
endStat("渠道[{0}]结束统计", info.m_channelName);
return(str == string.Empty);
}
public object GetDatabaseTypeList(StatBase thisStatBase)
{
List<Database.DatabaseType> value = ((Stat<List<Database.DatabaseType>>)thisStatBase).Value;
return value;
}
public object GetDatabaseType(StatBase thisStatBase)
{
Database.DatabaseType value = ((Stat<Database.DatabaseType>)thisStatBase).Value;
return value;
}
public object GetBool(StatBase thisStatBase)
{
bool value = ((Stat<bool>)thisStatBase).Value;
return value;
}
public object[] GetArgumentsForUUID(StatBase statBase)
{
return new object[] { System.Guid.NewGuid() };
}
public object[] GetArgumentsForStringList(StatBase statBase)
{
return new object[] { };
}
public object[] GetArgumentsForStringIntDictionary(StatBase statBase)
{
return new object[] { };
}
public object GetImage(StatBase thisStatBase)
{
Image value = ((Stat<Image>)thisStatBase).Value;
return value;
}
public object GetPod(StatBase thisStatBase)
{
Pod value = ((Stat<Pod>)thisStatBase).Value;
return value;
}
private void UpdateTooltipText(StatBase statBase)
{
var displayStr = StatModifiersToDisplayString(statBase);
UpdateTooltipText(displayStr);
}
public object GetDouble(StatBase thisStatBase)
{
double value = ((Stat<double>)thisStatBase).Value;
return value;
}
public object GetStringList(StatBase thisStatBase)
{
List<string> value = ((Stat<List<string>>)thisStatBase).Value;
return value;
}
// ----------------------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------------------
// FILLMEIN
public object GetString(StatBase thisStatBase)
{
string value = ((Stat<string>)thisStatBase).Value;
return value;
}
public object[] GetArgumentsForBool(StatBase statBase)
{
return new object[] { false };
}
public StatBase Create(System.Type templateType, StatBase templateValue)
{
StatHelperData thisHelper = GetHelper(templateType);
StatBase newStat = (StatBase)Activator.CreateInstance(thisHelper.StatSystemType);
newStat.StatTypeSystem = thisHelper.TemplateSystemType;
object[] arguments = thisHelper.GetArguments(templateValue);
newStat.Initialise(arguments);
return newStat;
}
public static bool IsStatType(StatBase thisStatBase, StatType checkingStatType)
{
StatHelperData thisHelper = GetHelper(thisStatBase.StatTypeSystem);
if (thisHelper.StatType == checkingStatType)
return true;
return false;
}
public object GetFloat(StatBase thisStatBase)
{
float value = ((Stat<float>)thisStatBase).Value;
return value;
}
public object[] GetArgumentsForInt(StatBase statBase)
{
return new object[] { 0 };
}
public object GetInt(StatBase thisStatBase)
{
int value = ((Stat<int>)thisStatBase).Value;
return value;
}
public object[] GetArgumentsForPod(StatBase statBase)
{
return new object[] { };
}
public object GetPodList(StatBase thisStatBase)
{
List<Pod> value = ((Stat<List<Pod>>)thisStatBase).Value;
return value;
}
/*
// ----------------------------------------------------------------------------------------------------
* Keep for the time being but should be obsolete as they are replaced with internal gets on the stat base itsef.
// ----------------------------------------------------------------------------------------------------
// FILLMEIN
public static void Get(StatBase thisStatBase, ref string outValue)
{
string value = ((Stat<string>)thisStatBase).Value;
outValue = value;
}
public static void Get(StatBase thisStatBase, ref int outValue)
{
int value = ((Stat<int>)thisStatBase).Value;
outValue = value;
}
public static void Get(StatBase thisStatBase, ref float outValue)
{
float value = ((Stat<float>)thisStatBase).Value;
outValue = value;
}
public static void Get(StatBase thisStatBase, ref double outValue)
{
double value = ((Stat<double>)thisStatBase).Value;
outValue = value;
}
public static void Get(StatBase thisStatBase, ref bool outValue)
{
bool value = ((Stat<bool>)thisStatBase).Value;
outValue = value;
}
public static void Get(StatBase thisStatBase, ref List<string> outValue)
{
List<string> value = ((Stat<List<string>>)thisStatBase).Value;
outValue = value;
}
public static void Get(StatBase thisStatBase, ref Dictionary<string, int> outValue)
{
Dictionary<string, int> value = ((Stat<Dictionary<string, int>>)thisStatBase).Value;
outValue = value;
}
public static void Get(StatBase thisStatBase, ref Database.DatabaseType outValue)
{
Database.DatabaseType value = ((Stat<Database.DatabaseType>)thisStatBase).Value;
outValue = value;
}
public static void Get(StatBase thisStatBase, ref List<Database.DatabaseType> outValue)
{
List<Database.DatabaseType> value = ((Stat<List<Database.DatabaseType>>)thisStatBase).Value;
outValue = value;
}
public static void Get(StatBase thisStatBase, ref Pod outValue)
{
Pod value = ((Stat<Pod>)thisStatBase).Value;
outValue = value;
}
public static void Get(StatBase thisStatBase, ref List<Pod> outValue)
{
List<Pod> value = ((Stat<List<Pod>>)thisStatBase).Value;
outValue = value;
}
public static void Get(StatBase thisStatBase, ref System.Guid outValue)
{
System.Guid value = ((Stat<System.Guid>)thisStatBase).Value;
outValue = value;
}
*/
// ----------------------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------------------
// FILLMEIN
public object[] GetArgumentsForString(StatBase statBase)
{
char[] defaultString = { 'N', 'o', 'n', 'e' };
return new object[] { defaultString };
}
public object GetStringIntDictionary(StatBase thisStatBase)
{
Dictionary<string, int> value = ((Stat<Dictionary<string, int>>)thisStatBase).Value;
return value;
}
public object[] GetArgumentsForDouble(StatBase statBase)
{
return new object[] { 0.0 };
}
public object GetUUID(StatBase thisStatBase)
{
System.Guid value = ((Stat<System.Guid>)thisStatBase).Value;
return value;
}
public object[] GetArgumentsForFloat(StatBase statBase)
{
return new object[] { 0.0f };
}
public object[] GetArgumentsForDatabaseType(StatBase statBase)
{
Stat<Database.DatabaseType> databaseTypeStat = ((Stat<Database.DatabaseType>)statBase);
Database.DatabaseType databaseType = databaseTypeStat.Value;
return new object[] { databaseType .mDatabaseName, databaseType.mGroupIndex, databaseType .mDataIndex};
}
public static Player GetPlayer(this StatBase stat) => stat.Hub.GetPlayer();
public object[] GetArgumentsForDatabaseTypeList(StatBase statBase)
{
return new object[] { };
}
/// <summary>
/// Formats a given stat for human consumption.
/// </summary>
public string Format(int par1)
{
return(par1.ToString(StatBase.GetNumberFormat()));
}
