private void RenderMessageCell(Gtk.TreeViewColumn column, Gtk.CellRenderer cell, Gtk.TreeModel model, Gtk.TreeIter iter)
{
if (model.GetValue(iter, 0) is TriggeredEvent)
{
TriggeredEvent ev = (TriggeredEvent)model.GetValue(iter, 0);
(cell as Gtk.CellRendererText).Text = ev.Message;
}
}
void Awake()
{
m_CurrentEvent = m_Events[0];
onNotify = TriggerNextEvent;
sub.Subscribe("nextVideo", onNotify);
TriggerEventAtIndex(0);
}
private void RenderTimeCell(Gtk.TreeViewColumn column, Gtk.CellRenderer cell, Gtk.TreeModel model, Gtk.TreeIter iter)
{
if (model.GetValue(iter, 0) is TriggeredEvent)
{
TriggeredEvent ev = (TriggeredEvent)model.GetValue(iter, 0);
ev.LastDisplay = ev.TimeStamp.TimeAgo();
(cell as Gtk.CellRendererText).Text = ev.LastDisplay;
}
}
public void TriggerEventAtIndex(int aIndex)
{
if (aIndex >= m_Events.Count)
{
TriggerEventAtIndex(0);
return;
}
m_CurrentEvent = m_Events[aIndex]; // Set the current event to the new event
m_CurrentEvent.RunEvent(); // Run the new event
m_Timer = 0;
}
/// <summary>
/// Used to update the IoT UI (for debugging) and send a message to the web API
/// </summary>
private async void CreateEvent(bool eventType)
{
Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => GpioStatus.Text = eventType.ToString());
var newEvent = new TriggeredEvent
{
EventType = eventType,
EventTime = DateTime.Now
};
HttpContent contentPost = new StringContent(JsonConvert.SerializeObject(newEvent), System.Text.Encoding.UTF8, "application/json");
HttpResponseMessage message = await client.PostAsync("api/event", contentPost);
}
public void Subscribe(string eventName, TriggeredEvent trigger)
{
if (_managedEvents.ContainsKey(eventName))
{
_managedEvents[eventName].Add(trigger);
}
else
{
Register(eventName);
Subscribe(eventName, trigger);
//Debug.LogWarning ("Attempting to subscribe to an event that is not registered: " + eventName);
}
}
public void Subscribe(string eventName, TriggeredEvent trigger)
{
if (_managedEvents.ContainsKey(eventName))
{
_managedEvents[eventName].Add(trigger);
}
else
{
Register(eventName);
Subscribe(eventName, trigger);
//Debug.LogWarning ("Attempting to subscribe to an event that is not registered: " + eventName);
}
}
private void Trigger()
{
hoursRemaining = UnityEngine.Random.Range(minimumHoursBetween, maxmumHoursBetween);
TriggeredEvent[] components = GetComponents <TriggeredEvent>();
if (components.Length != 0)
{
TriggeredEvent triggeredEvent = components[UnityEngine.Random.Range(0, components.Length)];
if (!(triggeredEvent == null))
{
triggeredEvent.SendMessage("RunEvent", SendMessageOptions.DontRequireReceiver);
}
}
}
public async Task <HttpResponseMessage> Post(TriggeredEvent newEvent)
{
var collectionLink = UriFactory.CreateDocumentCollectionUri(databaseName, collectionName);
var response = await GetDocResponse();
var upserted = response.Resource;
var events = upserted.GetPropertyValue <List <TriggeredEvent> >("records");
events.Add(newEvent);
upserted.SetPropertyValue("records", events);
response = await documentClient.UpsertDocumentAsync(collectionLink, upserted);
var pushNotificationResponse = await TriggerPushNotification(newEvent.EventType);
return(Request.CreateResponse(HttpStatusCode.OK, newEvent));
}
private void Trigger()
{
this.hoursRemaining = Random.Range(this.minimumHoursBetween, this.maxmumHoursBetween);
TriggeredEvent[] components = (TriggeredEvent[])((Component)this).GetComponents <TriggeredEvent>();
if (components.Length == 0)
{
return;
}
TriggeredEvent triggeredEvent = components[Random.Range(0, components.Length)];
if (Object.op_Equality((Object)triggeredEvent, (Object)null))
{
return;
}
((Component)triggeredEvent).SendMessage("RunEvent", (SendMessageOptions)1);
}
private void Trigger()
{
this.hoursRemaining = UnityEngine.Random.Range(this.minimumHoursBetween, this.maxmumHoursBetween);
TriggeredEvent[] components = base.GetComponents <TriggeredEvent>();
if (components.Length == 0)
{
return;
}
TriggeredEvent triggeredEvent = components[UnityEngine.Random.Range(0, (int)components.Length)];
if (triggeredEvent == null)
{
return;
}
triggeredEvent.SendMessage("RunEvent", SendMessageOptions.DontRequireReceiver);
}
private void ExecuteCallbacks()
{
while (_isDisposed == false)
{
try
{
TriggeredEvent.WaitOne();
while (TriggeredCallbacks.TryDequeue(out var callback))
{
callback();
}
}
catch (Exception ex)
{
LogTo.Error(ex, "An exception was thrown while executing Keyboard HotKey callback");
}
}
}
public void UnSubscribe(string eventName, TriggeredEvent trigger)
{
if (_managedEvents.ContainsKey(eventName))
{
List <TriggeredEvent> events = _managedEvents[eventName];
for (int i = 0; i < events.Count; i++)
{
if (events[i].Target == trigger.Target)
{
events.RemoveAt(i);
break;
}
}
}
else
{
Debug.LogWarning("Attempting to unsubscribe to an event that is not registered: " + eventName);
}
}
public void UnSubscribe(string eventName, TriggeredEvent trigger)
{
if (_managedEvents.ContainsKey(eventName))
{
List<TriggeredEvent> events = _managedEvents[eventName];
for (int i = 0; i < events.Count; i++)
{
if (events[i].Target == trigger.Target)
{
events.RemoveAt(i);
break;
}
}
}
else
{
Debug.LogWarning ("Attempting to unsubscribe to an event that is not registered: " + eventName);
}
}
public EventsWidget()
{
this.Build();
Gtk.TreeViewColumn timeColumn = new Gtk.TreeViewColumn();
timeColumn.Title = "Time";
timeColumn.Resizable = true;
Gtk.TreeViewColumn notificationColumn = new Gtk.TreeViewColumn();
notificationColumn.Title = "Notification";
notificationColumn.Resizable = true;
Gtk.TreeViewColumn messageColumn = new Gtk.TreeViewColumn();
messageColumn.Title = "Message";
Gtk.CellRendererText timeCell = new Gtk.CellRendererText();
Gtk.CellRendererText notificationCell = new Gtk.CellRendererText();
Gtk.CellRendererText messageCell = new Gtk.CellRendererText();
timeColumn.PackEnd(timeCell, false);
notificationColumn.PackEnd(notificationCell, false);
messageColumn.PackEnd(messageCell, false);
timeColumn.SetCellDataFunc(timeCell, new Gtk.TreeCellDataFunc(RenderTimeCell));
notificationColumn.SetCellDataFunc(notificationCell, new Gtk.TreeCellDataFunc(RenderNotificationCell));
messageColumn.SetCellDataFunc(messageCell, new Gtk.TreeCellDataFunc(RenderMessageCell));
treeviewEvents.AppendColumn(timeColumn);
treeviewEvents.AppendColumn(notificationColumn);
treeviewEvents.AppendColumn(messageColumn);
EventListStore.SetSortFunc(0, delegate(TreeModel model, TreeIter a, TreeIter b) {
TriggeredEvent s1 = (TriggeredEvent)model.GetValue(a, 0);
TriggeredEvent s2 = (TriggeredEvent)model.GetValue(b, 0);
return(DateTime.Compare(s1.TimeStamp, s2.TimeStamp));
});
EventListStore.SetSortColumnId(0, SortType.Descending);
treeviewEvents.Model = EventListStore;
RefreshTimer = GLib.Timeout.Add(5000, new GLib.TimeoutHandler(UpdateRows));
}
private bool UpdateRows()
{
TreeIter iter;
if (EventListStore.GetIterFirst(out iter))
{
do
{
TriggeredEvent ev = (TriggeredEvent)EventListStore.GetValue(iter, 0);
if (ev.LastDisplay != ev.TimeStamp.TimeAgo())
{
TreePath path = EventListStore.GetPath(iter);
EventListStore.EmitRowChanged(path, iter);
}
}while (EventListStore.IterNext(ref iter));
}
return(true);
}
public void Trigger(TriggeredEvent tevent)
{
if (!tevent.solved)
{
if (!toggled && tevent != null)
{
trigg_event = tevent;
//event_description.text = tevent.flavour_text;
option_1_text.text = tevent.option_one;
option_2_text.text = tevent.option_two;
float chance = tevent.ShowChance(game.GetStatlist()[trigg_event.test.stat_id]);
success_chance.text = "(" + chance.ToString("F2") + "%)";
fail_chance.text = "(" + (100 - chance).ToString("F2") + "%)";
AssignSprites();
}
Toggle();
}
// if (toggled && !tevent.solved)
//{
// Toggle();
//}
}
void OnTriggerEnter2D(Collider2D col)
{
TriggeredEvent?.Invoke(this, col);
}
public PlayerChoiceOption(int id, TriggeredEvent triggeredEvent)
{
Id = id;
Event = triggeredEvent;
}
public void ExecuteProgress()
{
foreach (var eventEntry in EventModifiers.EventData)
{
switch (eventEntry.Type)
{
case TownEventDataType.IdleBuff:
for (int i = 0; i < Heroes.Count; i++)
{
if (Heroes[i].Status == HeroStatus.Available)
{
Heroes[i].AddBuff(new BuffInfo(DarkestDungeonManager.Data.Buffs[eventEntry.StringData],
BuffDurationType.IdleTownVisit, BuffSourceType.Estate));
}
}
break;
case TownEventDataType.IdleResolve:
for (int i = 0; i < Heroes.Count; i++)
{
if (Heroes[i].Class == eventEntry.StringData)
{
for (int j = 0; j < eventEntry.NumberData; j++)
{
Heroes[i].Resolve.AddExperience(Heroes[i].Resolve.NextLevelXP - Heroes[i].Resolve.CurrentXP);
}
Heroes[i].UpdateResolve();
}
}
break;
case TownEventDataType.InActivityBuff:
for (int i = 0; i < Heroes.Count; i++)
{
if (Heroes[i].Status == HeroStatus.Abbey || Heroes[i].Status == HeroStatus.Tavern)
{
for (int j = 0; j < eventEntry.NumberData; j++)
{
Heroes[i].AddBuff(new BuffInfo(DarkestDungeonManager.Data.Buffs[eventEntry.StringData],
BuffDurationType.IdleTownVisit, BuffSourceType.Estate));
}
}
}
break;
default:
break;
}
}
TriggeredEvent = null;
GuaranteedEvent = null;
EventModifiers.Reset();
Estate.ExecuteProgress();
var possibleEvents = DarkestDungeonManager.Data.EventDatabase.Events.FindAll(townEvent => townEvent.IsPossible);
if (possibleEvents.Count > 0 && EventsOption.Frequency.Count > 3 && RandomSolver.CheckSuccess(EventsOption.Frequency[3]))
{
TriggeredEvent = RandomSolver.ChooseBySingleRandom(possibleEvents);
for (int i = 0; i < DarkestDungeonManager.Data.EventDatabase.Events.Count; i++)
{
DarkestDungeonManager.Data.EventDatabase.Events[i].EventTriggered(false);
}
TriggeredEvent.EventTriggered(true);
EventModifiers.IncludeEvent(TriggeredEvent);
if (TriggeredEvent.Id == "plot_quest_town_invasion_0")
{
DarkestSoundManager.PlayOneShot("event:/town/town_event_display_bandit_incursion");
}
else if (TriggeredEvent.Tone == TownEventTone.Bad)
{
DarkestSoundManager.PlayOneShot("event:/town/town_event_display_bad");
}
else if (TriggeredEvent.Tone == TownEventTone.Good)
{
DarkestSoundManager.PlayOneShot("event:/town/town_event_display_good");
}
else
{
DarkestSoundManager.PlayOneShot("event:/town/town_event_display_neutral");
}
}
GenerateQuests();
SearchMissingHeroes();
}
private static void AddAverageDailyData(TriggeredEvent e,
ObservableCollection <AverageDailyData> averageDailyInsights)
{
averageDailyInsights[DayOfWeekConverter(e.EventTime.DayOfWeek)].AverageDayValue += 1;
}
public void AddOnClick(string s, TriggeredEvent fooabr)
{
Where = s;
OnClick+=fooabr;
}
public void execute(componentMapObject actor, TriggeredEvent tEvent)
{
Debug.Log("Executing Triggered Behavior!!!");
}
public void OnTriggered(TriggeredEvent handler)
{
triggered = handler;
CPP.Add("QObject::connect($q, &QAction::triggered, [=] (bool selected) {this->SlotTriggered(selected);});");
}
private IntPtr LowLevelKeyboardProc(int nCode,
IntPtr wParam,
IntPtr lParam)
{
if (nCode < 0)
{
return(CallNextHookEx(_windowsHookHandle,
nCode,
wParam,
lParam));
}
var wparamTyped = wParam.ToInt32();
// TODO: Invoke KeyboardPressed
if (Enum.IsDefined(typeof(KeyboardState),
wparamTyped))
{
KeyboardState kbState = (KeyboardState)wparamTyped;
LowLevelKeyboardInputEvent kbEvent = (LowLevelKeyboardInputEvent)Marshal.PtrToStructure(lParam,
typeof(LowLevelKeyboardInputEvent));
if (kbState == KeyboardState.KeyDown || kbState == KeyboardState.SysKeyDown)
{
var hk = new HotKey(
kbEvent.Key,
GetCtrlPressed(), GetAltPressed(), GetShiftPressed(), GetMetaPressed());
var hkReg = HotKeys.SafeGet(hk);
if (MainCallback != null && hk.Modifiers != KeyModifiers.None)
{
MainCallback(hk);
}
if (hkReg != null)
{
bool scopeMatches = true;
if (hkReg.Scope != HotKeyScope.Global)
{
var foregroundWdwHandle = GetForegroundWindow();
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
if (foregroundWdwHandle == null || foregroundWdwHandle == IntPtr.Zero)
{
scopeMatches = false;
}
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
else if (_elWdwHandle == null || _elWdwHandle == IntPtr.Zero)
{
LogTo.Warning(
$"KeyboardHook: HotKey {hk} requested with scope {Enum.GetName(typeof(HotKeyScope), hkReg.Scope)}, but _elWdwHandle is {_elWdwHandle}. Trying to refresh.");
OnElementWindowAvailable();
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
if (_elWdwHandle == null || _elWdwHandle == IntPtr.Zero)
{
scopeMatches = false;
}
}
else if (hkReg.Scope == HotKeyScope.SMBrowser && foregroundWdwHandle != _elWdwHandle)
{
scopeMatches = false;
}
else if (hkReg.Scope == HotKeyScope.SM)
{
GetWindowThreadProcessId(foregroundWdwHandle, out var foregroundProcId);
if (foregroundProcId != _smProcessId)
{
scopeMatches = false;
}
}
}
if (scopeMatches)
{
TriggeredCallbacks.Enqueue(hkReg.Callback);
TriggeredEvent.Set();
return((IntPtr)1);
}
}
}
}
return(CallNextHookEx(_windowsHookHandle,
nCode,
wParam,
lParam));
}
public void trigger(string tag, TriggeredEvent tEvent)
{
Debug.Log("Activating Trigger : " + tag);
if (_triggeredBehaviors.ContainsKey(tag) == true)
{
foreach (TriggeredBehaviorMapObject behavior in _triggeredBehaviors[tag])
{
Debug.Log("Triggering Behavior!");
behavior.execute(this, tEvent);
}
}
}
