public static HRTimer create(TimerType type)
{
HRTimer timer = null;
switch (type)
{
case TimerType.DEFAULT:
{
timer = new DefaultTimer();
break;
}
case TimerType.MULTI_MEDIA:
{
timer = new MultiMediaTimer();
break;
}
case TimerType.TIMER_QUEUE:
{
timer = new TimerQueueTimer();
break;
}
}
return (timer);
}
public static Timer Add(TimerType timerType, TimerCycles timerCycles, double timerLength)
{
string timerID = Guid.NewGuid().ToString();
Timer timer = Add(timerID, timerType, timerCycles, timerLength);
timer.TimerID = timerID;
return timer;
}
public Timer(float time, float time2)
{
Time1 = time;
Time2 = time2;
MyType = TimerType.RANDOM_TWO_CONSTANTS;
Reset();
}
public Timer CreateTimer(float duration, TimerType type = TimerType.Once, int times = -1)
{
++timerid;
Timer t = new Timer(duration, timerid, type, times);
timers.Add(timerid, t);
return t;
}
public static Timer Add(string timerID, TimerType timerType, TimerCycles timerCycles, double timerLength)
{
Timer timer = new Timer(timerType, timerCycles, HighResTimer.GetCurrentTickCount(), timerLength);
_timers.Add(timerID, timer);
timer.TimerID = timerID;
return timer;
}
public async Task<IHttpActionResult> PutTimerType(int id, TimerType timerType)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
if (id != timerType.TimerTypeID)
{
return BadRequest();
}
db.Entry(timerType).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TimerTypeExists(id))
{
return NotFound();
}
else
{
throw;
}
}
return StatusCode(HttpStatusCode.NoContent);
}
public Event(object actor, int delay, TimerType type, string method, object[] arguments)
{
Actor = actor;
Delay = delay;
Type = type;
Method = method;
Arguments = arguments;
}
public Timer(float duration, int timerId, TimerType type = TimerType.Once, int times = -1)
{
countDown = 0.0f;
this.duration = duration;
this.timerId = timerId;
this.type = type;
state = Phase.NeverStart;
this.times = times;
}
internal Timer(TimerType timerType, TimerCycles timerCycles, long startTick, double len)
{
Type = timerType;
Cycles = timerCycles;
StartTick = startTick;
LastEventTick = startTick;
Length = (long)(len * (double)HighResTimer.TicksPerSecond);
Paused = false;
}
public static ITimer GetTimer(TimerType timerType)
{
switch (timerType)
{
case TimerType.Inverted:
return new FwTimer(1, TimerType.Inverted);
default:
return new FwTimer(1, TimerType.Normal);
}
}
public Timer(double duration, TimerType timerType, string parameter, bool failContract)
: base("")
{
this.duration = duration;
this.timerType = timerType;
this.parameter = parameter;
this.fakeFailures = !failContract;
disableOnStateChange = false;
}
public TimerElement (string text, float duration, TimerType type, System.Action onEnd=null) {
Text = text;
this.duration = duration
#if FAST_TIME
* 0.1f
#endif
;
this.type = type;
this.onEnd = onEnd;
Reset ();
}
public async Task<IHttpActionResult> PostTimerType(TimerType timerType)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
db.TimerTypes.Add(timerType);
await db.SaveChangesAsync();
return CreatedAtRoute("DefaultApi", new { id = timerType.TimerTypeID }, timerType);
}
public FwTimer()
{
// to be sure everything is initialized
_running = false;
_interval = DEFAULT_INTERVAL;
_timer = new Timer {AutoReset = false};
_timer.Elapsed += OnElapse;
_status = TimerLogStatus.Disabled;
_type = TimerType.Inverted;
_startTime = DateTime.Now;
_endTime = _startTime.AddSeconds(_interval);
}
public void SetAffect(string name, Mob afflicted, Mob owner, TimerType durationType, int duration, bool tickmethod, bool endmethod)
{
Name = name;
HandlingName = name.ToLower().Trim();
Duration = duration;
DurationType = durationType;
Owner = owner;
Afflicted = afflicted;
Level = Owner.Level;
CanHasTickMethod = tickmethod;
CanHasEndMethod = endmethod;
}
public WaitingPeriodState(int stateId, TimerType timerType, int?delayPeriod, DateInterval?dateInterval,
RunOn?runOn, TimeSpan?runAt, RunType?runType, DateTime?runOnDate, DateTime?startDate, DateTime?endDate,
IEnumerable <DayOfWeek> runOnDays, int workflowId, IWorkflowService workflowService, IPublishSubscribeService pubSubService)
: base(stateId)
{
this.timerType = timerType;
this.delayPeriod = delayPeriod;
this.dateInterval = dateInterval;
this.runOn = runOn;
this.runAt = runAt;
this.runType = runType;
this.runOnDate = runOnDate;
this.startDate = startDate;
this.endDate = endDate;
this.runOnDays = runOnDays;
this.workflowId = workflowId;
this.pubSubService = pubSubService;
this.workflowService = workflowService;
}
public void DecrementAffects(Mob mob, TimerType type)
{
List <Affect> ToRemove = new List <Affect>();
foreach (Affect affect in mob.Affects)
{
if (affect.DurationType == type)
{
if (affect.Decrement() == 0)
{
ToRemove.Add(affect);
}
}
}
foreach (Affect affect in ToRemove)
{
mob.Affects.Remove(affect);
}
}
public static void RaiseTimerEvents(TimerType timerType, long engineTick)
{
List <string> expiredTimers = new List <string>();
foreach (KeyValuePair <string, Timer> timer in _timers)
{
// checking this TimerType? (i.e., PreCycle or PostCycle)
if (timer.Value.Type == timerType)
{
// "push" time forward for Paused Timer instances
if (Paused || timer.Value.Paused)
{
timer.Value.LastEventTick += (engineTick - timer.Value.LastEventTick);
continue;
}
// check if Timer.Length time has passed
while (engineTick - timer.Value.LastEventTick >= timer.Value.Length)
{
// save the time this event was scheduled to run;
// might be different from engineTick, but storing this value
// will ensure that a lag in repeating timer events does not
// accumulate over time
timer.Value.LastEventTick += timer.Value.Length;
// raise the event
timer.Value.RaiseTick();
// check for any expired timers
if (timer.Value.Cycles == TimerCycles.Once)
{
expiredTimers.Add(timer.Key);
}
}
}
}
// remove any expired timers
foreach (string expired in expiredTimers)
{
_timers.Remove(expired);
}
}
public void Start(uint ms, bool repeat)
{
// Kill any existing timer
Stop();
// Set the timer type flags
TimerType timerType = TimerType.TIME_CALLBACK_FUNCTION | (repeat ? TimerType.TIME_PERIODIC : TimerType.TIME_ONESHOT);
lock (lock_)
{
timerId_ = timeSetEvent(ms, 0, TimerCallback, UIntPtr.Zero, (uint)timerType);
if (timerId_ == 0)
{
throw new Exception("timeSetEvent error");
}
Debug.WriteLine("MMTimer " + timerId_.ToString() + " started");
}
}
public static int GetColumnCountForTimerType(TimerType timerType)
{
switch (timerType)
{
case TimerType.CHECKIN:
return(5);
case TimerType.ARRIVAL:
return(3);
case TimerType.VOTING_BOOTH:
case TimerType.BALLOT_SCANNING:
case TimerType.THROUGHPUT:
return(4);
case TimerType.BMD:
default:
return(5);
}
}
public static string GenerateUpdateTimeRecordSQL(TimerType data, TimeSpan elapsed)
{
StringBuilder sqlStatement = new StringBuilder();
try
{
string currentDateTime = DateToDBDateTime(DateTime.Now);
sqlStatement.AppendLine("UPDATE time_sheet SET ");
sqlStatement.AppendLine(string.Format("work_end_time = '{0}'", currentDateTime));
sqlStatement.AppendLine(string.Format(",mins_accrued = '{0}'", elapsed.TotalMinutes));
sqlStatement.AppendLine(string.Format("WHERE work_id = '{0}'", data.db_id));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(sqlStatement.ToString());
}
/// <summary>
/// Creates a new timer object and adds it to the corresponding database.
/// </summary>
/// <param name="JSON">JSON-formatted string-string Dictionary codifying the parameters to pass to <paramref name="ClassName"/>.<paramref name="MethodName"/>()</param>
/// <param name="ClassName">The name of the class containing <paramref name="MethodName"/>.</param>
/// <param name="MethodName">The name of the method to call when the event is triggered.</param>
/// <param name="SecondsTillExpiration">Time until the event expires (Expire) or triggers (Interval).</param>
/// <param name="TimerType">Whether the timer is a single-trigger timer (Expire) or triggers every set number of <paramref name="SecondsTillExpiration"/> (Interval).</param>
/// <returns>A <c>Task</c> object, which can be awaited until this method completes successfully.</returns>
public async Task <string> AddTimer(string JSON, string ClassName, string MethodName, int SecondsTillExpiration, TimerType TimerType)
{
string Token = CreateToken();
EventTimer Timer = new () {
Token = Token,
ExpirationLength = SecondsTillExpiration,
CallbackClass = ClassName,
CallbackMethod = MethodName,
CallbackParameters = JSON,
ExpirationTime = DateTimeOffset.UtcNow.ToUnixTimeSeconds() + (TimerType != TimerType.Interval ? SecondsTillExpiration : 0),
TimerType = TimerType
};
EventTimersDB.EventTimers.Add(Timer);
await EventTimersDB.SaveChangesAsync();
return(Timer.Token);
}
/// <summary>
///
/// this.timerTimer = new System.Threading.Timer(new TimerCallback(this.EvTimer));
/// </summary>
/// <param name="codeMemberMethod"></param>
/// <param name="timer"></param>
private void WriteInitializeTimer(CodeMemberMethod codeMemberMethod, TimerType timer)
{
// this.timerRedTimer = new Timer();
//codeMemberMethod.Statements.Add(
// new CodeAssignStatement(
// new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), GetTimerFieldName(timer)),
// new CodeObjectCreateExpression("System.Timers.Timer")));
// new TimerCallback(this.EvTimer)
var delegateTimerCallback = new CodeDelegateCreateExpression(
new CodeTypeReference("TimerCallback"),
new CodeThisReferenceExpression(), timer.id);
//this.timerTimer = new System.Threading.Timer(new TimerCallback(this.EvTimer));
codeMemberMethod.Statements.Add(
new CodeAssignStatement(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), GetTimerFieldName(timer)),
new CodeObjectCreateExpression("System.Threading.Timer",
new CodeExpression[] {
delegateTimerCallback,
new CodePrimitiveExpression(null),
new CodeVariableReferenceExpression("Timeout.Infinite"),
new CodeVariableReferenceExpression("Timeout.Infinite")
})));
// this.timerRedTimer.Elapsed += new ElapsedEventHandler(this.EvTimerRed);
//CodeDelegateCreateExpression timerDelegate = new CodeDelegateCreateExpression(
// new CodeTypeReference("ElapsedEventHandler"),
// new CodeThisReferenceExpression(), timer.id);
//CodeAttachEventStatement attachStatement = new CodeAttachEventStatement(new CodeFieldReferenceExpression(
// new CodeThisReferenceExpression(), GetTimerFieldName(timer)), "Elapsed", timerDelegate);
//codeMemberMethod.Statements.Add(attachStatement);
// this.timerRedTimer.AutoReset = false;
//codeMemberMethod.Statements.Add(
// new CodeAssignStatement(
// new CodeFieldReferenceExpression(
// new CodeFieldReferenceExpression(
// new CodeThisReferenceExpression(), GetTimerFieldName(timer)), "AutoReset"),
// new CodePrimitiveExpression(false)));
}
public void Start()
{
// Kill any existing timer
Stop();
// Set the timer type flags
TimerType timerType = TimerType.TIME_CALLBACK_FUNCTION |
TimerType.TIME_KILL_SYNCHRONOUS |
(IsPeriodic ? TimerType.TIME_PERIODIC : TimerType.TIME_ONESHOT);
lock (lock_)
{
timerId_ = timeSetEvent((uint)Interval, (uint)Resolution, callback_, UIntPtr.Zero, (uint)timerType);
if (timerId_ == 0)
{
throw new Exception("timeSetEvent error");
}
Debug.WriteLine("MMTimer " + timerId_.ToString() + " started");
}
}
public async void timerType_insert_and_delete()
{
var context = new JobTimerDbContext();
var timerTypeAccess = new TimerTypeAccess(context);
var timerType = new TimerType {
ID = 99999, Type = _fixture.Create <string>()
};
await timerTypeAccess.SaveAsync(timerType);
timerType.ID.Should().NotBe(0);
var timerTypeLoaded = await timerTypeAccess.LoadAsync(timerType.ID);
timerTypeLoaded.Type.Should().Be(timerType.Type);
var deletedCount = await timerTypeAccess.DeleteAsync(timerTypeLoaded);
deletedCount.Should().BeGreaterOrEqualTo(1);
}
public void EditTaskRunParam(Guid id, TimerType timerType, int interval, DateTime?startTime, bool runOnStart)
{
if (!tasks.ContainsKey(id))
{
throw new TaskNotExistException();
}
if (tasks[id].Status != TaskStatus.Stop)
{
throw new TaskNotStopException();
}
var t = tasks[id];
var configs = LoadTaskRunParam(t.AssemblyId);
var config = configs[t.TypeName];
config.interval = interval;
config.timerType = timerType;
config.startTime = startTime;
config.runOnStart = runOnStart;
t.runParam = config;
SaveTaskRunParam(t.AssemblyId, configs.Values);
}
public Timer(TimerType type, int startInMiliSeconds, int MiliSeconds, int repeatCount, int repeatInterval, OnTimeout PassedDelegate)
{
// nix mit Verarschen hier
if (startInMiliSeconds < 0)
{
startInMiliSeconds = -startInMiliSeconds;
}
if (MiliSeconds < 0)
{
MiliSeconds = -MiliSeconds;
}
Type = type;
StartInMiliSeconds = startInMiliSeconds;
MiliSecondsLeft = MiliSeconds;
Handler += PassedDelegate;
RepeatInterval = repeatInterval;
RepeatCount = repeatCount;
Active = true;
TimerManager.Timers.Add(this);
}
/// <summary>
///
/// </summary>
/// <param name="interval">时间间隔</param>
/// <param name="action">事件</param>
/// <param name="loop">loop为0表示永远执行,loop大于0表示次数</param>
public TimerInfo(float interval, int loop, LuaFunction func)
{
this.interval = interval;
this.func = func;
this.action = delegate() {
if (func != null)
{
func.Call();
}
};
this.loop = loop;
timerState = TimerState.Run;
if (this.loop > 0)
{
timerType = TimerType.Numeral;
}
else
{
timerType = TimerType.Forever;
}
}
private void Form1_Load(object sender, EventArgs e)
{
TimerType initialTimerType = Properties.Settings.Default.TimerType;
timerTypeListBox.BindEnumToListBox(initialTimerType);
ColorType initialColorType = Properties.Settings.Default.ColorType;
colorChoiceListBox.BindEnumToListBox(initialColorType);
int buildRate = Properties.Settings.Default.BuildRate;
int decayRate = Properties.Settings.Default.DecayRate;
int maxValue = Properties.Settings.Default.MaxValue;
bool keepLEDsLitCold = Properties.Settings.Default.KeepLEDsLitCold;
bool scaleBrightness = Properties.Settings.Default.ScaleBrightness;
this.buildRateTextBox.Text = $"{buildRate}";
this.decayRateTextBox.Text = $"{decayRate}";
this.maxHeatValueTextBox.Text = $"{maxValue}";
this.coldOFFCheckBox.Checked = keepLEDsLitCold;
this.scaleBrightnessCheckbox.Checked = scaleBrightness;
}
public int TimeLeft(int historyId, TimerType timerType)
{
switch (timerType)
{
case TimerType.Realtime:
if (ModuleTimers.TryGetValue(historyId, out TimerAssociates realtimeTimerAssociates))
{
return(Convert.ToInt32((realtimeTimerAssociates.ModuleFinish - DateTime.UtcNow).TotalSeconds));
}
return(0);
case TimerType.Individual:
if (IndividualQuizTimers.TryGetValue(historyId, out TimerAssociates indivdualTimerAssociates))
{
return(Convert.ToInt32((indivdualTimerAssociates.ModuleFinish - DateTime.UtcNow).TotalMilliseconds));
}
else
{
int timeLeft = Convert.ToInt32(Math.Round(TimeSpan.FromMinutes((from q in _context.Questions
join iq in _context.IndividualQuizPasseds on q.LectureId equals iq.LectureId
where iq.Id == historyId
select q).Count()).TotalMilliseconds / 2));
return(timeLeft);
}
case TimerType.Cumulative:
if (CumulativeQuizTimers.TryGetValue(historyId, out TimerAssociates cumulativeTimerAssociates))
{
return(Convert.ToInt32((cumulativeTimerAssociates.ModuleFinish - DateTime.UtcNow).TotalMilliseconds));
}
else
{
int timeLeft = Convert.ToInt32(Math.Round(TimeSpan.FromMinutes(20).TotalMilliseconds / 2));
return(timeLeft);
}
}
return(0);
}
private void ReadConfig()
{
if (!Directory.Exists(MC.SaveDirectory))
{
Directory.CreateDirectory(MC.SaveDirectory);
}
try
{
XmlDocument xml = new XmlDocument();
xml.Load(MC.ConfigFileName);
XmlElement node = xml["MegaSpawnerSystemConfig"];
try{ timerTypeSwitch = (TimerType)int.Parse(GetInnerText(node["TimerSetting"])); }
catch (Exception ex) { totalErrors++; AddToErrorLog(ex); }
try{ staffTriggerEventSwitch = bool.Parse(GetInnerText(node["StaffTriggerEvent"])); }
catch (Exception ex) { totalErrors++; AddToErrorLog(ex); }
}
catch
{
DefaultConfigCreate();
MessagesTitle = "Mega Spawner System Configuration";
Messages = "Configuration file not found, creating default configuration...";
}
SetConfigList();
ConfigRead = true;
if (totalErrors > 0)
{
MessagesTitle = "Mega Spawner System Configuration";
Messages = String.Format("{0} error{1} been detected.\nError Log:\n {2}", totalErrors, totalErrors == 1 ? " has" : "s have", ErrorLog);
}
}
/// <summary>
/// Setup the timer
/// </summary>
/// <param name="container">TMPro object that will contain the timer</param>
/// <param name="timerType">What type of timer will it be (Countdown, Stopwatch, Clock)</param>
/// <param name="countdownTime">The time that will have in case it is a countdown timer</param>
/// <returns></returns>
public static Timer SetupTimer(this TMP_Text container, TimerType timerType, TimerUpdate timerUpdate, float countdownTime = 60f)
{
Timer t = container.gameObject.AddComponent <Timer>();
float elapsedTime = 0f;
string text = string.Empty;
TimeSpan timePlaying = TimeSpan.Zero;
switch (timerType)
{
case TimerType.Countdown:
elapsedTime = countdownTime;
timePlaying = TimeSpan.FromSeconds(elapsedTime);
text = timePlaying.ToString("m':'ss'.'ff");
break;
case TimerType.Clock:
text = DateTime.Now.ToString("HH:mm:ss");
break;
}
t.Setup(elapsedTime, true, timePlaying, container, timerType, timerUpdate, text);
return(t);
}
/// <summary>
/// Update this instance.
/// </summary>
public virtual void Update()
{
days = ( playTime / 86400);
hours = (playTime / 3600) % 24;
minutes = (playTime / 60) % 60;
seconds = (playTime % 60);
fractions = (playTime * 1000 ) % 1000;
switch( currentTimer )
{
case TimerType.Playtime:
playTime = Time.time - startTime - continueTime + addToTime;
break;
case TimerType.FromLoad:
playTime = Time.timeSinceLevelLoad + addToTime;
break;
case TimerType.Countdown:
playTime = countdownDelay - Time.time + countdownAmount;
if( playTime < 0 )
{
currentTimer = TimerType.Inactive;
}
break;
case TimerType.Realtime:
playTime = Time.realtimeSinceStartup + addToTime;
break;
default:
break;
}
if( playTime > delayTime )
{
delayTime = playTime + delayRate;
}
}
/// <summary>
/// Stops the timer.
/// </summary>
public void StopTimer()
{
stopTime = playTime;
addToTime = 0;
currentTimer = TimerType.Inactive;
}
/// <summary>
/// Starts the time as Play Time..
/// </summary>
public void StartTimer()
{
startTime = Time.time;
addToTime = 0f;
continueTime = 0f;
currentTimer = TimerType.Playtime;
}
public TimerComponent(TimerType type = TimerType.Flag)
{
Type = type;
CurrentTime = new GameTime();
TargetTimeSpanMilliseconds = CurrentTime.TotalGameTime.TotalMilliseconds - 1;
}
public void SetTimerType(TimerType type) => timerType = type;
static public void StopTimer (TimerType which)
{
timers [(int) which] += DateTime.Now - timer_start [(int) which];
++timer_counters [(int) which];
}
public int GetTimer(TimerType whichTimer)
{
return(timers[(int)whichTimer]);
}
public void Start (TimerType type)
{
if (timers != null) {
var sw = new Stopwatch ();
timers[(int) type] = sw;
sw.Start ();
}
}
private void SetHoldThumbAreaTimer ()
{
timer.Enabled = false;
timer.Interval = 200;
timer_type = TimerType.HoldThumbArea;
timer.Enabled = true;
}
private void SetHoldButtonClickTimer ()
{
timer.Enabled = false;
timer.Interval = 200;
timer_type = TimerType.HoldButton;
timer.Enabled = true;
}
public void SetTimer(TimerType whichTimer, int newTimerValue)
{
timers[(int)whichTimer] = newTimerValue;
timersEnded[(int)whichTimer] = false;
}
protected string GetTimerStopName(TimerType timer)
{
return("TimerStop" + timer.name);
}
public TimerComponent(TimerType type, GameTime currentTime, double targetLifespanInMilliseconds = 0)
{
Type = type;
CurrentTime = currentTime;
TargetTimeSpanMilliseconds = currentTime.TotalGameTime.TotalMilliseconds + targetLifespanInMilliseconds;
}
protected string GetTimerFieldName(TimerType timer)
{
return("timer" + timer.name);
}
public void Stop (TimerType type)
{
if (timers != null) {
timers[(int) type].Stop ();
}
}
static public void StopTimer(TimerType which)
{
timers [(int)which] += DateTime.Now - timer_start [(int)which];
++timer_counters [(int)which];
}
private void SetRepeatButtonTimer ()
{
timer.Enabled = false;
timer.Interval = 50;
timer_type = TimerType.RepeatButton;
timer.Enabled = true;
}
public void CountUp()
{
_timerType = TimerType.CountUp;
}
private void SetRepeatThumbAreaTimer ()
{
timer.Enabled = false;
timer.Interval = 50;
timer_type = TimerType.RepeatThumbArea;
timer.Enabled = true;
}
public void CountDown()
{
_timerType = TimerType.CountDown;
}
public void Stop (TimerType type)
{
if (timers != null) {
timers[(int) type].Stop ();
}
}
/// <summary>
/// Starts the counter using realtime.
/// </summary>
public void RealTime()
{
realTime = Time.realtimeSinceStartup;
startTime = 0f;
addToTime = 0f;
currentTimer = TimerType.Realtime;
}
static public void StartTimer (TimerType which)
{
timer_start [(int) which] = DateTime.Now;
}
/// <summary>
/// Reset the timer.
/// </summary>
public void Reset()
{
stopTime = 0f;
playTime = 0f;
continueTime = 0f;
addToTime = 0f;
currentTimer = TimerType.Inactive;
}
static public void ShowTimer (TimerType which, string msg)
{
Console.WriteLine (
"[{0:00}:{1:000}] {2} (used {3} times)",
(int) timers [(int) which].TotalSeconds,
timers [(int) which].Milliseconds, msg,
timer_counters [(int) which]);
}
/// <summary>
/// Resumes the timer.
/// </summary>
public void Resume()
{
continueTime = Time.time - playTime;
startTime = 0f;
addToTime = 0f;
currentTimer = TimerType.Playtime;
}
static public void StartTimer(TimerType which)
{
timer_start [(int)which] = DateTime.Now;
}
public bool HasTimerEnded(TimerType whichTimer)
{
return(timersEnded[(int)whichTimer]);
}
