private bool TriggerLastKills2(TriggerData t)
{
if (ChooseFromUnknown == 0)
{
return(false);
}
AddMobName = t.Match.Groups[1].Value.Trim();
if (!int.TryParse(t.Match.Groups[2].Value, out AddMobLevel) || UnknownMobs.Count == 0)
{
ChooseFromUnknown = 0;
return(false);
}
AddMobArea = RoomInfoArea;
int i = 1;
World.Instance.SendMessage("@wSelect mob longname from list (type number):");
foreach (string x in UnknownMobs)
{
World.Instance.SendMessage("@W" + i + ". " + x);
i++;
}
return(false);
}
/// <summary>
/// 获取伤害类型
/// </summary>
/// <param name="trigger"></param>
/// <returns></returns>
public static HurtType GetDemageHurtType(TriggerData trigger)
{
// 转换伤害类型
var hurtType = HurtType.NormalAttack;
if (trigger.IsCrit)
{
hurtType = HurtType.Crit;
}
else
{
switch (trigger.DemageType)
{
case DemageType.NormalAttackDemage:
hurtType = HurtType.NormalAttack;
break;
case DemageType.SkillAttackDemage:
hurtType = HurtType.SkillAttack;
break;
}
}
return(hurtType);
}
public override async Task <ITriggerData> BindAsync(TTriggerValue value, ValueBindingContext context)
{
Dictionary <string, object> bindingData = Hooks.GetBindingData(value);
TMessage[] arrayRaw = Hooks.BindMultiple(value, context);
int len = arrayRaw.Length;
Type elementType = _innerBinding.ElementType;
var arrayUser = Array.CreateInstance(elementType, len);
for (int i = 0; i < len; i++)
{
TMessage item = arrayRaw[i];
object obj = await _innerBinding.ConvertAsync(item, null, context);
arrayUser.SetValue(obj, i);
}
Type arrayType = elementType.MakeArrayType();
IValueProvider valueProvider = new ConstantValueProvider(arrayUser, arrayType, "???");
var triggerData = new TriggerData(valueProvider, bindingData);
return(triggerData);
}
private void Play(ref TriggerData data)
{
if (data != null)
{
data.Play(_playObject, _audioSource);
}
}
private bool TriggerRoomChars2(TriggerData t)
{
ListeningRoomChars = false;
if (Config.GetInt32("Tags.Gag", 1) != 0)
{
t.Msg.AuthMask = 0;
}
if (RoomInfoEntry != uint.MaxValue && RoomLocations.ContainsKey(RoomInfoEntry))
{
foreach (MobLocation x in RoomLocations[RoomInfoEntry])
{
Mob m = GetMob(x.MobEntry);
if (m != null && CurrentTime - x.LastVisited >= 600)
{
x.TimesVisited++;
if (foundMobs.Contains(m))
{
x.TimesSeen++;
}
x.LastVisited = CurrentTime;
}
}
}
return(false);
}
public async Task BindAsync_ReturnsExpectedTriggerData()
{
ParameterInfo parameter = GetType().GetMethod("TestTimerJob").GetParameters()[0];
MethodInfo methodInfo = (MethodInfo)parameter.Member;
string timerName = string.Format("{0}.{1}", methodInfo.DeclaringType.FullName, methodInfo.Name);
Mock <ScheduleMonitor> mockScheduleMonitor = new Mock <ScheduleMonitor>(MockBehavior.Strict);
ScheduleStatus status = new ScheduleStatus();
mockScheduleMonitor.Setup(p => p.GetStatusAsync(timerName)).ReturnsAsync(status);
TimerTriggerAttribute attribute = parameter.GetCustomAttribute <TimerTriggerAttribute>();
TimersConfiguration config = new TimersConfiguration();
config.ScheduleMonitor = mockScheduleMonitor.Object;
TestTraceWriter trace = new TestTraceWriter();
TimerTriggerBinding binding = new TimerTriggerBinding(parameter, attribute, config, trace);
// when we bind to a non-TimerInfo (e.g. in a Dashboard invocation) a new
// TimerInfo is created, with the ScheduleStatus populated
FunctionBindingContext functionContext = new FunctionBindingContext(Guid.NewGuid(), CancellationToken.None, trace);
ValueBindingContext context = new ValueBindingContext(functionContext, CancellationToken.None);
TriggerData triggerData = (TriggerData)(await binding.BindAsync("", context));
TimerInfo timerInfo = (TimerInfo)triggerData.ValueProvider.GetValue();
Assert.Same(status, timerInfo.ScheduleStatus);
// when we pass in a TimerInfo that is used
TimerInfo expected = new TimerInfo(attribute.Schedule, status);
triggerData = (TriggerData)(await binding.BindAsync(expected, context));
timerInfo = (TimerInfo)triggerData.ValueProvider.GetValue();
Assert.Same(expected, timerInfo);
}
public Task <ITriggerData> BindAsync(object value, ValueBindingContext context)
{
var orchestrationContext = (DurableOrchestrationContext)value;
Type destinationType = this.parameterInfo.ParameterType;
object convertedValue = null;
if (destinationType == typeof(DurableOrchestrationContext))
{
convertedValue = orchestrationContext;
}
else if (destinationType == typeof(string))
{
convertedValue = OrchestrationContextToString(orchestrationContext);
}
var inputValueProvider = new ObjectValueProvider(
convertedValue ?? value,
this.parameterInfo.ParameterType);
var bindingData = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
bindingData[this.parameterInfo.Name] = convertedValue;
// We don't specify any return value binding because we process the return value
// earlier in the pipeline via the InvokeHandler extensibility.
var triggerData = new TriggerData(inputValueProvider, bindingData);
return(Task.FromResult <ITriggerData>(triggerData));
}
public bool UpdateTriggerActiveStatus(TriggerData objTriggerData)
{
bool bOk = false;
try
{
using (OracleConnection con = new DBConnection().getDBConnection())
{
OracleCommand command = con.CreateCommand();
string sql = "update L2_TRIGGER_COMMANDS set is_trigger ='" + (objTriggerData.TriggerEnabled ? 1 : 0)
+ "',TRIGGER_TYPE ='" + objTriggerData.category.ToString()
+ "',N_VALUE ='" + objTriggerData.ErrorCode
+ "' where MACHINE = '" + objTriggerData.MachineCode
+ "' and is_trigger!='" + (objTriggerData.TriggerEnabled ? 1 : 0) + "'";
command.CommandText = sql;
command.CommandType = CommandType.Text;
command.ExecuteNonQuery();
bOk = true;
}
}
finally
{
}
return(bOk);
}
public bool ShowTrigger(Model.PSTData objPSTData)
{
if (objPSTData == null)
{
return(false);
}
if (objErrorDaoService == null)
{
objErrorDaoService = new ErrorDaoImp();
}
if (objErrorControllerService == null)
{
objErrorControllerService = new ErrorControllerImp();
}
int error = objErrorControllerService.GetErrorCode(objPSTData.machineChannel, objPSTData.machineCode, OpcTags.PST_L2_ErrCode);
if (error != 0)
{
return(false);
}
TriggerData objTriggerData = new TriggerData();
objTriggerData.MachineCode = objPSTData.machineCode;
objTriggerData.category = TriggerData.triggerCategory.ERROR;
objTriggerData.ErrorCode = error.ToString();
objTriggerData.TriggerEnabled = true;
objErrorDaoService.UpdateTriggerActiveStatus(objTriggerData);
return(true);
}
public Task <ITriggerData> BindAsync(object value, ValueBindingContext context)
{
var orchestrationContext = (EventStreamBackedClassifierTriggerValue)value;
Type destinationType = this.parameterInfo.ParameterType;
object convertedValue = null;
if (destinationType == typeof(EventStreamBackedClassifierTriggerValue))
{
convertedValue = orchestrationContext;
}
else if (destinationType == typeof(string))
{
convertedValue = EventStreamBackedClassifierOrchestrationToString(orchestrationContext);
}
return(Task.FromException <ITriggerData>(new NotImplementedException()));
#if TODO
// Need to work out how to return the binding ??
var bindingData = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
bindingData[this.parameterInfo.Name] = convertedValue;
// We don't specify any return value binding
var triggerData = new TriggerData(inputValueProvider, bindingData);
return(Task.FromResult <ITriggerData>(triggerData));
#endif
}
public void NotifyTriggerEnter(TriggerDetector detector, GameObject other)
{
TriggerData newData = new TriggerData();
FillData(newData, detector, other);
triggerEnter.Invoke(newData);
}
private bool OnTick(TriggerData t)
{
for (int i = 0; i < MoonTimer.Length; i++)
{
// Increase moon timers if we have seen a moon rise or fall.
if (MoonTimer[i] == -1)
{
continue;
}
MoonTimer[i]++;
MoonTimer[i] %= MoonInterval[i];
}
// See if we must alert users when moons are about to come up.
if (AlertMoons != -1)
{
int i = WhenAreMoonsUp(MoonTypes.Black, MoonTypes.Grey, MoonTypes.White);
if (i == 0)
{
if (!IsMoonUp(MoonTypes.Black, -1) || !IsMoonUp(MoonTypes.Grey, -1) || !IsMoonUp(MoonTypes.White, -1))
{
World.Instance.SendMessage("@GMOONS: @wThree moons are now @WUP@w!");
}
}
else if (i <= AlertMoons)
{
World.Instance.SendMessage("@GMOONS: @wThree moons will be up in @W" + i + " @wtick" + (i != 1 ? "s" : "") + ".");
}
}
return(false);
}
private bool OnSeeMoon(TriggerData t)
{
/* Arg here is what we used to register trigger with, for example if you see whiterise trigger
* I set the argument to be 3 so it will go to case 3: */
switch (t.Arg)
{
case 3:
MoonTimer[(int)MoonTypes.White] = MoonDuration[(int)MoonTypes.White] - 1;
break;
case -3:
MoonTimer[(int)MoonTypes.White] = 0;
break;
case 2:
MoonTimer[(int)MoonTypes.Grey] = MoonDuration[(int)MoonTypes.Grey] - 1;
break;
case -2:
MoonTimer[(int)MoonTypes.Grey] = 0;
break;
case 1:
MoonTimer[(int)MoonTypes.Black] = MoonDuration[(int)MoonTypes.Black] - 1;
break;
case -1:
MoonTimer[(int)MoonTypes.Black] = 0;
break;
}
return(false);
}
public void TriggerPoint(bool advanceLevel, TriggerData tData, ExtraTriggerData extras)
{
if (advanceLevel)
{
IncrementLevel();
}
if (tData.moveObject)
{
TeleportableGameItem tgi = extras.colliderLevelItem.GetComponent <TeleportableGameItem>();
if (tgi != null)
{
Vector3 dPos = tData.playerPositionOffset;
if (tData.playerPositionOffset.x > 0)
{
dPos -= new Vector3(extras.objectSize.x / 2f, 0, 0);
}
else if (tData.playerPositionOffset.x < 0)
{
dPos += new Vector3(extras.objectSize.x / 2f, 0, 0);
}
if (positionChanges.ContainsKey(tgi.rigidBody))
{
positionChanges[tgi.rigidBody] = dPos;
}
else
{
positionChanges.Add(tgi.rigidBody, dPos);
}
}
}
}
public async Task <ActionResult <TriggerResponse> > AddTrigger(Guid deviceId, [FromBody] TriggerRequest req)
{
var user = HttpContext.User.Identity?.Name;
if (user == null)
{
return(NotFound("Cannot find user"));
}
var ud = await Db.Users.Where(x => x.Aud == user)
.Include(x => x.Device)
.FirstOrDefaultAsync(x => x.Device.DeviceId == deviceId);
if (ud == null)
{
return(NotFound("Device Not Found"));
}
var pd = new TriggerData
{
Name = req.Name,
Code = req.Code,
DeviceId = ud.DeviceId,
};
var saved = await Db.Triggers
.AddAsync(pd);
await Db.SaveChangesAsync();
var ok = saved.Entity !;
return(Ok(new TriggerResponse(ok.Id, ok.Name)));
}
public void Triggered(TriggerData td)
{
if (td.pressed)
{
isActive = !isActive;
}
}
public Task <ITriggerData> BindAsync(object value, ValueBindingContext context)
{
IConverterManager cm = this.parent.extensionContext.Config.ConverterManager;
MethodInfo getConverterMethod = cm.GetType().GetMethod(nameof(cm.GetConverter));
getConverterMethod = getConverterMethod.MakeGenericMethod(
typeof(DurableActivityContext),
this.parameterInfo.ParameterType,
typeof(ActivityTriggerAttribute));
Delegate d = (Delegate)getConverterMethod.Invoke(cm, null);
object convertedValue = d.DynamicInvoke(value, this.attribute, context);
var valueProvider = new ObjectValueProvider(
convertedValue,
this.parameterInfo.ParameterType);
DurableActivityContext activityContext = (DurableActivityContext)value;
var bindingData = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase)
{
{ nameof(DurableActivityContext.InstanceId), activityContext.InstanceId }
};
var triggerData = new TriggerData(valueProvider, bindingData);
return(Task.FromResult <ITriggerData>(triggerData));
}
internal TriggerEvent(InputActionManager manager, int triggerDataIndex)
{
Debug.Assert(triggerDataIndex >= 0 && triggerDataIndex < manager.m_TriggerDataCount);
m_Manager = manager;
m_TriggerDataIndex = triggerDataIndex;
m_Data = m_Manager.m_TriggerDataBuffer[triggerDataIndex];
}
protected override void Init(MyObjectBuilder_DefinitionBase def)
{
base.Init(def);
_triggersByEvent.Clear();
foreach (var trig in Triggers)
{
if (trig.To == MyStringHash.NullOrEmpty)
{
MyDefinitionErrors.Add(Package, $"Trigger {trig} in {Id} has no to state", LogSeverity.Critical);
}
TriggerData trigs;
if (!_triggersByEvent.TryGetValue(trig.Event, out trigs))
{
_triggersByEvent.Add(trig.Event, trigs = new TriggerData());
}
if (trig.From == MyStringHash.NullOrEmpty && trigs.AnySourceTrigger != null)
{
MyDefinitionErrors.Add(Package, $"Trigger {trig} trying to overwrite {trigs.AnySourceTrigger}", LogSeverity.Warning);
}
if (trig.From == MyStringHash.NullOrEmpty)
{
trigs.AnySourceTrigger = trig;
}
else
{
trigs.Triggers.Add(trig);
}
}
}
private bool TriggerUsername(TriggerData t)
{
if (CanEnterUsername != 1)
{
return(false);
}
string n = Config.GetString("AutoLogin.User", "").Trim();
if (string.IsNullOrEmpty(n))
{
CanEnterUsername = 0;
return(false);
}
string p = Config.GetString("AutoLogin.Pass", "").Trim();
if (string.IsNullOrEmpty(p))
{
CanEnterUsername = 0;
return(false);
}
CanEnterUsername = 2;
World.Instance.Execute(n, false);
return(false);
}
public Task <ITriggerData> BindAsync(object value, ValueBindingContext context)
{
var entityContext = (DurableEntityContext)value;
Type destinationType = this.parameterInfo.ParameterType;
object convertedValue = null;
if (destinationType == typeof(IDurableEntityContext))
{
convertedValue = entityContext;
#if !FUNCTIONS_V1
((IDurableEntityContext)value).FunctionBindingContext = context.FunctionContext;
#endif
}
else if (destinationType == typeof(string))
{
convertedValue = EntityContextToString(entityContext);
}
var inputValueProvider = new ObjectValueProvider(
convertedValue ?? value,
this.parameterInfo.ParameterType);
var bindingData = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
bindingData[this.parameterInfo.Name] = convertedValue;
var triggerData = new TriggerData(inputValueProvider, bindingData);
return(Task.FromResult <ITriggerData>(triggerData));
}
public void Init(TriggerData data = null)
{
Reset();
_data = data;
List <Dropdown.OptionData> optList = new List <Dropdown.OptionData>()
{
new Dropdown.OptionData(QuestTriggerCondition.COMPLETE),
new Dropdown.OptionData(QuestTriggerCondition.UNCOMPLETE)
};
_conditionDropdown.ClearOptions();
_conditionDropdown.AddOptions(optList);
_triggerStepDropdown.Init();
_targetStepDropdown.Init();
_alterStepDropdown.Init();
if (_data != null)
{
_conditionDropdown.value = _conditionDropdown.options.FindIndex(o => o.text == _data.condition);
_triggerStepDropdown.Dropdown.value =
_triggerStepDropdown.Dropdown.options.FindIndex(o => o.text == _data.triggerStepId);
_targetStepDropdown.Dropdown.value =
_targetStepDropdown.Dropdown.options.FindIndex(o => o.text == _data.targetStepId);
_alterStepDropdown.Dropdown.value =
_alterStepDropdown.Dropdown.options.FindIndex(o => o.text == _data.alterStepId);
}
}
public void Register(int triggerType, int triggerFuncRef)
{
//for (int i=0;i<_triggerDataCount;i++)
//{
// TriggerData data = _triggerDatas[i];
// if ( data.triggerType == triggerType )
// {
// Logger.LogWarn("Trigger of type " + triggerType + " of this bullet is already exist!Please check lua");
// if ( data.triggerFuncRef != 0 )
// {
// InterpreterManager.GetInstance().UnrefLuaFunction(data.triggerFuncRef);
// }
// data.triggerFuncRef = triggerFuncRef;
// _triggerDatas[i] = data;
// return;
// }
//}
// 暂定：碰撞类型可以重复
TriggerData newData = new TriggerData
{
triggerGroup = triggerType,
triggerFuncRef = triggerFuncRef,
};
_triggerDatas.Add(newData);
_triggerDataCount++;
}
public Trigger(GameContext context, TriggerData data, Entity entity, Gear item)
{
_data = data;
Entity = entity;
Item = item;
Context = context;
}
public Task <ITriggerData> BindAsync(object value, ValueBindingContext context)
{
var activityContext = (DurableActivityContext)value;
Type destinationType = this.parameterInfo.ParameterType;
object convertedValue;
if (destinationType == typeof(object))
{
// Straight assignment
convertedValue = value;
}
else
{
// Try using the converter manager
IConverterManager cm = this.parent.extensionContext.Config.ConverterManager;
MethodInfo getConverterMethod = cm.GetType().GetMethod(nameof(cm.GetConverter));
getConverterMethod = getConverterMethod.MakeGenericMethod(
typeof(DurableActivityContext),
destinationType,
typeof(ActivityTriggerAttribute));
Delegate d = (Delegate)getConverterMethod.Invoke(cm, null);
if (d != null)
{
convertedValue = d.DynamicInvoke(value, this.attribute, context);
}
else if (!destinationType.IsInterface)
{
MethodInfo getInputMethod = activityContext.GetType()
.GetMethod(nameof(activityContext.GetInput))
.MakeGenericMethod(destinationType);
convertedValue = getInputMethod.Invoke(activityContext, null);
}
else
{
throw new ArgumentException(
$"Activity triggers cannot be bound to {destinationType}.",
this.parameterInfo.Name);
}
}
var inputValueProvider = new ObjectValueProvider(
convertedValue,
this.parameterInfo.ParameterType);
var bindingData = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase)
{
{ nameof(DurableActivityContext.InstanceId), activityContext.InstanceId },
};
var triggerData = new TriggerData(inputValueProvider, bindingData);
triggerData.ReturnValueProvider = new ActivityTriggerReturnValueBinder(
activityContext,
this.parameterInfo.ParameterType);
return(Task.FromResult <ITriggerData>(triggerData));
}
// -----------------------buff效果执行----------------------------
///// <summary>
///// 检查并执行符合条件的技能
///// </summary>
///// <param name="buffList">被检查列表</param>
///// <param name="releaseOwner">技能释放单位</param>
///// <param name="receiveOwner">技能被释放单位</param>
///// <param name="type1">第一级技能触发类型</param>
///// <param name="type2">第二级技能触发类型</param>
//public void CheckAndDoBuffInfo(IList<BuffInfo> buffList,
// DisplayOwner releaseOwner,
// DisplayOwner receiveOwner,
// TriggerLevel1 type1,
// TriggerLevel2 type2)
//{
// // 如果攻击时触发
// foreach (var buff in buffList.Where(skill => skill != null && skill.TriggerLevel1 == type1 && skill.TriggerLevel2 == type2))
// {
// // 触发技能
// DoBuff(buff, BuffDoType.Action, FormulaParamsPackerFactroy.Single.GetFormulaParamsPacker(buff.ReleaseMember, buff.ReceiveMember, buff, 1, buff.IsNotLethal));
// }
//}
/// <summary>
/// 检查并执行符合条件的技能
/// </summary>
/// <param name="buffList">被检查列表</param>
/// <param name="triggerData">事件数据</param>
public void CheckAndDoBuffInfo([NotNull] IList <BuffInfo> buffList, [NotNull] TriggerData triggerData)
{
if (buffList.Count == 0)
{
return;
}
if (triggerData.TypeLevel1 == TriggerLevel1.None || triggerData.TypeLevel2 == TriggerLevel2.None)
{
// 不存在事件不触发
Debug.Log("空事件");
return;
}
// 如果攻击时触发
for (var i = 0; i < buffList.Count(); i++)
{
var buff = buffList[i];
if (buff == null || buff.ReceiveMember == null || buff.ReceiveMember.ClusterData.AllData.MemberData.IsAntiBuff)
{
continue;
}
// 生命值百分比
var hpPercent = buff.ReleaseMember.ClusterData.AllData.MemberData.CurrentHP /
buff.ReleaseMember.ClusterData.AllData.MemberData.TotalHp;
// 构建数据packer
var paramsPacker = FormulaParamsPackerFactroy.Single.GetFormulaParamsPacker(buff.ReleaseMember,
buff.ReceiveMember, buff, 1, buff.IsNotLethal);
paramsPacker.TriggerData = triggerData;
// 判断是否符合生命值
// 触发技能
if (buff.HpScopeMin < 0 || buff.HpScopeMax < 0 ||
((hpPercent > buff.HpScopeMin) && (hpPercent < buff.HpScopeMax)))
{
int r = RandomPacker.Single.GetRangeI(0, 100);
//Debug.Log("buff触发几率为 " + buff.TriggerProbability);
// 触发action
if (buff.TriggerLevel1 == triggerData.TypeLevel1 && buff.TriggerLevel2 == triggerData.TypeLevel2 && r <= buff.TriggerProbability * 100)
{
//Debug.Log("ROLL出概率为 " + r);
DoBuff(buff, BuffDoType.Action, paramsPacker);
}
}
if (buff.DetachHpScopeMin < 0 || buff.DetachHpScopeMax < 0 ||
((hpPercent > buff.DetachHpScopeMin) && (hpPercent < buff.DetachHpScopeMax)))
{
// 检测Detach条件如果符合触发detach
if (buff.DetachTriggerLevel1 == triggerData.TypeLevel1 &&
buff.DetachTriggerLevel2 == triggerData.TypeLevel2 && buff.CheckDetach())
{
DoBuff(buff, BuffDoType.Detach, paramsPacker);
}
}
}
}
private bool TriggerRoomChars3(TriggerData t)
{
if (!ListeningRoomChars)
{
return(false);
}
string n = t.Msg.Msg;
Mob m = GetMob(ref n);
t.Msg.Msg = n;
if (m == null)
{
return(false);
}
if (RoomInfoEntry != uint.MaxValue)
{
if (!foundMobs.Contains(m))
{
foundMobs.Add(m);
}
bool f = false;
foreach (MobLocation x in m.Locations)
{
if (x.RoomEntry != RoomInfoEntry)
{
continue;
}
f = true;
if (CurrentTime - x.LastVisited >= 600)
{
x.CountSeen++;
}
break;
}
if (!f)
{
MobLocation ml = new MobLocation();
ml.RoomEntry = RoomInfoEntry;
ml.MobEntry = m.Entry;
ml.LastVisited = CurrentTime;
ml.TimesSeen = 0;
ml.TimesVisited = 0;
ml.CountSeen = 1;
m.Locations.Add(ml);
if (!RoomLocations.ContainsKey(RoomInfoEntry))
{
RoomLocations[RoomInfoEntry] = new List <MobLocation>();
}
RoomLocations[RoomInfoEntry].Add(ml);
}
}
return(false);
}
/// <summary>
/// Bind a value using the binding context
/// </summary>
/// <param name="value">Value to bind</param>
/// <param name="context">Binding contract to use</param>
/// <returns>Returns a Task that contains the <c>TriggerData</c></returns>
public Task <ITriggerData> BindAsync(object value, ValueBindingContext context)
{
var valueProvider = new NatsValueBinder(value);
var bindingData = new Dictionary <string, object>();
var triggerData = new TriggerData(valueProvider, bindingData);
return(Task.FromResult <ITriggerData>(triggerData));
}
private void OnTrigger(TriggerData triggerData)
{
ObjectPointTriggered?.Invoke(triggerData.point);
int hashCode = triggerData.gameObject.GetHashCode();
ObjectTriggered?.Invoke(triggersMap[hashCode].SceneObjectType);
}
public BriefingRunner(ReadyRoomScreen screen, Chk scenario,
string scenario_prefix)
{
this.screen = screen;
this.scenario = scenario;
this.prefix = scenario_prefix;
triggerData = scenario.BriefingData;
}
public Task<ITriggerData> BindAsync(object value, ValueBindingContext context)
{
IValueProvider provider = new JsonValueProvider(value, _parameter.ParameterType);
IReadOnlyDictionary<string, object> bindingData = (_bindingDataProvider != null)
? _bindingDataProvider.GetBindingData(provider.GetValue()) : null;
var result = new TriggerData(provider, bindingData);
return Task.FromResult<ITriggerData>(result);
}
protected override void OnTriggerLOSEnter(TriggerData data)
{
base.OnTriggerLOSEnter(data);
if (data.triggerType == TagTypes.mob)
{
if (IsEnemey(data.entity.FactionFlags))
{
enemies.Add(data.entity);
CurrentActivity = ActivityState.Attacking;
SetEntityAndFollow(data.entity);
}
}
}
public Task<ITriggerData> BindAsync(object value, ValueBindingContext context)
{
if (value != null && value.GetType() == typeof(string))
{
throw new NotSupportedException("ErrorTrigger does not support Dashboard invocation.");
}
TraceFilter triggerValue = (TraceFilter)value;
IValueBinder valueBinder = new ErrorValueBinder(_parameter, triggerValue);
TriggerData triggerData = new TriggerData(valueBinder, GetBindingData(triggerValue));
return Task.FromResult<ITriggerData>(triggerData);
}
RegexTrigger CreateRegexTrigger(TriggerData data)
{
var trigger = new RegexTrigger
{
Condition = data.Condition,
Name = data.Condition.Substring(0, data.Condition.Length <= 25 ? data.Condition.Length : 25),
Active = data.Active
};
trigger.AddNotifier(new SoundNotifier(data.SoundName));
foreach (var logType in data.LogTypes)
{
trigger.AddLogType(logType);
}
return trigger;
}
SimpleTrigger CreateSimpleTrigger(TriggerData data)
{
var unescapedCond = Regex.Unescape(data.Condition);
var trigger = new SimpleTrigger
{
Condition = ConvertRegexToCondText(data.Condition),
Name = unescapedCond.Substring(0, unescapedCond.Length <= 25 ? unescapedCond.Length : 25),
Active = data.Active
};
trigger.AddNotifier(new SoundNotifier(data.SoundName));
foreach (var logType in data.LogTypes)
{
trigger.AddLogType(logType);
}
return trigger;
}
private static IList<TriggerData> GetTriggers(IScheduler scheduler, JobKey jobKey)
{
var result = new List<TriggerData>();
foreach (var trigger in scheduler.GetTriggersOfJob(jobKey))
{
var data = new TriggerData(trigger.Key.Name, GetTriggerStatus(trigger, scheduler))
{
StartDate = trigger.StartTimeUtc,
EndDate = trigger.EndTimeUtc,
NextFireDate = trigger.GetNextFireTimeUtc(),
PreviousFireDate = trigger.GetPreviousFireTimeUtc()
};
result.Add(data);
}
return result;
}
public IEnumerable<TriggerData> GetData()
{
var triggers = new List<TriggerData>();
using (var sr = new StreamReader(_filePath))
{
var firstline = sr.ReadLine();
// skip any potential outdated version of this file to make this simple
if (firstline != null && !firstline.Trim().StartsWith("FILEVERSION 3", StringComparison.OrdinalIgnoreCase))
{
Logger.LogInfo("Found outdated playlist file, skipping import: "+firstline);
return null;
}
string line;
while ((line = sr.ReadLine()) != null)
{
try
{
var triggerData = new TriggerData();
string[] entries = line.Split(';');
triggerData.Active = Convert.ToBoolean(entries[0]);
triggerData.SoundName = entries[1];
triggerData.Condition = entries[2];
triggerData.LogTypes = new List<GameLogTypes>();
for (int i = 3; i < entries.Length; i++)
{
if (entries[i].Contains("s:CustomRegex"))
{
triggerData.IsRegex = true;
continue;
}
try
{
triggerData.LogTypes.Add(ParseLogType(entries[i]));
}
catch (Exception exception)
{
Logger.LogInfo("found unrecognized string in special conditions" + entries[i], this, exception);
}
}
triggers.Add(triggerData);
}
catch (Exception exception)
{
Logger.LogInfo("error while parsing imported playlist line, skipping to next, line text: " + line, this, exception);
}
}
}
return triggers.ToArray();
}
public BriefingRunner(ReadyRoomScreen screen, Chk scenario,
string scenario_prefix)
{
this.screen = screen;
this.scenario = scenario;
this.prefix = scenario_prefix;
triggerData = scenario.BriefingData;
}
protected virtual void OnTriggerLOSExit(TriggerData data)
{
}
protected virtual void OnTriggerLOSEnter(TriggerData data)
{
}
protected virtual void OnChaseLOSExit(TriggerData data)
{
}
protected override void OnTriggerLOSEnter(TriggerData data)
{
base.OnTriggerLOSEnter(data);
if (IsEnemey(data.entity.GetComponent<ActiveEntity>().FactionFlags))
enemies.Add(data.entity.GetComponent<ActiveEntity>());
}
protected override void OnChaseLOSExit(TriggerData data)
{
base.OnChaseLOSExit(data);
enemies.Remove(data.entity.GetComponent<ActiveEntity>());
}
