public StatusEffectControl(GameInstance owner, Action<StatusEffectEntity2> onAttach, Action<StatusEffectEntity2> onDetach)
{
this.objectHolder = owner;
this.stat = owner.Stat;
this.onAttach = onAttach;
this.onDetach = onDetach;
}
public void SetUp()
{
var fileName = Path.GetTempPath() + Guid.NewGuid();
_db = new LiteDatabase(fileName);
_server = new StatServer(_db);
_server.Start("http://+:8081/");
}
public void AddBuff(int buffID, StatServer firerStat, Buff.Handle onBuff, Buff.Handle onDebuff)
{
StatusEffectEntity2 buffEntity = TableLoader.GetTable<StatusEffectEntity2>().Get(buffID);
CheckBuffType(buffEntity);
Buff buff = new Buff(buffEntity, firerStat, onBuff, onDebuff);
AddBuff(buff);
}
public virtual Action GenerateAction(StatServer stat)
{
string pattern = actionPattern;
if (!string.IsNullOrEmpty(animationName))
{
pattern = string.Format("Motion({0}; {1})", animationName, pattern);
}
return ActionPattern.Create(pattern).Generate(stat);
}
public void SetUp()
{
client = new Client.Client("http://127.0.0.1:8080/");
server = new StatServer();
server.ClearDatabaseAndCache();
var prefix = "http://+:8080/";
new Thread(() => server.Start(prefix)).Start();
}
public static Action Generate(string actionPattern, StatServer stat, params object[] args)
{
ActionPattern pattern = Create(actionPattern);
if (pattern != null)
{
return pattern.Generate(stat, args);
}
return null;
}
private static void RunServer(Options options)
{
using (var server = new StatServer(1))
{
server.Start(options.Prefix);
System.Console.ReadKey(true);
}
}
private static Dictionary<Enum, float> ParseStatMod(string[] token, Type targetStatType, StatServer firerStat)
{
Dictionary<Enum, float> statMod = new Dictionary<Enum, float>();
for (int i = 0; i < token.Length; i++)
{
string[] keyValue = token[i].Split("=".ToCharArray(), 2);
Enum key = EnumTool.Parse(targetStatType, keyValue[0]) as Enum;
float value = StatCalc.Calc(keyValue[1], firerStat);
statMod.Add(key, value);
}
return statMod;
}
static string ApplyStat(string actionPattern, StatServer stat)
{
while (actionPattern.Contains("["))
{
int startIndex = actionPattern.IndexOf("[");
int endIndex = actionPattern.IndexOf("]", startIndex);
string strStatType = actionPattern.Substring(startIndex + 1, endIndex - startIndex - 1);
Enum statType = EnumTool.Parse(strStatType) as Enum;
float statValue = stat.Get(statType);
actionPattern = actionPattern.Replace(actionPattern.Substring(startIndex, endIndex - startIndex + 1), statValue.ToString());
}
return actionPattern;
}
public static float Calc(string expr, StatServer statHolder)
{
expr = expr.Trim();
Assert.IsTrue(HasValidSquareBrackets(expr), "has invalid brackets \n" + expr);
var bracketedTokens = ExportBracketedTokens(expr).Distinct();
Assert.IsTrue(bracketedTokens.All(x => EnumTool.Parse(x) != null), "has invalid enum token \n" + expr);
Assert.IsTrue(bracketedTokens.All(x => statHolder.ContainsKey(EnumTool.Parse(x) as Enum)));
var statTable = bracketedTokens.ToDictionary(x => string.Format("[{0}]", x), x => statHolder.Get(EnumTool.Parse(x) as Enum));
foreach (var entity in statTable)
{
expr = expr.Replace(entity.Key, entity.Value.ToString());
}
return SimpleCalc.Calc(expr);
}
public void AddBuff(int buffID, StatServer firerStat, Buff.Handle onBuff, Buff.Handle onDebuff)
{
if (Constants.Instance.Editor.VerifyData)
{
try
{
buffControl.AddBuff(buffID, firerStat, onBuff, onDebuff);
}
catch(Exception e)
{
Debug.LogError("error on buff: " + buffID);
throw e;
}
}
else
{
buffControl.AddBuff(buffID, firerStat, onBuff, onDebuff);
}
}
public Buff(StatusEffectEntity2 entity, StatServer firerStat, Handle OnBuff, Handle OnDebuff)
{
statusEffectEntity = entity;
name = "Buff" + entity.statusEffectCode;
duration = entity.expireTime > 0 ? entity.expireTime : float.MaxValue;
this.spawnEffect = entity.spawnVFX;
this.spawnSound = entity.spawnSFX;
this.OnBuff = OnBuff;
this.OnDebuff = OnDebuff;
if (!string.IsNullOrEmpty(entity.targetStat))
{
Type targetStatType = Type.GetType(entity.targetStat);
if (targetStatType != null)
{
string strStatMod = StringTool.RemoveWhiteSpace(entity.statMod);
string[] modTokens = strStatMod.Split(";".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
statMod = ParseStatMod(modTokens, targetStatType, firerStat);
}
}
}
public void Start(string[] args)
{
m_Parameters = ParameterParse.ParseArguments(args, false /* firstOpFlag */, true /* multipleFiles */);
foreach (KeyValuePair <string, string> kvp in m_Parameters)
{
switch (kvp.Key)
{
case "-o":
case "--output":
m_outFile = kvp.Value;
break;
case "--verbose":
m_ParamVerbose++;
break;
case ParameterParse.LAST_PARAM:
m_inFiles = kvp.Value;
break;
case ParameterParse.ERROR_PARAM:
// if we get here, the parser found an error
Logger.Log("Parameter error: " + kvp.Value);
Logger.Log(Invocation());
return;
default:
Logger.Log("ERROR: UNKNOWN PARAMETER: " + kvp.Key);
Logger.Log(Invocation());
return;
}
}
GlobalRecordCollection globalCollection = new GlobalRecordCollection();
// Read in all log records into approriate structure type for each log line
if (!String.IsNullOrEmpty(m_inFiles))
{
string[] files = m_inFiles.Split(',');
foreach (string fileName in files)
{
if (fileName.Substring(0, connName.Length) == connName)
{
List <Records> syncConn = StatSyncConnector.Read(fileName);
globalCollection.Add(syncConn);
}
else if (fileName.Substring(0, sceneName.Length) == sceneName)
{
List <Records> syncConn = StatScene.Read(fileName);
globalCollection.Add(syncConn);
}
else if (fileName.Substring(0, serverName.Length) == serverName)
{
List <Records> syncConn = StatServer.Read(fileName);
globalCollection.Add(syncConn);
}
else
{
Logger.Log("No handler for file {0}", fileName);
}
}
}
// Compute the number of buckets based on the log records. Compute min and max.
double[] bucketTimes = ComputeBuckets(globalCollection, 10 /* bucket size in seconds */);
long numBuckets = bucketTimes.Length;
if (numBuckets > 0)
{
List <Records>[] buckets = DistributeToBucketArray(globalCollection, numBuckets);
GenerateOutput(globalCollection, buckets, bucketTimes);
}
}
public Action Generate(StatServer stat, params object[] args)
{
if (patternType == ActionPatternType.Action)
{
string modifiedStrValue = ApplyStat(strValue, stat);
modifiedStrValue = string.Format(modifiedStrValue, args);
string[] param = null;
if (list != null)
{
param = list.ToArray();
}
return new ActionSingle(target, type, SimpleCalc.Calc(modifiedStrValue), param);
}
if (patternType == ActionPatternType.Vector)
{
float speedX = SimpleCalc.Calc(ApplyStat(list[0], stat));
float speedY = SimpleCalc.Calc(ApplyStat(list[1], stat));
float gravity = SimpleCalc.Calc(ApplyStat(list[2], stat));
bool toLeft = bool.Parse(list[3]);
return new ActionVector(target, speedX, speedY, gravity, toLeft);
}
if (patternType == ActionPatternType.Projectile)
{
int? projectileId = Cast.To<int>(strValue);
Action action = children[0].Generate(stat, args);
return new ActionProjectile(projectileId.Value, action);
}
if (patternType == ActionPatternType.Delegate)
{
return new ActionDelegate(target, strValue);
}
if (patternType == ActionPatternType.Motion)
{
string animationName = strValue;
Action action = children[0].Generate(stat, args);
return new ActionMotion(animationName, action);
}
if (patternType == ActionPatternType.Sequence || patternType == ActionPatternType.Exclusive)
{
ActionSequence ret = patternType == ActionPatternType.Exclusive ? new ActionExclusive() : new ActionSequence();
foreach (var entity in children)
{
ret.Add(entity.Generate(stat, args));
}
return ret;
}
return null;
}
public void SetUp()
{
server = new StatServer();
server.Start(Prefix);
}
