public async Task SetUpAsync()
{
_modifierDefinitions = await GameData.Modifiers.ConfigureAwait(false);
_statTranslator = (await GameData.StatTranslators.ConfigureAwait(false))[StatTranslationFileNames.Main];
_parser = await ParserTask.ConfigureAwait(false);
}
/// <summary>
/// Add new parsertask
/// </summary>
/// <param name="parsertask"></param>
/// <returns>id of new parser</returns>
public int Add(ParserTaskDTO parsertask)
{
if (parsertask == null)
{
return(-1);
}
ParserTask parsertaskDb = Mapper.Map <ParserTask>(parsertask);
try
{
parsertaskDb.Category = uOW.CategoryRepo.GetByID(parsertaskDb.CategoryId);
parsertaskDb.WebShop = uOW.WebShopRepo.GetByID(parsertaskDb.WebShopId);
parsertaskDb.Status = Common.Enum.Status.NotFinished;
parsertaskDb.LastChange = DateTime.Now;
uOW.ParserRepo.Insert(parsertaskDb);
uOW.Save();
return(parsertaskDb.Id);
}
catch (Exception ex)
{
logger.Error(ex.Message);
return(-1);
}
}
public async Task SetUpAsync()
{
_baseItemDefinitions = await GameData.BaseItems.ConfigureAwait(false);
_statTranslator = await _statTranslatorTask.ConfigureAwait(false);
_parser = await ParserTask.ConfigureAwait(false);
}
public static Task CreateTaskFromNode(NodeTask node, Task parent)
{
Task n = ParserTask.GetTask(node);
if (n != null)
{
n.Parent = parent;
}
else
{
Logger.Log("!Warning:Unknown task type: " + node.Type);
return(null);
}
return(n);
}
public static async Task ClassInit()
{
_builderFactories = await BuilderFactoriesTask.ConfigureAwait(false);
_metaStats = _builderFactories.MetaStatBuilders;
var parser = await ParserTask.ConfigureAwait(false);
var modSource = new ModifierSource.Global();
_givenMods = parser.ParseGivenModifiers()
.Append(
new Modifier(
Build(_builderFactories.DamageTypeBuilders.Physical.Damage.Taken
.For(_builderFactories.EntityBuilders.Enemy)),
Form.Increase, new Constant(20), modSource),
new Modifier(
Build(_builderFactories.DamageTypeBuilders.Physical.Resistance
.For(_builderFactories.EntityBuilders.Enemy)),
Form.BaseSet, new Constant(60), modSource),
new Modifier(
Build(_builderFactories.DamageTypeBuilders.Physical.DamageMultiplier),
Form.BaseAdd, new Constant(75), modSource),
new Modifier(
Build(_builderFactories.StatBuilders.Level),
Form.BaseSet, new Constant(90), modSource),
new Modifier(
Build(_builderFactories.DamageTypeBuilders.Physical.Damage.WithSkills),
Form.BaseSet, new Constant(5), modSource),
new Modifier(
Build(_builderFactories.StatBuilders.Accuracy),
Form.BaseAdd, new Constant(1000), modSource),
new Modifier(
Build(_metaStats.SkillHitDamageSource),
Form.BaseSet, new Constant((int)DamageSource.Attack), modSource),
new Modifier(
Build(_metaStats.SkillUsesHand(AttackDamageHand.MainHand)),
Form.BaseSet, new Constant(true), modSource),
new Modifier(
Build(_metaStats.SkillUsesHand(AttackDamageHand.OffHand)),
Form.BaseSet, new Constant(true), modSource),
new Modifier(
Build(_builderFactories.EquipmentBuilders.Equipment[ItemSlot.MainHand].ItemTags),
Form.TotalOverride, new Constant(Tags.Sword.EncodeAsDouble()), modSource))
.ToList();
}
/// <inheritdoc />
public void Parse(GrammarReference grammar, string parserRuleName, string text, ParseOption options)
{
lock (_Padlock)
{
var nextRun = CalculateNextRunTime(_PreviousNodeQty, 50, 5, 1000);
var work = new ParserWorkItem(grammar, parserRuleName, text, options, nextRun);
QueuedWork.Enqueue(work);
_LastQueuedTime = DateTime.Now;
if (ParserTask.IsCompleted)
{
ParserTask = new Task(ParserWorkLoop);
}
if (ParserTask.Status != TaskStatus.Running)
{
ParserTask.Start();
}
}
}
private static void RegisterTasks()
{
ParserTask.registeredTasks.Clear();
Type taskType = typeof(ParserTask);
Assembly cur = Assembly.GetExecutingAssembly();
Assembly[] allAsms = System.AppDomain.CurrentDomain.GetAssemblies();
// this is only sorted for debugging
SortedList <string, Type> internalTypes = new SortedList <string, Type>();
SortedList <string, Type> userTypes = new SortedList <string, Type>();
foreach (Type t in cur.GetTypes())
{
if (t.IsSubclassOf(taskType) && !t.IsAbstract)
{
internalTypes[t.FullName] = t;
}
}
foreach (Assembly a in allAsms)
{
if (a == cur)
{
continue; // already did them
}
try
{
foreach (Type t in a.GetTypes())
{
if (t.IsSubclassOf(taskType) && !t.IsAbstract)
{
userTypes[t.FullName] = t;
}
}
}
catch { }
}
List <Type> allTypes = new List <Type>();
allTypes.AddRange(internalTypes.Values);
allTypes.AddRange(userTypes.Values);
foreach (Type t in allTypes)
{
try
{
FieldInfo f = t.GetField("ParserKeyword");
string s = "";
if (null != f)
{
s = f.GetValue(null).ToString();
}
else
{
// if the field doesn't exist, use the class name
int index = t.Name.LastIndexOf("Task", StringComparison.Ordinal);
s = index >= 0 ? t.Name.Substring(0, index) : t.Name;
}
foreach (string ss in s.Split(','))
{
string sss = ss.Trim();
if (sss != "")
{
ParserTask.RegisterTask(sss, t);
}
}
}
catch (Exception)
{
}
}
}
public async Task SetUpAsync()
{
_parser = await ParserTask.ConfigureAwait(false);
_f = await BuilderFactoriesTask.ConfigureAwait(false);
}
protected internal override void onPostExecute(string result)
{
ParserTask parserTask = new ParserTask(outerInstance);
parserTask.execute(result);
}
public async Task SetUpAsync()
{
_skillDefinitions = await GameData.Skills.ConfigureAwait(false);
_parser = await ParserTask.ConfigureAwait(false);
}
public C99Highlighter()
{
this.outqueue = new ConcurrentQueue<TextBlock>();
this.inqueue = new ConcurrentQueue<Token>();
this.parserTask = new ParserTask(this.outqueue, this.inqueue);
this.parserTask.Start();
}
