private void DbSetMetaEventStatus(MetaEventStatus status, IDbTransaction tx = null)
{
IDbCommand cmd = m_DbConn.CreateCommand();
if (tx != null)
{
cmd.Connection = m_DbConn;
cmd.Transaction = tx;
}
try
{
cmd.CommandText = @"INSERT OR REPLACE INTO eventtimerapi_events (id, name, mincountdown, maxcountdown, stageid, stagename, stagetype, timestamp)
VALUES (@id, @name, @mincountdown, @maxcountdown, @stageid, @stagename, @stagetype, @timestamp)";
cmd.AddParameter("@id", status.Id);
cmd.AddParameter("@name", status.Name);
cmd.AddParameter("@mincountdown", status.MinCountdown);
cmd.AddParameter("@maxcountdown", status.MaxCountdown);
cmd.AddParameter("@stageid", status.StageId);
cmd.AddParameter("@stagename", status.StageName);
cmd.AddParameter("@stagetype", status.StageType);
cmd.AddParameter("@timestamp", status.Timestamp);
cmd.ExecuteNonQuery();
}
catch (Exception e)
{
LOGGER.Error(string.Format("Exception thrown when attempting to set event data [{0}]", status.Id), e);
}
}
private MetaEventStatus DbGetMetaEventStatus(string id)
{
MetaEvent meta = MetaEventDefinitions.MetaEvents.Where(m => m.Id == id).FirstOrDefault();
if (meta == null)
{
throw new KeyNotFoundException(string.Format("Meta event [{0}] does not exist", id));
}
MetaEventStatus status = new MetaEventStatus()
{
Id = meta.Id,
Name = meta.Name,
Countdown = 0,
StageId = -1,
StageTypeEnum = MetaEventStage.StageType.Reset,
StageName = null,
Timestamp = DbGetTimestamp()
};
IDbCommand cmd = m_DbConn.CreateCommand();
try
{
cmd.CommandText = "SELECT * FROM eventtimerapi_events WHERE id = @id";
cmd.AddParameter("@id", id);
using (IDataReader reader = cmd.ExecuteReader())
{
if (reader.Read())
{
status.Id = reader["id"].ToString();
status.Name = reader["name"].ToString();
status.MinCountdown = uint.Parse(reader["mincountdown"].ToString());
status.MaxCountdown = uint.Parse(reader["maxcountdown"].ToString());
status.StageId = int.Parse(reader["stageid"].ToString());
status.StageName = reader["stagename"].ToString();
status.StageType = reader["stagetype"].ToString();
status.Timestamp = long.Parse(reader["timestamp"].ToString());
}
}
}
catch (Exception e)
{
LOGGER.Error(string.Format("Exception thrown when attempting to get event data [{0}]", id), e);
}
return(status);
}
public static void WorkerThread(object sender, ElapsedEventArgs e)
{
// attempt to set the sync, if another of us is running, just exit
if (Interlocked.CompareExchange(ref m_TimerSync, 1, 0) != 0)
{
return;
}
// wrap in a try-catch so we can release our interlock if something fails
try
{
EventsResponse response = new EventsRequest(1007).Execute();
long timestamp = (long)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalMilliseconds;
HashSet <EventState> metaEvents = new HashSet <EventState>(response.Events.Where(es => MetaEventDefinitions.EventList.Contains(es.EventId)));
foreach (MetaEvent meta in MetaEventDefinitions.MetaEvents)
{
if (m_EventStatus.ContainsKey(meta.Id))
{
int stageId = meta.GetStageId(metaEvents, m_EventStatus[meta.Id].StageId);
MetaEventStatus oldevs = m_EventStatus[meta.Id];
MetaEventStatus newevs = new MetaEventStatus()
{
Id = meta.Id,
StageId = stageId,
StageTypeEnum = (stageId >= 0 ? meta.Stages.ElementAt(stageId).Type : MetaEventStage.StageType.Invalid),
Timestamp = (long)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalMilliseconds
};
if (stageId < 0 && oldevs.StageId >= 0)
{
newevs.StageName = meta.Stages.ElementAt(oldevs.StageId).IsFailed(metaEvents).ToString();
}
if (oldevs.StageTypeEnum == MetaEventStage.StageType.Invalid &&
newevs.StageTypeEnum != MetaEventStage.StageType.Invalid)
{
DateTime epoch = new DateTime(1970, 1, 1);
DateTime oldTIme = epoch.AddMilliseconds((double)oldevs.Timestamp);
DateTime newTIme = epoch.AddMilliseconds((double)newevs.Timestamp);
EventSpawnData spawnData = new EventSpawnData()
{
ev_id = meta.Id,
spawn_time = newTIme - oldTIme,
failed = oldevs.StageName
};
m_Data.Add(spawnData);
}
if (oldevs.StageId != newevs.StageId)
{
m_EventStatus[meta.Id] = newevs;
}
}
}
}
catch (Exception)
{ }
// reset sync to 0
Interlocked.Exchange(ref m_TimerSync, 0);
}
protected override EventScheduleResponse GetData(IDictionary <string, string> _get)
{
DateTime timestamp = DateTime.UtcNow;
uint slot_secs_remaining = 900 - ((uint)Math.Floor(timestamp.TimeOfDay.TotalSeconds) % 900);
int slot = MetaEventSchedule.GetSlot(timestamp);
EventScheduleResponse data = new EventScheduleResponse()
{
Timestamp = (long)(timestamp - new DateTime(1970, 1, 1)).TotalMilliseconds,
Events = new List <MetaEventStatus>()
};
SortedDictionary <int, string> meta_slot_order = new SortedDictionary <int, string>();
foreach (string meid in MetaEventSchedule.MetaEventList)
{
if (meid == null)
{
continue;
}
int meta_slot = -1;
for (int i = slot; meta_slot < 0; i++)
{
if (MetaEventSchedule.MetaEventRotation[i % MetaEventSchedule.MetaEventRotation.Length] == meid)
{
meta_slot = i;
}
}
meta_slot_order.Add(meta_slot, meid);
}
foreach (KeyValuePair <int, string> entry in meta_slot_order)
{
int meta_slot = entry.Key;
MetaEvent meta = MetaEventDefinitions.MetaEvents.Where(me => me.Id == entry.Value).First();
MetaEventStatus status = new MetaEventStatus()
{
Id = meta.Id,
Name = meta.Name,
MinCountdown = 0,
MaxCountdown = 0,
StageId = -1,
StageType = null,
StageName = null,
Timestamp = data.Timestamp
};
if (meta_slot == slot)
{
status.StageId = 2;
status.StageTypeEnum = MetaEventStage.StageType.Boss;
status.StageName = "This boss is currently active.";
status.Countdown = slot_secs_remaining;
}
else if (meta_slot == slot + 1)
{
status.StageId = 1;
status.StageTypeEnum = MetaEventStage.StageType.PreEvent;
status.StageName = "This boss is on deck.";
status.Countdown = slot_secs_remaining;
}
else
{
status.StageId = 0;
status.StageTypeEnum = MetaEventStage.StageType.Invalid;
status.StageName = "This boss is on cooldown.";
status.Countdown = ((uint)(meta_slot - (slot + 1)) * 900) + slot_secs_remaining;
}
data.Events.Add(status);
}
return(data);
}
public void Process(EventsResponse events)
{
long timestamp = (long)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalMilliseconds;
HashSet <EventState> metaEvents = new HashSet <EventState>(events.Events.Where(es => es.WorldId == WORLD_ID && MetaEventDefinitions.EventList.Contains(es.EventId)));
HashSet <MetaEventStatus> changedStatuses = new HashSet <MetaEventStatus>();
// discover meta-event states
foreach (MetaEvent meta in MetaEventDefinitions.MetaEvents)
{
MetaEventStatus oldStatus = DbGetMetaEventStatus(meta.Id);
int stageId = meta.GetStageId(metaEvents, oldStatus.StageId);
// stock state
MetaEventStatus status = new MetaEventStatus()
{
Id = meta.Id,
Name = meta.Name,
MinCountdown = meta.MinSpawn,
MaxCountdown = meta.MaxSpawn,
StageId = stageId,
StageType = null,
StageName = null,
Timestamp = (long)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalMilliseconds
};
// we're in a stage
if (stageId >= 0)
{
MetaEventStage stage = meta.Stages.ElementAt(stageId);
if (stage.Countdown > 0 && stage.Countdown != uint.MaxValue)
{
status.Countdown = stage.Countdown;
}
else
{
status.Countdown = 0;
}
status.StageName = stage.Name;
status.StageTypeEnum = stage.Type;
}
// has the status changed?
if (oldStatus.StageId != status.StageId || (stageId >= 0 && oldStatus.StageName != status.StageName))
{
// if the actual stage hasn't changed (multiline scenareo) then don't update the timestamp
if (oldStatus.StageId == status.StageId)
{
status.Timestamp = oldStatus.Timestamp;
}
changedStatuses.Add(status);
}
}
if (changedStatuses.Count > 0)
{
LOGGER.DebugFormat("Saving {0} updated event status(es)", changedStatuses.Count);
IDbTransaction tx = m_DbConn.BeginTransaction();
try
{
DbSetProperty("timestamp", timestamp.ToString(), tx);
foreach (MetaEventStatus status in changedStatuses)
{
DbSetMetaEventStatus(status, tx);
}
tx.Commit();
}
catch (Exception e)
{
LOGGER.Error("Exception thrown when attempting to update event status", e);
try
{
tx.Rollback();
}
catch (Exception ex)
{
LOGGER.Error("Exception thrown when attempting to roll back event status update", ex);
}
}
}
}
public void SetData(MetaEventStatus e)
{
EventName.Text = e.Name;
DateTime then = new DateTime(1970, 1, 1).AddMilliseconds(e.Timestamp);
TimeSpan span = DateTime.UtcNow - then;
m_Countdown = false;
string windowType = null;
if (e.MinCountdown > 0)
{
m_Countdown = true;
if (e.MinCountdown - span.TotalSeconds > 0)
{
span = new TimeSpan(0, 0, (int)e.MinCountdown) - span;
}
else
{
if (e.MaxCountdown - span.TotalSeconds > 0)
{
windowType = "window";
span = new TimeSpan(0, 0, (int)e.MaxCountdown) - span;
}
else
{
m_Countdown = false;
windowType = "behind";
span -= new TimeSpan(0, 0, (int)Math.Max(e.MinCountdown, e.MaxCountdown));
}
}
}
m_EventTime = span;
Visibility = Visibility.Visible;
if (e.StageTypeEnum == MetaEventStage.StageType.Boss)
{
Background = BOSS_GRADIENT;
}
else if (e.StageTypeEnum == MetaEventStage.StageType.PreEvent)
{
Background = PRE_GRADIENT;
}
else
{
Background = null;
if (windowType == "window")
{
EventTime.Foreground = Brushes.Blue;
}
else if (windowType == "behind")
{
EventTime.Foreground = Brushes.Red;
}
else
{
EventTime.Foreground = null;
Visibility = Visibility.Collapsed;
}
}
if (e.StageId < 0)
{
TimeSpan window = new TimeSpan(0, 0, (int)(e.MaxCountdown - e.MinCountdown));
if (windowType == "behind")
{
EventInfo.Text = "Time Event has been Outdated";
}
else if (windowType == "window")
{
EventInfo.Text = string.Format("{0}{1}Spawning Window",
(window.Hours > 0 ? string.Format("{0} Hour ", window.Hours) : string.Empty),
(window.Minutes > 0 ? string.Format("{0} Minute ", window.Minutes) : string.Empty));
}
else
{
EventInfo.Text = string.Empty;
}
}
else
{
EventInfo.Text = e.StageName;
}
}
