public SingleEvent GetEventById(string id)
{
int group = int.Parse(id.Substring(0, 1));
SingleEvent returnEvent = null;
SingleEvent[] eventGroup = GetEventGroup(group).events;
foreach (SingleEvent sEvent in eventGroup)
{
if (sEvent.id == int.Parse(id))
{
returnEvent = sEvent;
break;
}
}
if (returnEvent == null)
{
Debug.Log("Event not found");
}
else
{
Debug.Log(id);
}
return(returnEvent);
}
private void _manageEventAffects(SingleEvent sEvent)
{
switch (sEvent.board_event)
{
case "dust":
_weatherSignController.ShowDustSign();
break;
case "thunder":
_weatherSignController.ShowThunderSign();
break;
case "asteroids":
_boardEvents.TriggerAsteroidField(new Vector3(Random.Range(1, 10), Random.Range(1, 4), 2));
break;
case "blue_flash":
_boardEvents.TriggerBlueFlash();
break;
default:
break;
}
_relationshipsController.AddMorale(sEvent.morale);
_relationshipsController.AddComradery(sEvent.comradery);
_relationshipsController.AddLoyalty(sEvent.loyalty);
_currencyController.SpendCurrency(sEvent.power, sEvent.money);
}
public void readFromFile()
{
if (!System.IO.File.Exists("myFile.txt"))
{
using (System.IO.File.Create("myFile.txt")) {}
return;
}
try {
using (StreamReader streamR = new StreamReader("myFile.txt")) {
string line;
string[] separator = { "@#%*!" };
while ((line = streamR.ReadLine()) != null)
{
SingleEvent oneEvent = new SingleEvent();
string[] strlist = line.Split(separator, StringSplitOptions.RemoveEmptyEntries);
oneEvent.id = Int32.Parse(strlist[0]);
oneEvent.dateOfEvent = strlist[1];
oneEvent.timeOfEvent = strlist[2];
oneEvent.description = strlist[3];
allEvents.Add(oneEvent);
}
allEvents.Sort(delegate(SingleEvent s1, SingleEvent s2)
{
return(s1.timeOfEvent.CompareTo(s2.timeOfEvent));
});
}
} catch (Exception) {
throw new IOException("There is an error during reading the data from the file.");
}
}
private static void UpdateElementLocation(Popup popup)
{
var occlutedRect = InputPane.GetForCurrentView().OccludedRect;
if (occlutedRect.Top > 0)
{
var element = FocusManager.GetFocusedElement() as FrameworkElement;
if (element != null)
{
SingleEvent.RegisterEvent(element,
(e, h) => e.LostFocus += h,
(e, h) => e.LostFocus -= h,
delegate { UpdateElementLocation(popup); });
var point = element.TransformToVisual(Window.Current.Content).TransformPoint(new Point(0, 0));
if (point.X + element.ActualHeight + 100 > occlutedRect.Top)
{
var offset = (point.X + element.ActualHeight + 100) - occlutedRect.Top - (double)popup.Tag;
if (offset > 20)
{
popup.VerticalOffset -= offset;
popup.Tag = (double)popup.Tag + offset;
}
}
}
}
}
public SingleEvent Post([FromBody] SingleEvent ev)
{
readFromFile();
ev.id = allEvents.Count();
allEvents.Add(ev);
saveToFile();
return(ev);
}
public int AddSingleEvent(SingleEvent singleEvent)
{
using (var db = new CalendarDbContext())
{
var entity = db.SingleEvents.Add(singleEvent);
db.SaveChanges();
return(entity.Entity.Id);
}
}
public SingleEvent UpdateSingleEvent(SingleEvent editedSingleEvent)
{
using (var db = new CalendarDbContext())
{
var entity = db.SingleEvents.Update(editedSingleEvent);
db.SaveChanges();
return(entity.Entity);
}
}
private void _shootEvent(SingleEvent sEvent)
{
if (sEvent == null)
{
return;
}
_triggerEventDisplay(sEvent);
_manageEventAffects(sEvent);
}
public void ManageEventAnswer(string eventId, bool isPending)
{
if (isPending)
{
_pendingEvent = eventListController.GetEventById(eventId);
}
else
{
_shootEvent(eventListController.GetEventById(eventId));
}
}
private int _getEventIndex(SingleEvent returnEvent, int evt, int group)
{
int returnEventIndex;
for (returnEventIndex = evt; _getEvt(returnEvent) != evt; returnEventIndex++)
{
returnEvent = GetEventGroup(group).events[returnEventIndex];
}
return(returnEventIndex);
}
/// <summary>
/// Uses the iCal calendar event info of the property Calendar and transfers it to the CalendarDataModel.
/// </summary>
private void ConvertICalDataToDataModel()
{
_data.EventData.Clear();
if ((Calendar == null) || (Calendar.Children.Count == 0))
{
// no calendar event in iCal found
return;
}
// process found iCal events
foreach (Ical.Net.CalendarComponents.CalendarEvent calEvent in Calendar.Children)
{
if (!calEvent.IsActive)
{
continue;
}
SingleEvent singleEvent = new SingleEvent();
// process dates
singleEvent.DayEvent = false;
singleEvent.DayEventSpecified = true;
if (calEvent.IsAllDay)
{
singleEvent.DayEvent = true;
singleEvent.Start = calEvent.Start.Date;
// one-day AllDays event need to be corrected
if (calEvent.Duration.TotalDays == -1)
{
// correct bug that one-day AllDay events the stop date is one day before start date.
singleEvent.Stop = calEvent.End.Date;
singleEvent.Stop = singleEvent.Stop.AddDays(1);
}
if (calEvent.Duration.TotalDays > 0)
{
// correct bug that multiple-day AllDay events the stop date is one day after start date.
singleEvent.Stop = calEvent.End.Date;
singleEvent.Stop = singleEvent.Stop.AddDays(-1);
}
}
else
{
singleEvent.Start = calEvent.Start.Value;
singleEvent.Stop = calEvent.End.Value;
}
// process description
singleEvent.Description = calEvent.Summary;
// process specified fields
singleEvent.StartSpecified = true;
singleEvent.StopSpecified = true;
Data.EventData.Add(singleEvent);
}
}
public SingleEvent Put([FromBody] SingleEvent ev)
{
readFromFile();
foreach (SingleEvent se in allEvents)
{
if (ev.id == se.id)
{
se.timeOfEvent = ev.timeOfEvent;
se.description = ev.description;
break;
}
}
saveToFile();
return(ev);
}
public void Display(SingleEvent sEvent)
{
DestroyOptions();
_textChildren[0].text = sEvent.title;
_textChildren[1].text = sEvent.story;
if (sEvent.choice_id == "" || sEvent.choice_id == null)
{
_instantiateChoices(new string[] { "close" }, new string[] { "Continue" }, -2.32f);
}
else
{
_instantiateChoices(_parseChoices(sEvent.choice_id), _parseChoices(sEvent.choice_text), -2.32f);
}
}
protected override void OnEnabling(EnablingEventArgs e)
{
tickTimer = new ScheduleTimer();
tickTimer.Elapsed += AlarmHit;
if (recurDaily)
{
tickTimer.AddEvent(new Schedule.ScheduledTime(EventTimeBase.Daily, new TimeSpan(0, hour, minute, second, 0)));
}
else
{
alarmTime = new DateTime(year, month, day, hour, minute, second);
SingleEvent se = new SingleEvent(alarmTime);
tickTimer.AddEvent(se);
}
tickTimer.Start();
}
public string Delete([FromBody] SingleEvent ev)
{
readFromFile();
for (int i = 0; i < allEvents.Count(); i++)
{
if (allEvents[i].id == ev.id)
{
allEvents.RemoveAt(i);
break;
}
}
foreach (SingleEvent se in allEvents)
{
if (se.id > ev.id)
{
se.id--;
}
}
saveToFile();
return("Deleted");
}
public void postMessage(int objectId)
{
SingleEvent message = store.getMessage(currentEventId, objectId);
DialogBox db = GameObject.Find("DialogBox").GetComponent <DialogBox>();
if (db.SetMessage(message))
{
switch (message.callback)
{
case SingleEvent.CallbackAction.Door:
DEV_ACTION_LIST[0].Handler();
break;
default:
break;
}
if (store.triggerEvent(currentEventId, objectId))
{
currentEventId++;
}
}
}
public override void Visit(SingleEvent e) => Count++;
private async void UpdateSource()
{
if (_canvas == null || _isAnimating || _lastSource == Source) // is animating or no change
{
return;
}
_isAnimating = true;
var currentSource = Source;
if (_lastSource == null)
{
ForegroundImage.Opacity = 0.0;
var success = SingleEvent.WaitForEventAsync(ForegroundImage,
(image, handler) => image.ImageOpened += handler,
(image, handler) => image.ImageOpened -= handler);
var failure = SingleEvent.WaitForEventAsync(ForegroundImage,
(image, handler) => image.ImageFailed += handler,
(image, handler) => image.ImageFailed -= handler);
ImageHelper.SetSource(ForegroundImage, currentSource);
var task = await Task.WhenAny(new[] { success, failure });
if (task == success)
{
await Fading.FadeInAsync(ForegroundImage, FadingDuration, FadingOpacity);
}
// TODO Deregister not called event
}
else if (currentSource != null) // exchange images
{
BackgroundImage.Opacity = 0.0;
var success = SingleEvent.WaitForEventAsync(BackgroundImage,
(image, handler) => image.ImageOpened += handler,
(image, handler) => image.ImageOpened -= handler);
var failure = SingleEvent.WaitForEventAsync(BackgroundImage,
(image, handler) => image.ImageFailed += handler,
(image, handler) => image.ImageFailed -= handler);
ImageHelper.SetSource(BackgroundImage, currentSource);
if (!WaitForNextImage)
{
Fading.FadeOutAsync(ForegroundImage, FadingDuration);
}
var task = await Task.WhenAny(new[] { success, failure });
if (task == success)
{
if (WaitForNextImage)
{
await Task.WhenAll(new[]
{
Fading.FadeInAsync(BackgroundImage, FadingDuration, FadingOpacity),
Fading.FadeOutAsync(ForegroundImage, FadingDuration)
});
}
else
{
await Fading.FadeInAsync(BackgroundImage, FadingDuration, FadingOpacity);
}
ImageHelper.SetSource(ForegroundImage, null);
// reverse image order
var fore = ForegroundImage;
var back = BackgroundImage;
_canvas.Children.Clear();
_canvas.Children.Add(fore);
_canvas.Children.Add(back);
}
else
{
await Fading.FadeOutAsync(ForegroundImage, FadingDuration);
}
}
else
{
BackgroundImage.Opacity = 0.0;
await Fading.FadeOutAsync(ForegroundImage, FadingDuration);
}
_isAnimating = false;
_lastSource = currentSource;
UpdateSource();
}
public void GetGameOverEvent(string reationshipIndex, bool isLow)
{
_gameOverEvent = eventListController.GetGameOver(reationshipIndex, isLow);
_shootEvent(_gameOverEvent);
}
private void _triggerEventDisplay(SingleEvent sEvent)
{
eventDisplayController.Display(sEvent);
}
protected virtual ICfgNode Build(SingleEvent e) => null;
public void Visit(SingleEvent e) => Result = Build(e);
public virtual void Visit(SingleEvent e)
{
}
private string _getOrder(SingleEvent sEvent)
{
return(sEvent.id.ToString().Substring(3, 1));
}
private int _getEvt(SingleEvent sEvent)
{
return(int.Parse(sEvent.id.ToString().Substring(1, 2)));
}
