public FurnaceWindow(IEventScheduler scheduler, Coordinates3D coordinates,
IItemRepository itemRepository, InventoryWindow inventory)
{
ItemRepository = itemRepository;
EventScheduler = scheduler;
Coordinates = coordinates;
WindowAreas = new[]
{
new WindowArea(IngredientIndex, 1, 1, 1),
new WindowArea(FuelIndex, 1, 1, 1),
new WindowArea(OutputIndex, 1, 1, 1),
new WindowArea(MainIndex, 27, 9, 3),
new WindowArea(HotbarIndex, 9, 9, 1)
};
inventory.MainInventory.CopyTo(MainInventory);
inventory.Hotbar.CopyTo(Hotbar);
foreach (var area in WindowAreas)
area.WindowChange += (s, e) => OnWindowChange(new WindowChangeEventArgs(
(s as WindowArea).StartIndex + e.SlotIndex, e.Value));
Copying = false;
inventory.WindowChange += (sender, e) =>
{
if (Copying) return;
if ((e.SlotIndex >= InventoryWindow.MainIndex && e.SlotIndex < InventoryWindow.MainIndex + inventory.MainInventory.Length)
|| (e.SlotIndex >= InventoryWindow.HotbarIndex && e.SlotIndex < InventoryWindow.HotbarIndex + inventory.Hotbar.Length))
{
inventory.MainInventory.CopyTo(MainInventory);
inventory.Hotbar.CopyTo(Hotbar);
}
};
}
public EventCommands(ICalendarService calendarService, IEventService eventService, IPermissionService permissionService, IEventScheduler eventScheduler)
{
_calendarService = calendarService;
_eventService = eventService;
_permissionService = permissionService;
_eventScheduler = eventScheduler;
}
/// <summary>
/// Trigger this action.
/// This method is usually invoked by an IEventScheduler and shouldn't be called manually.
/// </summary>
/// <param name="scheduler">The scheduler which triggered the event</param>
public virtual void Trigger(IEventScheduler scheduler)
{
var args = new SchedulerEventArgs(scheduler);
EventTriggered?.Invoke(this, args);
_action?.Invoke();
}
public SettingsCommands(ICalendarService calendarService, IEventService eventService, IPermissionService permissionService, IEventScheduler eventScheduler, IConfigurationRoot configuration, IMemoryCache cache)
{
_calendarService = calendarService;
_eventService = eventService;
_permissionService = permissionService;
_eventScheduler = eventScheduler;
_configuration = configuration;
_cache = cache;
}
public BatchEventAggregator(int minimumBatchSeparationInMilliseconds,
IEventSchedulerFactory schedulerFactory, ITimer timer)
{
_minimumBatchSeparationInMilliseconds = minimumBatchSeparationInMilliseconds;
_scheduler = schedulerFactory.Create(HandleBatchCheck);
_currentBatchAndTimerLocker = new object();
_currentBatch = new TBatch();
_timer = timer;
}
public KioskDevice(KioskDeviceConfig deviceConfig, IDeviceClient client, IEventScheduler eventScheduler) : base(deviceConfig, client, eventScheduler)
{
this.deviceConfig = deviceConfig;
this.TicketStockCount = deviceConfig.InitialStockCount;
// set up any simulated events for this device
this._EventScheduler.Add(new TimedSimulatedEvent(5000, 2500, this.SendPurchaseTicketMessageToCloud));
// register any direct methods we're to recieve
this._DeviceClient.RegisterDirectMethodAsync(ReceivePurchaseTicketResponse).Wait();
}
public MainWindow(IEventScheduler eventScheduler)
{
this.eventScheduler = eventScheduler;
InitializeComponent();
timer.Interval = TimeSpan.FromSeconds(0.5);
timer.Start();
timer.Tick += TimerOnTick;
eventScheduler.EventScheduled += OnEventScheduled;
eventScheduler.EventFinished += OnEventFinished;
}
public override void Trigger(IEventScheduler scheduler)
{
base.Trigger(scheduler);
DateTime nextMonth = DateTime.Today.AddMonths(1);
int dayInMonth = DateTime.DaysInMonth(nextMonth.Year, nextMonth.Month);
int nextDay = dayInMonth < _dayOfMonth ? dayInMonth : _dayOfMonth;
ScheduledTime = new DateTime(nextMonth.Year, nextMonth.Month, nextDay,
ScheduledTime.Hour, ScheduledTime.Minute, ScheduledTime.Second);
scheduler.Schedule(this);
}
public BaseDevice(IDeviceConfig deviceConfig, IDeviceClient client, IEventScheduler eventScheduler)
{
if (deviceConfig == null || client == null || eventScheduler == null)
{
throw new ArgumentNullException("one or more parameters are null. All parameters must be provided");
}
this._EventScheduler = eventScheduler;
this._DeviceClient = client; // Connect to the IoT hub using the MQTT protocol
this._deviceConfig = deviceConfig; // save for later
this.deviceId = deviceConfig.DeviceId;
this.deviceType = deviceConfig.DeviceType;
// device status is set during initialization
}
private SignalsHub(SignalsConfig config)
{
_counters = new Counters();
var ioc = create_dependencies(config);
_log = ioc.Resolve<ILogFile>();
_repo = ioc.Resolve<IHubRepo>();
_configRa = ioc.Resolve<ISignalsConfigRa>();
_messenger = ioc.Resolve<IMessengerEngine>();
_agents = ioc.Resolve<IAgentsEngine>();
_idler = ioc.Resolve<IIdler>();
_scheduler = ioc.Resolve<IEventScheduler>();
var target = wcf.SignalsHub.New(this);
_host = WcfHost<comm.ISignalsHub>.NewAsync(_log, target);
_serviceName = GetType().AsServiceName();
}
private void TryInitializeFurnace(FurnaceState state, IEventScheduler scheduler, IWorld world,
Coordinates3D coords, IItemRepository itemRepository)
{
if (TrackedFurnaces.ContainsKey(coords))
{
return;
}
var inputStack = state.Items[FurnaceWindow.IngredientIndex];
var fuelStack = state.Items[FurnaceWindow.FuelIndex];
var outputStack = state.Items[FurnaceWindow.OutputIndex];
var input = itemRepository.GetItemProvider(inputStack.ID) as ISmeltableItem;
var fuel = itemRepository.GetItemProvider(fuelStack.ID) as IBurnableItem;
if (state.BurnTimeRemaining > 0)
{
if (state.CookTime == -1 && input != null && (outputStack.Empty || outputStack.CanMerge(input.SmeltingOutput)))
{
state.CookTime = 0;
SetState(world, coords, state);
}
var subject = new FurnaceEventSubject();
TrackedFurnaces[coords] = subject;
scheduler.ScheduleEvent("smelting", subject, TimeSpan.FromSeconds(1),
server => UpdateFurnace(server.Scheduler, world, coords, itemRepository));
return;
}
if (fuel != null && input != null) // We can maybe start
{
if (outputStack.Empty || outputStack.CanMerge(input.SmeltingOutput))
{
// We can definitely start
state.BurnTimeRemaining = state.BurnTimeTotal = (short)(fuel.BurnTime.TotalSeconds * 20);
state.CookTime = 0;
state.Items[FurnaceWindow.FuelIndex].Count--;
SetState(world, coords, state);
world.SetBlockID(coords, LitFurnaceBlock.BlockID);
var subject = new FurnaceEventSubject();
TrackedFurnaces[coords] = subject;
scheduler.ScheduleEvent("smelting", subject, TimeSpan.FromSeconds(1),
server => UpdateFurnace(server.Scheduler, world, coords, itemRepository));
}
}
}
public FortunaAccumulator(IEventScheduler eventScheduler, IEnumerable <IEntropyProvider> entropyProviders)
{
if (eventScheduler == null)
{
throw new ArgumentNullException(nameof(eventScheduler));
}
if (entropyProviders == null)
{
throw new ArgumentNullException(nameof(entropyProviders));
}
_eventScheduler = eventScheduler;
_entropyProviders = new ReadOnlyCollection <IEntropyProvider>(entropyProviders.ToList());
InitializePools();
RegisterEntropySources(_entropyProviders);
_eventScheduler.EntropyAvailable += AccumulateEntropy;
}
public FurnaceWindow(IEventScheduler scheduler, Coordinates3D coordinates,
IItemRepository itemRepository, InventoryWindow inventory)
{
ItemRepository = itemRepository;
EventScheduler = scheduler;
Coordinates = coordinates;
WindowAreas = new[]
{
new WindowArea(IngredientIndex, 1, 1, 1),
new WindowArea(FuelIndex, 1, 1, 1),
new WindowArea(OutputIndex, 1, 1, 1),
new WindowArea(MainIndex, 27, 9, 3),
new WindowArea(HotbarIndex, 9, 9, 1)
};
inventory.MainInventory.CopyTo(MainInventory);
inventory.Hotbar.CopyTo(Hotbar);
foreach (var area in WindowAreas)
{
area.WindowChange += (s, e) => OnWindowChange(new WindowChangeEventArgs(
(s as WindowArea).StartIndex + e.SlotIndex, e.Value));
}
Copying = false;
inventory.WindowChange += (sender, e) =>
{
if (Copying)
{
return;
}
if ((e.SlotIndex >= InventoryWindow.MainIndex && e.SlotIndex < InventoryWindow.MainIndex + inventory.MainInventory.Length) ||
(e.SlotIndex >= InventoryWindow.HotbarIndex && e.SlotIndex < InventoryWindow.HotbarIndex + inventory.Hotbar.Length))
{
inventory.MainInventory.CopyTo(MainInventory);
inventory.Hotbar.CopyTo(Hotbar);
}
};
}
private void UpdateFurnace(IEventScheduler scheduler, IWorld world, Coordinates3D coords, IItemRepository itemRepository)
{
if (TrackedFurnaces.ContainsKey(coords))
{
TrackedFurnaces.Remove(coords);
}
if (world.GetBlockID(coords) != FurnaceBlock.BlockID && world.GetBlockID(coords) != LitFurnaceBlock.BlockID)
{
/*if (window != null && !window.IsDisposed)
* window.Dispose();*/
return;
}
var state = GetState(world, coords);
var inputStack = state.Items[FurnaceWindow.IngredientIndex];
var outputStack = state.Items[FurnaceWindow.OutputIndex];
var input = itemRepository.GetItemProvider(inputStack.ID) as ISmeltableItem;
// Update burn time
var burnTime = state.BurnTimeRemaining;
if (state.BurnTimeRemaining > 0)
{
state.BurnTimeRemaining -= 20; // ticks
if (state.BurnTimeRemaining <= 0)
{
state.BurnTimeRemaining = 0;
state.BurnTimeTotal = 0;
world.SetBlockID(coords, FurnaceBlock.BlockID);
}
}
// Update cook time
if (state.CookTime < 200 && state.CookTime >= 0)
{
state.CookTime += 20; // ticks
if (state.CookTime >= 200)
{
state.CookTime = 200;
}
}
// Are we done cooking?
if (state.CookTime == 200 && burnTime > 0)
{
state.CookTime = -1;
if (input != null && (outputStack.Empty || outputStack.CanMerge(input.SmeltingOutput)))
{
if (outputStack.Empty)
{
outputStack = input.SmeltingOutput;
}
else if (outputStack.CanMerge(input.SmeltingOutput))
{
outputStack.Count += input.SmeltingOutput.Count;
}
state.Items[FurnaceWindow.OutputIndex] = outputStack;
state.Items[FurnaceWindow.IngredientIndex].Count--;
}
}
SetState(world, coords, state);
TryInitializeFurnace(state, scheduler, world, coords, itemRepository);
}
private void UpdateFurnace(IEventScheduler scheduler, IWorld world, Coordinates3D coords, IItemRepository itemRepository)
{
if (TrackedFurnaces.ContainsKey(coords))
TrackedFurnaces.Remove(coords);
if (world.GetBlockID(coords) != FurnaceBlock.BlockID && world.GetBlockID(coords) != LitFurnaceBlock.BlockID)
{
/*if (window != null && !window.IsDisposed)
window.Dispose();*/
return;
}
var state = GetState(world, coords);
var inputStack = state.Items[FurnaceWindow.IngredientIndex];
var outputStack = state.Items[FurnaceWindow.OutputIndex];
var input = itemRepository.GetItemProvider(inputStack.ID) as ISmeltableItem;
// Update burn time
var burnTime = state.BurnTimeRemaining;
if (state.BurnTimeRemaining > 0)
{
state.BurnTimeRemaining -= 20; // ticks
if (state.BurnTimeRemaining <= 0)
{
state.BurnTimeRemaining = 0;
state.BurnTimeTotal = 0;
world.SetBlockID(coords, FurnaceBlock.BlockID);
}
}
// Update cook time
if (state.CookTime < 200 && state.CookTime >= 0)
{
state.CookTime += 20; // ticks
if (state.CookTime >= 200)
state.CookTime = 200;
}
// Are we done cooking?
if (state.CookTime == 200 && burnTime > 0)
{
state.CookTime = -1;
if (input != null && (outputStack.Empty || outputStack.CanMerge(input.SmeltingOutput)))
{
if (outputStack.Empty)
outputStack = input.SmeltingOutput;
else if (outputStack.CanMerge(input.SmeltingOutput))
outputStack.Count += input.SmeltingOutput.Count;
state.Items[FurnaceWindow.OutputIndex] = outputStack;
state.Items[FurnaceWindow.IngredientIndex].Count--;
}
}
SetState(world, coords, state);
TryInitializeFurnace(state, scheduler, world, coords, itemRepository);
}
private void TryInitializeFurnace(FurnaceState state, IEventScheduler scheduler, IWorld world,
Coordinates3D coords, IItemRepository itemRepository)
{
if (TrackedFurnaces.ContainsKey(coords))
return;
var inputStack = state.Items[FurnaceWindow.IngredientIndex];
var fuelStack = state.Items[FurnaceWindow.FuelIndex];
var outputStack = state.Items[FurnaceWindow.OutputIndex];
var input = itemRepository.GetItemProvider(inputStack.ID) as ISmeltableItem;
var fuel = itemRepository.GetItemProvider(fuelStack.ID) as IBurnableItem;
if (state.BurnTimeRemaining > 0)
{
if (state.CookTime == -1 && input != null && (outputStack.Empty || outputStack.CanMerge(input.SmeltingOutput)))
{
state.CookTime = 0;
SetState(world, coords, state);
}
var subject = new FurnaceEventSubject();
TrackedFurnaces[coords] = subject;
scheduler.ScheduleEvent("smelting", subject, TimeSpan.FromSeconds(1),
server => UpdateFurnace(server.Scheduler, world, coords, itemRepository));
return;
}
if (fuel != null && input != null) // We can maybe start
{
if (outputStack.Empty || outputStack.CanMerge(input.SmeltingOutput))
{
// We can definitely start
state.BurnTimeRemaining = state.BurnTimeTotal = (short)(fuel.BurnTime.TotalSeconds * 20);
state.CookTime = 0;
state.Items[FurnaceWindow.FuelIndex].Count--;
SetState(world, coords, state);
world.SetBlockID(coords, LitFurnaceBlock.BlockID);
var subject = new FurnaceEventSubject();
TrackedFurnaces[coords] = subject;
scheduler.ScheduleEvent("smelting", subject, TimeSpan.FromSeconds(1),
server => UpdateFurnace(server.Scheduler, world, coords, itemRepository));
}
}
}
public override void Trigger(IEventScheduler scheduler)
{
base.Trigger(scheduler);
ScheduledTime = GetNextScheduleDate(null);
scheduler.Schedule(this);
}
public static IEventSlot New(IEventScheduler scheduler)
{
return
new EventSlot(scheduler);
}
private EventSlot(IEventScheduler scheduler)
{
_scheduler = scheduler;
}
public DeleteCommands(IEventService eventService, IPermissionService permissionService, IEventScheduler eventScheduler)
{
_eventService = eventService;
_permissionService = permissionService;
_eventScheduler = eventScheduler;
}
/// <summary>
/// Device class constructor, calls base constructor and starts loading device values.
/// Accepts a device config, client, and event scheduler. The later 2 are externalized to make
/// unit testing of the device easier.
/// </summary>
public GateReaderDevice(GateReaderDeviceConfig deviceConfig, IDeviceClient client, IEventScheduler eventScheduler)
: base(deviceConfig, client, eventScheduler)
{
// save device configuration
this.deviceConfig = deviceConfig;
}
/// <summary>
/// Create a new instance of SchedulerEventArgs
/// </summary>
/// <param name="eventScheduler">A reference to the EventScheduler which triggered the event</param>
public SchedulerEventArgs(IEventScheduler eventScheduler)
{
EventScheduler = eventScheduler;
}
public override void Trigger(IEventScheduler scheduler)
{
base.Trigger(scheduler);
ScheduledTime = DateTime.Now + _timePeriod;
scheduler.Schedule(this);
}
public override void Trigger(IEventScheduler scheduler)
{
base.Trigger(scheduler);
ScheduledTime = GetNextScheduleDate(DateTime.Today.AddDays(1));
scheduler.Schedule(this);
}
public override void Trigger(IEventScheduler scheduler)
{
base.Trigger(scheduler);
ScheduledTime = ScheduledTime.AddYears(1);
scheduler.Schedule(this);
}
