public async Task <int> AddEvent(CommandContext ctx, EventType type, string message, DateTime eventTime, ulong channelId = 0) { List <ulong> mentionedUserIds = new List <ulong>(); List <ulong> mentionedRoleIds = new List <ulong>(); ctx.Message.MentionedUsers.ToList().ForEach(user => mentionedUserIds.Add(user.Id)); ctx.Message.MentionedRoles.ToList().ForEach(user => mentionedRoleIds.Add(user.Id)); TimedEvent tEvent = new TimedEvent { Type = type, Message = message, EventTime = eventTime, UserId = ctx.User.Id, ChannelId = channelId > 0 ? channelId : ctx.Channel.Id, MentionUserIdList = mentionedUserIds.ToArray(), MentionRoleIdList = mentionedRoleIds.ToArray() }; tEvent.Id = (await ShimakazeBot.DbCtx.TimedEvents.AddAsync(tEvent)).Entity.Id; try { await ShimakazeBot.DbCtx.SaveChangesAsync(); } catch (Exception e) { await ctx.RespondAsync(e.Message); } return(AddAndStartEvent(EventInTimer.MakeTimer(tEvent), tEvent.Id) ? tEvent.Id : -1); }
public Form(int x, int y) { Ready = false; Controls = new List <IFormControl>(); Position = new Vector2(x, y); ReveilEvent = new TimedEvent(200, () => { if (Reveiling) { Controls[ReveilIndex].Visible = true; ContentHandler.Sounds["Swoosh"].Play(); if (ReveilIndex < Controls.Count - 1) { ReveilIndex++; } else { Reveiling = false; Ready = true; } } }, -1); }
private void Blank_OnExecute(TimedEvent timedEvent) { if (timedEvent.FirstExecution) { destinationSlot.SetVisible(false); } }
public int schedule(TimedEvent task, DateTime time) { long t = time.Ticks - DateTime.Now.Ticks; t = Math.Abs(t); return(schedulemms(task, t)); }
private static PlaybackEvent GetPlaybackEventWithNoteMetadata(TimedEvent timedEvent, TempoMap tempoMap, NotePlaybackEventMetadata noteMetadata) { var playbackEvent = new PlaybackEvent(timedEvent.Event, timedEvent.TimeAs <MetricTimeSpan>(tempoMap), timedEvent.Time); playbackEvent.Metadata.Note = noteMetadata; return(playbackEvent); }
public void GenerateSpan() { ZipkinEndpoint localEndpoint = new ZipkinEndpoint() { ServiceName = "tweetiebird" }; var traceId = "d239036e7d5cec116b562147388b35bf"; var spanId = "9cc1e3049173be09"; var parentId = "8b03ab423da481c5"; Dictionary <string, IAttributeValue> attributes = new Dictionary <string, IAttributeValue>(); IList <ITimedEvent <IAnnotation> > annotations = new List <ITimedEvent <IAnnotation> >(); List <ITimedEvent <IMessageEvent> > networkEvents = new List <ITimedEvent <IMessageEvent> >() { TimedEvent <IMessageEvent> .Create(Timestamp.Create(EPOCH_SECONDS + 1505855799, 433901068), new MessageEventBuilder(MessageEventType.RECEIVED, 0, 0, 0).SetCompressedMessageSize(7).Build()), TimedEvent <IMessageEvent> .Create(Timestamp.Create(EPOCH_SECONDS + 1505855799, 459486280), new MessageEventBuilder(MessageEventType.SENT, 0, 0, 0).SetCompressedMessageSize(13).Build()) }; ISpanData data = SpanData.Create( SpanContext.Create( TraceId.FromBytes(Arrays.StringToByteArray(traceId)), SpanId.FromBytes(Arrays.StringToByteArray(spanId)), TraceOptions.FromBytes(new byte[] { 1 })), SpanId.FromBytes(Arrays.StringToByteArray(parentId)), true, /* hasRemoteParent */ "Recv.helloworld.Greeter.SayHello", /* name */ Timestamp.Create(EPOCH_SECONDS + 1505855794, 194009601) /* startTimestamp */, Attributes.Create(attributes, 0 /* droppedAttributesCount */), TimedEvents <IAnnotation> .Create(annotations, 0 /* droppedEventsCount */), TimedEvents <IMessageEvent> .Create(networkEvents, 0 /* droppedEventsCount */), LinkList.Create(new List <ILink>(), 0 /* droppedLinksCount */), null, /* childSpanCount */ Status.OK, Timestamp.Create(EPOCH_SECONDS + 1505855799, 465726528) /* endTimestamp */); var handler = new TraceExporterHandler(new TraceExporterOptions() { UseShortTraceIds = false }); var result = handler.GenerateSpan(data, localEndpoint); var zspan = ZipkinSpan.NewBuilder() .TraceId(traceId) .ParentId(parentId) .Id(spanId) .Kind(ZipkinSpanKind.SERVER) .Name(data.Name) .Timestamp(1505855794000000L + (194009601L / 1000)) .Duration( (1505855799000000L + (465726528L / 1000)) - (1505855794000000L + (194009601L / 1000))) .LocalEndpoint(localEndpoint) .AddAnnotation(1505855799000000L + (433901068L / 1000), "RECEIVED") .AddAnnotation(1505855799000000L + (459486280L / 1000), "SENT") .PutTag("census.status_code", "OK") .Build(); Assert.Equal(zspan, result); }
public void Clone() { var timedEvent = new TimedEvent(new NoteOnEvent((SevenBitNumber)100, (SevenBitNumber)50)); Assert.IsTrue(TimedEventEquality.AreEqual(timedEvent, timedEvent.Clone(), true), "Clone of a timed event doesn't equal to the original one."); }
public void AdvertiseCallback(TimedEvent timer) { foreach (string arg in BroadcastMessage) { Server.Broadcast(arg); } }
void bs_times_CurrentItemChanged(object sender, EventArgs e) { var selection = grid.SelectedCells.Cast <DataGridViewCell>().Select(fn => fn.RowIndex).Distinct().ToArray(); var adding = TimeSpan.Zero; foreach (var index in selection) { var ev = (TimedEvent)grid.Rows[index].DataBoundItem; adding += ev.ComputeDuration(); } string msg = ""; if (selection.Length > 1) { msg = $" Selection: {(int)adding.TotalHours}:{adding.Minutes:00}"; } var time = TimedEvent.ComputeDuration(Times(), true); lblHours.Text = $"Time: {(int)time.TotalHours}:{time.Minutes:00}{msg}"; if (Started() != null) { btnStartStop.Text = "Stop Timing"; } else { btnStartStop.Text = "Start Timing"; } }
public void OnTimerCB(TimedEvent evt) { if (Globals.Contains(evt.Name + "Callback")) { Invoke(evt.Name + "Callback", evt); } }
public LLUDPServer(LLUDP udp, IScene scene, IPAddress bindAddress, int port, IConfigSource configSource, IScheduler scheduler) : base(bindAddress, port) { m_udp = udp; Scene = scene; Scheduler = scheduler; IConfig throttleConfig = configSource.Configs["LLUDP"]; m_throttleRates = new ThrottleRates(LLUDPServer.MTU, throttleConfig); m_resendTimer = new TimedEvent(100); m_ackTimer = new TimedEvent(500); m_pingTimer = new TimedEvent(5000); m_httpServer = Scene.Simian.GetAppModule <IHttpServer>(); IConfig config = configSource.Configs["LLUDP"]; if (config != null) { m_asyncPacketHandling = config.GetBoolean("AsyncPacketHandling", true); m_recvBufferSize = config.GetInt("SocketReceiveBufferSize", 0); } m_throttle = new TokenBucket(null, m_throttleRates.SceneTotalLimit, m_throttleRates.SceneTotal); PacketEvents = new PacketEventDictionary(Scheduler); Scene.OnPresenceRemove += PresenceRemoveHandler; }
// // Interface Contracts // /// <summary> /// Called by the TimedEvent holding this animation /// </summary> public void ExecuteCommand() { this.Animate(); this.UpdateIntervalTime(); this.currentEvent = null; this.ProgressToNextUnit(); }
/// <summary> /// Initialize scene. /// </summary> public override void Init() { // Call base init. base.Init(); // Set texture of the scene. Texture2D texture = Game.Content.Load <Texture2D>("Images/Screens/GameOver"); // Load the nintendo logo. MonoSprite logo = new MonoSprite(texture, new Rectangle(0, 0, SuperPlatformerGame.RESOLUTION_X, SuperPlatformerGame.RESOLUTION_Y), Vector2.Zero, SuperPlatformerGame.RESOLUTION_X, SuperPlatformerGame.RESOLUTION_Y); // Add the logo to the drawlist. Children.Add(logo); _sound = Game.Content.Load <SoundEffect>("Audio/smw_gameover"); if (_sound != null) { _sound.Play(); } // Set and start the timer. _durationTimer = new TimedEvent(OnTimerElapsed, _duration); _durationTimer.Enable(); }
/// <inheritdoc/> public void AddEvent(string name, IDictionary <string, object> eventAttributes) { if (name == null) { throw new ArgumentNullException(nameof(name)); } if (eventAttributes == null) { throw new ArgumentNullException(nameof(eventAttributes)); } if (!this.IsRecordingEvents) { return; } lock (this.@lock) { if (this.HasEnded) { // logger.log(Level.FINE, "Calling AddEvent() on an ended Span."); return; } this.InitializedEvents.AddEvent(TimedEvent <IEvent> .Create(PreciseTimestamp.GetUtcNow(), Event.Create(name, eventAttributes))); } }
public void handleMouseInput() { // if the mouse is in the range of the player and the player is // not frozen if (!freeze) { // if you are clicking left the tell playerToWorld to delete the block // if they are clicking right then try and add a block if (Input.GetButtonDown("Fire1") && isMouseClickInRange()) { // create a timed event for the left click that must be complete to do again Vector3Int mousePos = getMousePositionAsInt(); TimedEvent.create(() => removeTile(mousePos), 1f, "leftClick"); } else if (Input.GetButtonDown("Fire2") && isMouseClickInRange() && !isMouseOverPlayer()) { placeTile(getMousePositionAsInt()); } } // if the player is scrolling at all then change the selected item if ((int)Input.mouseScrollDelta.y != 0) { playerToWorld.changeSelectedItem((int)Input.mouseScrollDelta.y); } }
public PatternActionResult Invoke(long time, PatternContext context) { var programEvent = Program.GetProgramEvent(context.Channel); var timedEvent = new TimedEvent(programEvent, time); return(new PatternActionResult(time, new[] { timedEvent })); }
public PatternActionResult Invoke(long time, PatternContext context) { var textEvent = (BaseTextEvent)Activator.CreateInstance(typeof(TEvent), Text); var timedEvent = new TimedEvent(textEvent, time); return(new PatternActionResult(time, new[] { timedEvent })); }
public void KillTimer(TimedEvent timer) { if (timer != null) { timer.Kill(); Timers.Remove(timer.Name); } }
public void KillParallelTimer(TimedEvent timer) { if (timer != null) { timer.Kill(); ParallelTimers.Remove(timer); } }
public ProcedimentosAdmin() { InitializeComponent(); Fill(); ControlsH.CreateColumns(ProcedimentosDG, typeof(Procedimento_Table)); TimedEvent = new TimedEvent(1, 2, true, UpdateProcedimentos); TimedEvent.TriggerNow(); }
/// <summary> /// Add an event to the map /// </summary> /// <param name="ev"></param> /// <returns>unique id of the added event, negative if the adding the event failed</returns> public int AddEvent(TimedEvent ev) { // assign and return the unique id int eventId = ++idCounter; eventMap.Add(eventId, ev); return eventId; }
// // Constructor // public PlayerRespawner() { // DATA SET this.respawnWait = 2.5f; // Add self to timer this.timedEvent = TimedEventManager.Active.Create(this, this.respawnWait); }
public EventTimer AddTimer(float duration, TimedEvent callbackFunction) { EventTimer newTimer = new EventTimer(duration, callbackFunction); currentTimers.Add(newTimer); return(newTimer); }
public void goToStage(int stage) { _currentEventSet = retrieveStage(stage); StopAllCoroutines(); currentStage = stage; startTime = Time.time; _nextEvent = null; }
// // Constructor // public Animation() : base() { this.currentUnit = null; this.currentEvent = null; this.intervalTime = 1.0f; this.requestedNewIntervalTime = this.intervalTime; this.isLooping = false; }
public PesquisaPessoas() { InitializeComponent(); ControlsH.CreateColumns(PessoasDG, typeof(Table1)); ControlsH.CreateColumns(EnderecoDG, typeof(Table2)); TimedEvent = new TimedEvent(1, 3, true, UpdatePessoas); TimedEvent.TriggerNow(); }
public HttpResponseMessage Put(TimedEvent timedEvent) { HeatingService.UpdateEvent(timedEvent); var response = Request.CreateResponse<TimedEvent>(System.Net.HttpStatusCode.OK, timedEvent); return response; }
public void _handleIncentives(IMessageBase message) { //Logger.Debug("handle incentives"); Incentives incentives = (Incentives)message; List <RevokeEvent> revokeEvents = new List <RevokeEvent>(); List <TimedEvent> actuationEvents = new List <TimedEvent>(); foreach (TimedEvent newEvent in incentives.Events) { var newTimedEvent = (TimedEvent)newEvent; if (newEvent is RevokeEvent) { revokeEvents.Add((RevokeEvent)newTimedEvent); } else { actuationEvents.Add(newTimedEvent); } } lock (_events) { _events.RemoveAll(event_ => revokeEvents.TrueForOne( revokeEvent => revokeEvent.Id == event_.Id ) ); foreach (TimedEvent newEvent in actuationEvents) { TimedEvent eventToOverwrite = _events.Find(existingEvent => newEvent.StrategyId == existingEvent.StrategyId && newEvent.Id == existingEvent.Id); if (eventToOverwrite == null) { _events.Add(newEvent); } else { eventToOverwrite.OverrideWith(newEvent); } } } //double minDistance = double.MaxValue; //Vector minPosition = null; //Vector currentPosition = CurrentPosition; //foreach (Vector position in positions) //{ // double distance = (currentPosition - position).SqrMagnitude; // if (distance < minDistance) // { // minDistance = distance; // minPosition = position; // } //} // _recommendedPosition = minPosition; }
public void SetTime_NonZero() { var tempoMap = TempoMap.Default; var timedEvent = new TimedEvent(new NoteOnEvent(), 1000); var changedTimedEvent = timedEvent.SetTime(new MetricTimeSpan(0, 0, 2), tempoMap); Assert.AreSame(timedEvent, changedTimedEvent, "Changed timed event is not the original one."); Assert.AreEqual(changedTimedEvent.TimeAs <MetricTimeSpan>(tempoMap), new MetricTimeSpan(0, 0, 2), "Time is invalid."); }
public void SetTime_Zero() { var tempoMap = TempoMap.Default; var timedEvent = new TimedEvent(new NoteOnEvent(), 1000); var changedTimedEvent = timedEvent.SetTime(new MetricTimeSpan(), tempoMap); Assert.AreSame(timedEvent, changedTimedEvent, "Changed timed event is not the original one."); Assert.AreEqual(0, changedTimedEvent.Time, "Time is not zero."); }
// Start is called before the first frame update void Start() { StartCoroutine(BeatGroupInitializer()); if (events.Length > 0) { Array.Sort(events); _nextEvent = events[_eventIndex]; } }
public Player(Vector2 position) { _position = position; _initialPosition = Position; _state = PlayerState.Idle; _timedEventInvinsible = new TimedEvent(2000, () => IsInvinsible = false); _isVisible = true; }
public static void AddEvent(TimedEvent timedEvent) { if (timedEvent.Id == 0) { highestEventId++; timedEvent.Id = highestEventId; } else if (timedEvent.Id > highestEventId) highestEventId = timedEvent.Id; Events.Add(timedEvent); }
public IEnumerable<TimedEvent> GetRange(DateTime RangeStart, DateTime RangeEnd) { // Handle zero interval condition if (_Interval == TimeSpan.Zero) yield break; // Check event intersection with range TimeSpan RangeDuration = RangeEnd - RangeStart; DateTime IterateStart = SynchronizeTime(RangeStart); DateTime IterateEnd = RangeEnd; // Check first event // EEEE EEEE // WWWWWWW TimedEvent FirstEvt = new TimedEvent( (IterateStart.Ticks >= _Interval.Ticks ? // Handle when IterateStart is near DateTime.MinValue IterateStart.Subtract(_Interval) : DateTime.MinValue), _Duration); if (FirstEvt.StartTime != IterateStart && FirstEvt.Intersects(new TimedEvent(RangeStart, RangeEnd))) yield return FirstEvt; if (DateTime.MaxValue - IterateEnd >= _Interval) { for (DateTime dt = IterateStart; dt < IterateEnd; dt = dt.Add(_Interval)) yield return new TimedEvent(dt, dt.Add(_Duration)); } else { // Special case when end of iteration is very close to DateTime.MaxValue // IterateEnd must be at least > Interval time to match any events if (IterateEnd.Ticks >= _Interval.Ticks) { DateTime IterateEnd2 = IterateEnd.Subtract(_Interval); for (DateTime dt = IterateStart; ; dt = dt.Add(_Interval)) { yield return new TimedEvent(dt, dt.Add(_Duration)); if (dt >= IterateEnd2) break; } } } yield break; }
public IEnumerable<TimedEvent> GetRange(DateTime RangeStart, DateTime RangeEnd) { TimedEvent RangeEvent = new TimedEvent(RangeStart, RangeEnd); IEnumerable<TimedEvent> Enum1 = _OffsetTime.Ticks >= 0 ? _Schedule.GetRange(SafeDateTimeAdd(RangeStart, _OffsetTime.Negate()), DateTime.MaxValue) : _Schedule.GetRange(SafeDateTimeAdd(RangeStart, _OffsetTime), DateTime.MaxValue); foreach (TimedEvent Evt in Enum1) { TimedEvent OffsetEvt; try { OffsetEvt = new TimedEvent(Evt.StartTime + _OffsetTime, Evt.EndTime + _OffsetTime); } catch (ArgumentOutOfRangeException) { // This occurs when _OffsetTime is added to StartTime or EndTime and causes an overflow or underflow. // In this case, we ignore this event, since it can't be represented. continue; } if (OffsetEvt.StartTime >= RangeEnd) break; if (OffsetEvt.Intersects(RangeEvent)) yield return OffsetEvt; } yield break; }
/// <summary>. /// Insert a timer event in the queue. Timer values are /// recursively defined by the summation of preceding timer values. /// So inserting a timeEvent with a value of 7 seconds may look as follows: /// /// Q before: 2 -> 3 -> 1 -> 5 -> ... /// /// Insert(7): 2 -> 3 -> 1 -> 1 -> 4 -> ... /// ^ seven inserted here. 1 + summation of preceding timers is 7. /// </summary> public void Insert(TimedEvent timedEvent) { int i = 0; Console.WriteLine("insert " + timedEvent.Timer_ms); //spool to proximity-based index for this event while (timedEvent.Timer_ms > 0 && i < _Q.Count) { timedEvent.Timer_ms -= _Q[i].Timer_ms; if (timedEvent.Timer_ms > 0) { i++; } } //insert and decrement right neighbor if (i < _Q.Count) { //There's some pencil work here to adjust the timerVals, and the neighbor. timedEvent.Timer_ms += _Q[i].Timer_ms; _Q[i].Timer_ms -= timedEvent.Timer_ms; _Q.Insert(i, timedEvent); } //degenerate case: end of list, just insert at the end else { _Q.Add(timedEvent); } //Console.WriteLine("Inserted event with tmr: "+timedEvent._timer_ms); }
public TimedEventBooleanUnitTest(string Name, TimedEvent Event, Func<TimedEvent, bool> TimedEventFunc, bool ExpectedResult) { this.Name = Name; this.Event = Event; this.TimedEventFunc = TimedEventFunc; this.ExpectedResult = ExpectedResult; }
private static void ProcessRelay(Heater p_Heater, TimedEvent p_Event, Boolean p_StaySame) { // if p_StaySame the relay should stay off if already off or on if already on bool bTooHot = false; for (int a = 0; a < p_Heater.Sensors.Count; a++) { if (p_Heater.Sensors[a].Reading >= p_Heater.TempMax) { bTooHot = true; break; } } if (!bTooHot) { bool bFound = false; bool bState = (p_Event.Type == (int)TimedEvent.EventType.Heat); for (int k = 0; k < m_oProcessedRelays.Count; k++) { if (p_Heater.RelayAddress == m_oProcessedRelays[k][0]) { if (p_Event.Id >= int.Parse(m_oProcessedRelays[k][1])) {// highest event id has priority RelayControl.SetupRelay(p_Heater.RelayAddress, (p_StaySame) ? RelayControl.GetRelayState(p_Heater.RelayAddress) : bState); m_oProcessedRelays[k][1] = p_Event.Id.ToString(); } bFound = true; } } if (!bFound) { RelayControl.SetupRelay(p_Heater.RelayAddress, (p_StaySame) ? RelayControl.GetRelayState(p_Heater.RelayAddress) : bState); string[] saUsedRelay = new string[3]; saUsedRelay[0] = p_Heater.RelayAddress; saUsedRelay[1] = p_Event.Id.ToString(); m_oProcessedRelays.Add(saUsedRelay); } } }
// Optimized 2008-07-13 public IEnumerable<TimedEvent> GetRange(DateTime RangeStart, DateTime RangeEnd) { /* Subtraction complex example: * Input: * A: xxxx xxxx * B: xxxxxx * * Compare: * A: AAAA xxxx * B: BBBBBB * * Compute subtraction: * A: AA-- xxxx * A: --BBBB * * Compare next: * A: RR AAAA * B: BBBB * * Compute subtraction: * A: RR --AA * B: BB-- * * Result: * RR RR * */ // Prepare iterator A. var IteratorA = _ScheduleA.GetRange(RangeStart, RangeEnd).GetEnumerator(); bool HasMoreA = IteratorA.MoveNext(); // If no events in schedule A, quit now. if (!HasMoreA) yield break; // Prepare iterator B. var IteratorB = _ScheduleB.GetRange(RangeStart, RangeEnd).GetEnumerator(); bool HasMoreB = IteratorB.MoveNext(); List<TimedEvent> QueueA = new List<TimedEvent>(); bool readvanceFlag; do { readvanceFlag = false; // Get next event for A from queue or iterator, whichever is earliest. TimedEvent A = default(TimedEvent); if (QueueA.Count > 0 && (!HasMoreA || QueueA[0] <= IteratorA.Current)) { // Pop event off queue A. A = QueueA[0]; QueueA.RemoveAt(0); } else if (HasMoreA) { // If queue is empty or iterator's current value is earlier, // get next event from A and put it on the queue. QueueA.Add(IteratorA.Current); HasMoreA = IteratorA.MoveNext(); readvanceFlag = true; continue; } bool recompareFlag; do { // comparison code block. recompareFlag = false; if (!HasMoreB) { // If no more events from B, return remaining events from A. yield return A; } else { // Compare A <=> B. var B = IteratorB.Current; // AAAA // BBBB if (A.EndTime <= B.StartTime) { // No intersection, return A. yield return A; } // AAAA or AAAA or AAAA or AA // BBBB BB BBBB BBBB else if (B.EndTime > A.StartTime) { // AAAA or AAAA // BBBB BB if (A.StartTime < B.StartTime) { var NewA = new TimedEvent(A.StartTime, B.StartTime); QueueA.Add(NewA); if (B.EndTime < A.EndTime) { var NewA2 = new TimedEvent(B.EndTime, A.EndTime); QueueA.Add(NewA2); } } // AAAA or AA // BBBB BBBB else if (B.EndTime < A.EndTime) { var NewA = new TimedEvent(B.EndTime, A.EndTime); QueueA.Add(NewA); } } else { // AAAA // BBBB // No intersection, advance schedule B and recompare. HasMoreB = IteratorB.MoveNext(); recompareFlag = true; continue; } } // if (!HasMoreB) else } while (recompareFlag); // Continue until no more events from A. } while (readvanceFlag || HasMoreA || QueueA.Count > 0); yield break; }
public static void UpdateEvent(TimedEvent timedEvent) { if (timedEvent.Id != 0) { if (timedEvent.Id > highestEventId) highestEventId = timedEvent.Id; TimedEvent anEvent = GetEventById(timedEvent.Id); if (anEvent != null) anEvent.setData(timedEvent); } }
/// <summary> /// Constructor for event with a start time and duration. /// </summary> /// <param name="EventTime">Date/time of event.</param> /// <param name="Duration">Duration of event.</param> public OneTimeSchedule(DateTime StartTime, TimeSpan Duration) { _Event = new TimedEvent(StartTime, Duration); _Notation = NotationKind.Lasting; }
/// <summary> /// GameModel.Initiaize() must be called before this, to make sure required objects exist. /// </summary> /// <param name="level"></param> void _initializeTimedEventQ(Level level) { int i, spawnTimeout_ms; //start by emptying the queue; it should never be full in this context _timerQ.Clear(); //init five missiles as initial wave in the first few seconds, with no spawn timeout for (i = 0; i < 5; i++) { spawnTimeout_ms = RandomNumberGenerator.Instance.Rand() % 1500; EventPacket missileEvent = _eventFactory.MakeRandomSpawnMissileEventPacket(_gameModel.GetGameObjectList()); TimedEvent timedMissile = new TimedEvent(spawnTimeout_ms, missileEvent); _timerQ.Insert(timedMissile); } //make 20 missiles, injected at random intervals, with a min separation of some sort for (i = 0; i < level.NumMissiles; i++) { spawnTimeout_ms = RandomNumberGenerator.Instance.Rand() % GameParameters.LEVEL_DURATION_MS; EventPacket missileEvent = _eventFactory.MakeRandomSpawnMissileEventPacket(_gameModel.GetGameObjectList()); TimedEvent timedMissile = new TimedEvent(spawnTimeout_ms, missileEvent); _timerQ.Insert(timedMissile); } //the final wave of missiles at the end of the level for (i = 0; i < 5; i++) { spawnTimeout_ms = GameParameters.LEVEL_DURATION_MS + RandomNumberGenerator.Instance.Rand() % 1500; EventPacket missileEvent = _eventFactory.MakeRandomSpawnMissileEventPacket(_gameModel.GetGameObjectList()); TimedEvent timedMissile = new TimedEvent(spawnTimeout_ms, missileEvent); _timerQ.Insert(timedMissile); } //some mirvs at the end for (i = 0; i < level.NumMirvs; i++) { spawnTimeout_ms = GameParameters.LEVEL_DURATION_MS + 1500 + RandomNumberGenerator.Instance.Rand() % 1500; EventPacket mirvEvent = _eventFactory.MakeRandomSpawnMirvEventPacket(_gameModel.GetGameObjectList()); TimedEvent timedMirv = new TimedEvent(spawnTimeout_ms, mirvEvent); _timerQ.Insert(timedMirv); } //spawn the bombers for (i = 0; i < level.NumBombers; i++) { spawnTimeout_ms = RandomNumberGenerator.Instance.Rand() % GameParameters.LEVEL_DURATION_MS; EventPacket bomberSpawn = _eventFactory.MakeSpawnBomberEventPacket(new Position(0, GameParameters.BOMBER_ALTITUDE)); TimedEvent timedBomber = new TimedEvent(spawnTimeout_ms, bomberSpawn); _timerQ.Insert(timedBomber); } //spawn the deathheads for (i = 0; i < level.NumDeathheads; i++) { spawnTimeout_ms = RandomNumberGenerator.Instance.Rand() % GameParameters.LEVEL_DURATION_MS; EventPacket deathheadSpawn = _eventFactory.MakeSpawnBomberEventPacket(new Position(0, GameParameters.BOMBER_ALTITUDE)); TimedEvent timedDeathhead = new TimedEvent(spawnTimeout_ms, deathheadSpawn); _timerQ.Insert(timedDeathhead); } }
/// <summary> /// Constructor for event with a start and end time. /// </summary> /// <param name="StartTime"></param> /// <param name="EndTime"></param> public OneTimeSchedule(DateTime StartTime, DateTime EndTime) { _Event = new TimedEvent(StartTime, EndTime); _Notation = NotationKind.To; }
public static void LoadFromFile() { Groups.Clear(); Rooms.Clear(); Events.Clear(); FloorHeats.Clear(); TowelRads.Clear(); RoomSensors.Clear(); FloorSensors.Clear(); EventGroup group; Room room; Heater heater; Sensor sensor; TimedEvent timedEvent; XmlTextReader reader = new XmlTextReader("initdata.xml"); while ((reader.Read())) { switch (reader.NodeType) { case XmlNodeType.Element: //Display beginning of element. switch (reader.Name) { case "group": group = new EventGroup(Convert.ToInt32(reader.GetAttribute("id")), reader.GetAttribute("name")); Groups.Add(group); break; case "room": room = new Room(Convert.ToInt32(reader.GetAttribute("id")), reader.GetAttribute("name"), Convert.ToInt32(reader.GetAttribute("group")), Convert.ToInt32(reader.GetAttribute("tempmin")), Convert.ToInt32(reader.GetAttribute("tempmax")), Convert.ToInt32(reader.GetAttribute("temptarget"))); Rooms.Add(room); break; case "floorheat": heater = new Heater(Convert.ToInt32(reader.GetAttribute("id")), Heater.HEATER_TYPE_FLOOR, reader.GetAttribute("name"), Convert.ToInt32(reader.GetAttribute("group")), Convert.ToInt32(reader.GetAttribute("room")), reader.GetAttribute("relay"), Convert.ToInt32(reader.GetAttribute("tempmax"))); FloorHeats.Add(heater); break; case "towelrad": heater = new Heater(Convert.ToInt32(reader.GetAttribute("id")), Heater.HEATER_TYPE_TOWEL, reader.GetAttribute("name"), Convert.ToInt32(reader.GetAttribute("group")), Convert.ToInt32(reader.GetAttribute("room")), reader.GetAttribute("relay"), Convert.ToInt32(reader.GetAttribute("tempmax"))); TowelRads.Add(heater); break; case "timergroup": break; case "roomsensor": sensor = new Sensor(Convert.ToInt32(reader.GetAttribute("id")), Sensor.SENSOR_TYPE_ROOM, reader.GetAttribute("name"), Convert.ToInt32(reader.GetAttribute("room")), reader.GetAttribute("owid"), "x"); RoomSensors.Add(sensor); break; case "floorsensor": sensor = new Sensor(Convert.ToInt32(reader.GetAttribute("id")), Sensor.SENSOR_TYPE_FLOOR, reader.GetAttribute("name"), Convert.ToInt32(reader.GetAttribute("room")), reader.GetAttribute("owid"), "x"); FloorSensors.Add(sensor); break; case "event": timedEvent = new TimedEvent(Convert.ToInt32(reader.GetAttribute("id")), 1, Convert.ToInt32(reader.GetAttribute("subject")), reader.GetAttribute("timestart"), reader.GetAttribute("timeend"), reader.GetAttribute("comment")); if (timedEvent.Id > highestEventId) highestEventId = timedEvent.Id; Events.Add(timedEvent); break; } break; } } // Add heaters to rooms for (int i = 0; i < FloorHeats.Count; i++) { for (int j = 0; j < Rooms.Count; j++) { if (Rooms[j].Id == FloorHeats[i].RoomId) { Rooms[j].Heaters.Add(FloorHeats[i]); break; } } } for (int i = 0; i < TowelRads.Count; i++) { for (int j = 0; j < Rooms.Count; j++) { if (Rooms[j].Id == TowelRads[i].RoomId) { Rooms[j].Heaters.Add(TowelRads[i]); break; } } } // Add sensors to rooms and heaters for (int i = 0; i < RoomSensors.Count; i++) { for (int j = 0; j < Rooms.Count; j++) { if (Rooms[j].Id == RoomSensors[i].RoomId) { Rooms[j].Sensors.Add(RoomSensors[i]); for (int k = 0; k < Rooms[j].Heaters.Count; k++) { Rooms[j].Heaters[k].Sensors.Add(RoomSensors[i]); } break; } } } for (int i = 0; i < FloorSensors.Count; i++) { for (int j = 0; j < Rooms.Count; j++) { if (Rooms[j].Id == FloorSensors[i].RoomId) { Rooms[j].Sensors.Add(FloorSensors[i]); for (int k = 0; k < Rooms[j].Heaters.Count; k++) { Rooms[j].Heaters[k].Sensors.Add(FloorSensors[i]); } break; } } } reader.Close(); }
public LLUDPServer(LLUDP udp, IScene scene, IPAddress bindAddress, int port, IConfigSource configSource, IScheduler scheduler) : base(bindAddress, port) { m_udp = udp; Scene = scene; Scheduler = scheduler; IConfig throttleConfig = configSource.Configs["LLUDP"]; m_throttleRates = new ThrottleRates(LLUDPServer.MTU, throttleConfig); m_resendTimer = new TimedEvent(100); m_ackTimer = new TimedEvent(500); m_pingTimer = new TimedEvent(5000); m_httpServer = Scene.Simian.GetAppModule<IHttpServer>(); IConfig config = configSource.Configs["LLUDP"]; if (config != null) { m_asyncPacketHandling = config.GetBoolean("AsyncPacketHandling", true); m_recvBufferSize = config.GetInt("SocketReceiveBufferSize", 0); } m_throttle = new TokenBucket(null, m_throttleRates.SceneTotalLimit, m_throttleRates.SceneTotal); PacketEvents = new PacketEventDictionary(Scheduler); Scene.OnPresenceRemove += PresenceRemoveHandler; }
public void SetTimer(TimedFunction function, float delay) { TimedEvent e = new TimedEvent(); e.function = function; e.delay = delay; e.addedTime = Time.time; timerList.Add(e); }
public TimedEventUnitTest(string Name, TimedEvent Event, Func<TimedEvent, IEnumerable<TimedEvent>> TimedEventFunc, IEnumerable<TimedEvent> ExpectedEvents) { this.Name = Name; this.Event = Event; this.TimedEventFunc = TimedEventFunc; this.ExpectedEvents = ExpectedEvents; }
public TimedEventDateUnitTest(string Name, TimedEvent Event, Func<TimedEvent, IEnumerable<DateTime>> TimedEventFunc, IEnumerable<DateTime> ExpectedDates) { this.Name = Name; this.Event = Event; this.TimedEventFunc = TimedEventFunc; this.ExpectedDates = ExpectedDates; }
public IEnumerable<TimedEvent> GetRange(DateTime RangeStart, DateTime RangeEnd) { // Determine start of iteration by stepping back _Duration time, then adding 1 minute (smallest increment in cron) TimeSpan OneMinute = new TimeSpan(0, 1, 0); TimeSpan StepBackTime = _Duration >= OneMinute ? _Duration.Subtract(OneMinute) : TimeSpan.Zero; DateTime IterateStart = RangeStart.Ticks >= StepBackTime.Ticks ? RangeStart.Subtract(StepBackTime) : DateTime.MinValue; // Strip seconds, ms, and ticks IterateStart.AddTicks(-(IterateStart.Ticks % TimeSpan.TicksPerMinute)); // Start iteration with restricted ranges int? MonthStart = IterateStart.Month; int? DayStart = IterateStart.Day; int? HourStart = IterateStart.Hour; int? MinuteStart = IterateStart.Minute; for (int Year = IterateStart.Year; Year <= RangeEnd.Year; Year++) { var Months = _MonthLookup.PickList .Where(x => MonthStart.HasValue ? x >= MonthStart.Value : true); foreach (int Month in Months) { var DOWCounter = new int[] { 0, 0, 0, 0, 0, 0, 0 }; var MonthDays = Calendar.GetMonthDays(Year, Month); var Days = _DayLookup.PickList .Select(x => x < 0 ? MonthDays + x + 1 : x) .Where(x => (DayStart.HasValue ? x >= DayStart.Value : true) && x <= MonthDays); if (MonthStart.HasValue && Month != MonthStart.Value) MonthStart = DayStart = HourStart = MinuteStart = null; foreach (int DayIndex in Days) { // Resolve negative Day as index from last day of the month. int Day = DayIndex < 0 ? MonthDays + DayIndex + 1 : DayIndex; if (DayStart.HasValue && Day != DayStart.Value) DayStart = HourStart = MinuteStart = null; // Compute day of week. int DOW = (int)new DateTime(Year, Month, Day).DayOfWeek; // Skip this day if DOW doesn't match if (!_DayOfWeekLookup[DOW]) continue; DOWCounter[DOW]++; if (_DayOfWeekLookup.OccurranceIndex.HasValue) { // Check DOW occurance index. // Handle special case for last occurance (negative range). int occuranceIndex = _DayOfWeekLookup.OccurranceIndex < 0 ? // Compute last occurrance index. ComputeLastDOWOccurance(Year, Month, DOW) + _DayOfWeekLookup.OccurranceIndex.Value + 1 : _DayOfWeekLookup.OccurranceIndex.Value - 1; if (occuranceIndex != DOWCounter[DOW] - 1) continue; } var Hours = _HourLookup.PickList .Where(x => HourStart.HasValue ? x >= HourStart.Value : true); foreach (int Hour in Hours) { if (HourStart.HasValue && Hour != HourStart.Value) HourStart = MinuteStart = null; var Minutes = _MinuteLookup.PickList .Where(x => MinuteStart.HasValue ? x >= MinuteStart.Value : true); foreach (int Minute in Minutes) { DateTime Next = new DateTime(Year, Month, Day, Hour, Minute, 0); if (Next >= RangeEnd) yield break; TimedEvent ReturnEvent = new TimedEvent(Next, _Duration); yield return ReturnEvent; } MinuteStart = null; } HourStart = MinuteStart = null; } DayStart = HourStart = MinuteStart = null; } MonthStart = DayStart = HourStart = MinuteStart = null; } yield break; }
public int AddEvent(TimedEvent TE) { TE.ID = IDGenerator; int temp = IDGenerator; SyncList.Add(IDGenerator++, TE); return temp; }
public IDisposable CreateTimedEvent(Categories category, string variable, string description, int? value) { if (!ReportingAnalytics) return Disposable; var e = new TimedEvent() { Category = category.ToString(), VariableName = variable, Description = description, Value = value }; //Timed event does not need startup tracking. return e; }
public void TrackTimedEvent(Categories category, string variable, TimeSpan time, string description = "") { if (!ReportingAnalytics) return; var e = new TimedEvent(time) { Category = category.ToString(), VariableName = variable, Description = description }; e.Track(); }