public GameEntity CreateGridObject(string objectId)
{
var entity = Contexts.sharedInstance.game.CreateEntity();
var objectData = database.Get <GridObjectData>(objectId);
var prefabPath = database.Get <string>(objectData.prefab);
entity.AddGameObject(objectData.objectId, objectData.typeId, Utils.GenerateUniqueId(database));
entity.AddResource(prefabPath);
var defaultFootprint = new List <List <int> >()
{
new List <int>()
{
1
}
};
entity.AddGrid(null, new List <GameEntity>(), new Footprint(objectData.footprintData == null ? defaultFootprint : objectData.footprintData), objectData.canSwap);
var view = FactoryPool.GetPooled(prefabPath);
var viewMono = view.GetComponent <ViewMonoComponent>();
entity.AddView(view, viewMono != null ? viewMono.HUDpivot : view.transform);
#if UNITY_EDITOR
entity.viewObject.name = string.Format("ent_{0}_{1}_{2}", entity.objectId, entity.typeId, entity.uniqueId);
#endif
EventDispatcherService <GameEntity> .Dispatch(Constants.EVENT_GRID_ENTITY_CREATION, entity);
return(entity);
}
static async Task Main(string[] args)
{
var eventDispatcher = new EventDispatcherService();
//eventDispatcher.RegisterHandler<TemperatureChangedEvent>(LogEvent);
eventDispatcher.RegisterHandler <OvenHeatedEvent>(LogEvent);
eventDispatcher.RegisterHandler <MotorActivatedEvent>(LogEvent);
eventDispatcher.RegisterHandler <ConveyorPositionReachedEvent>(LogEvent);
eventDispatcher.RegisterHandler <BiscuitExtractedEvent>(LogEvent);
eventDispatcher.RegisterHandler <BiscuitStampedEvent>(LogEvent);
eventDispatcher.RegisterHandler <BiscuitBakedEvent>(LogEvent);
eventDispatcher.RegisterHandler <BiscuitCollectedEvent>(LogEvent);
eventDispatcher.RegisterHandler <ProductionFinishedEvent>(LogEvent);
var biscuitMachineOptions = new OptionsWrapper <BiscuitMachineOptions>(new BiscuitMachineOptions()
{
MinOvenTemperature = 20,
MaxOvenTemperature = 40,
MotorPulsesToReachPosition = 10,
BiscuitBakeTimeInSeconds = 3
});
BiscuitMachine machine = new BiscuitMachine(biscuitMachineOptions, eventDispatcher);
await machine.TurnOn();
await Task.Delay(10000);
await machine.TurnOff();
Console.ReadLine();
}
public async Task ShouldFinishProductionWhenTurnedOff()
{
//Arrange
var collectedBiscuitsBeforeProductionFinished = 0;
var collectedBiscuits = 0;
var eventDispatcher = new EventDispatcherService();
eventDispatcher.RegisterHandler <BiscuitCollectedEvent>(async e =>
{
collectedBiscuits++;
await Task.Delay(0);
});
BiscuitMachine machine = CreateBiscuitMachine(eventDispatcher, 5, 15, 2, 2);
//Act
await machine.TurnOn();
var extractedBiscuits = await ExtractBiscuits(eventDispatcher, 5);
await machine.TurnOff();
collectedBiscuitsBeforeProductionFinished = collectedBiscuits;
await FinishProduction(eventDispatcher);
//Assert
Assert.True(collectedBiscuitsBeforeProductionFinished < extractedBiscuits);
Assert.Equal(extractedBiscuits, collectedBiscuits);
}
public bool HandleTouchUp(Vector3 screenPos)
{
if (!isTapOnUI)
{
var touched = Utils.GetInputTargetOnGrid(screenPos, sceneSystem, cameraService.activeCamera, gridService);
if (touched != null && (!touched.hasGrid || (touched.hasGrid && touched.grid.cells.Count > 0)))
{
EventDispatcherService <GameEntity> .Dispatch(Constants.EVENT_ENTITY_TAP_UP, touched);
if (touched.hasGameObject)
{
TutorialService <TutorialStep> .Notify(string.Format("tap?{0}", touched.objectId));
}
if (touched.hasCommand && !string.IsNullOrEmpty(touched.command.onTapCommand))
{
var cell = touched.hasGrid ? touched.grid.pivot : null;
commandSystem.Execute(touched.command.onTapCommand, touched.position, cell, touched);
AnimateObjectTouch(touched);
}
}
}
isTapOnUI = false;
return(false);
}
private void CancelDraggedObject()
{
if (dragged != null && dragged.hasGameObject)
{
EventDispatcherService <GameEntity> .Dispatch(Constants.EVENT_ENTITY_CANCEL_DRAG, dragged);
Utils.SetSortingLayer(dragged, Constants.SORTING_LAYER_DEFAULT);
gridService.SetEntityOn(dragged, draggedInitCell);
dragged = null;
}
}
public void WhenCallbackIsSubscribedAndPerformCall_CallToTheCallback()
{
var eventDispatcher = new EventDispatcherService();
var callback1 = Substitute.For <SignalDelegate>();
eventDispatcher.Subscribe <TestSignal>(callback1);
var testSignal = new TestSignal("SomeData");
eventDispatcher.Dispatch(testSignal);
callback1.Received().Invoke(testSignal);
}
public async Task ShouldHeatOven()
{
//Arrange
const int minOvenTemperature = 5;
const int maxOvenTemperature = 15;
var isOvenHeated = false;
var ovenTemperatureBeforeHeatedLog = new List <int>();
var ovenTemperatureAfterHeatedLog = new List <int>();
var eventDispatcher = new EventDispatcherService();
eventDispatcher.RegisterHandler <TemperatureChangedEvent>(async e =>
{
var temperature = ((TemperatureChangedEvent)e).Temperature;
if (!isOvenHeated)
{
ovenTemperatureBeforeHeatedLog.Add(temperature);
}
else
{
ovenTemperatureAfterHeatedLog.Add(temperature);
}
await Task.Delay(0);
});
BiscuitMachine machine = CreateBiscuitMachine(eventDispatcher, minOvenTemperature, maxOvenTemperature, 2, 2);
//Act
await machine.TurnOn();
await HeatOven(eventDispatcher);
isOvenHeated = true;
await Task.Run(async() =>
{
while (true)
{
if (ovenTemperatureAfterHeatedLog.Count >= 5)
{
break;
}
await Task.Delay(200);
}
});
await machine.TurnOff();
//Assert
Assert.True(ovenTemperatureBeforeHeatedLog.TrueForAll(x => x > 0 && x <= minOvenTemperature));
Assert.Equal(minOvenTemperature, ovenTemperatureBeforeHeatedLog.Last());
Assert.True(ovenTemperatureAfterHeatedLog.TrueForAll(x => x > minOvenTemperature));
}
public ResourcesService(
IIdentityService identityService,
EventDispatcherService eventDispatcher,
ProviderManagerService providerManager,
IDataStore <Resource> resourceStore,
Func <Resource, ResourceViewModel> resourceViewModelDelegate)
{
_identityService = identityService;
_eventDispatcher = eventDispatcher;
_providerManager = providerManager;
_resources = resourceStore;
_resourceViewModel = resourceViewModelDelegate;
}
private void StartDragEntity()
{
// start and drag the touched entity
if (touched != null && touched.isDraggable && touched.hasGameObject)
{
dragged = touched;
touched = null;
Utils.SetSortingLayer(dragged, Constants.SORTING_LAYER_DRAG);
draggedInitCell = dragged.grid.pivot;
gridService.DeAttach(dragged);
dragged.CancelTween();
EventDispatcherService <GameEntity> .Dispatch(Constants.EVENT_ENTITY_START_DRAG, dragged);
}
}
public async Task DispatchShouldDispatchEvents()
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddTransient <IEventHandler <ArticleEvent>, ArticleEventHandler>();
var dispatcher = new EventDispatcherService(serviceCollection.BuildServiceProvider());
var domainEvent = new ArticleEvent();
await dispatcher.Dispatch(domainEvent);
Assert.True(domainEvent.Handled);
}
public ScheduleRekeyingTasksService(
IOptions <AuthJanitorCoreConfiguration> configuration,
EventDispatcherService eventDispatcherMetaService,
ProviderManagerService providerManager,
IDataStore <ManagedSecret> managedSecretStore,
IDataStore <Resource> resourceStore,
IDataStore <RekeyingTask> rekeyingTaskStore)
{
_configuration = configuration.Value;
_eventDispatcherMetaService = eventDispatcherMetaService;
_providerManager = providerManager;
_managedSecrets = managedSecretStore;
_resources = resourceStore;
_rekeyingTasks = rekeyingTaskStore;
}
public ProvidersService(
IIdentityService identityService,
ILogger <ProvidersService> logger,
EventDispatcherService eventDispatcher,
ProviderManagerService providerManager,
Func <AuthJanitorProviderConfiguration, ProviderConfigurationViewModel> configViewModelDelegate,
Func <LoadedProviderMetadata, LoadedProviderViewModel> providerViewModelDelegate)
{
_identityService = identityService;
_logger = logger;
_eventDispatcher = eventDispatcher;
_providerManager = providerManager;
_configViewModel = configViewModelDelegate;
_providerViewModel = providerViewModelDelegate;
}
public void WhenDifferentSignalsAreRegisteredAndPerformCallWithOne_OnlyCallToTheAssociateCallbacksOfThisSignal()
{
var eventDispatcher = new EventDispatcherService();
var callback1 = Substitute.For <SignalDelegate>();
var callback2 = Substitute.For <SignalDelegate>();
eventDispatcher.Subscribe <TestSignal>(callback1);
eventDispatcher.Subscribe <TestSignal2>(callback2);
var testSignal2 = new TestSignal2(123);
eventDispatcher.Dispatch(testSignal2);
callback1.DidNotReceive();
callback2.Received().Invoke(testSignal2);
}
private void HandleDraggedObject(Vector3 screenPos)
{
if (dragged != null && dragged.hasGameObject)
{
EventDispatcherService <GameEntity> .Dispatch(Constants.EVENT_ENTITY_END_DRAG, dragged);
Utils.SetSortingLayer(dragged, Constants.SORTING_LAYER_DEFAULT);
var pos = Utils.GetPlaneTouchPos(screenPos, cameraService.activeCamera);
var closestCell = gridService.GetClosestCell(pos, false);
gridService.SetEntityOn(dragged, closestCell);
if (dragged.hasCommand)
{
commandSystem.Execute(dragged.command.onDragEndCommand, closestCell, dragged);
}
dragged = null;
}
}
public void CleanupEntity(IContext context, IEntity entity)
{
var gameEntity = (GameEntity)entity;
if (gameEntity != null)
{
EventDispatcherService <GameEntity> .Dispatch(Constants.EVENT_ENTITY_DESTRUCTION, gameEntity);
// cleanup process for different components
if (gameEntity.hasView) // return view to the pool
{
gameEntity.localScale = Vector3.one;
gameEntity.viewObject.SetActive(false);
}
}
}
public async Task ShouldStopConveyorMovementWhenPaused()
{
//Arrange
var motorMovementsBeforePause = 0;
var motorMovementsAfterPause = 0;
var isPaused = false;
var eventDispatcher = new EventDispatcherService();
eventDispatcher.RegisterHandler <MotorActivatedEvent>(async e =>
{
if (!isPaused)
{
motorMovementsBeforePause++;
}
else
{
motorMovementsAfterPause++;
}
await Task.Delay(0);
});
BiscuitMachine machine = CreateBiscuitMachine(eventDispatcher, 5, 15, 2, 2);
//Act
await machine.TurnOn();
await HeatOven(eventDispatcher);
await Task.Delay(2000);
await machine.Pause();
isPaused = true;
await Task.Delay(2000);
await machine.TurnOff();
//Assert
Assert.True(isPaused);
Assert.True(motorMovementsBeforePause > 0);
Assert.Equal(0, motorMovementsAfterPause);
}
private void Start()
{
var mainMenuViewModel = new MainMenuViewModel();
var inGameViewModel = new InGameViewModel();
var loadingViewModel = new LoadingViewModel();
InstantiateViews(mainMenuViewModel, inGameViewModel, loadingViewModel);
// TODO: these services should be unique, instantiate it in a previous step
var gameRepository = new GameRepository();
var gameServerService = new GameServerService
(
new RestRestClientAdapter(new JsonUtilityAdapter()),
gameRepository
);
var eventDispatcherService = new EventDispatcherService();
var startGameUseCase =
new StartGameUseCase(gameServerService, gameRepository, new ConfigurationGameRepository(),
eventDispatcherService);
var startGameController = new StartGameController(mainMenuViewModel,
startGameUseCase
);
var keyboardController = new KeyboardController(inGameViewModel,
new GuessLetterUseCase(
new CheckSolutionUseCase(
gameServerService,
gameRepository,
eventDispatcherService
),
gameRepository,
gameServerService,
eventDispatcherService
)
);
var restartGameController =
new RestartGameController(inGameViewModel,
new RestartGameUseCase(startGameUseCase, eventDispatcherService));
var updateWordPresenter = new InGamePresenter(inGameViewModel, eventDispatcherService);
var mainMenuPresenter = new MainMenuPresenter(mainMenuViewModel, eventDispatcherService);
var loadingPresenter = new LoadingPresenter(loadingViewModel, eventDispatcherService);
}
public RekeyingTasksService(
IOptions <AuthJanitorCoreConfiguration> configuration,
IIdentityService identityService,
TaskExecutionMetaService taskExecutionMetaService,
EventDispatcherService eventDispatcher,
ProviderManagerService providerManager,
IDataStore <ManagedSecret> managedSecretStore,
IDataStore <RekeyingTask> rekeyingTaskStore,
Func <RekeyingTask, RekeyingTaskViewModel> rekeyingTaskViewModelDelegate)
{
_configuration = configuration.Value;
_identityService = identityService;
_taskExecutionMetaService = taskExecutionMetaService;
_eventDispatcher = eventDispatcher;
_providerManager = providerManager;
_managedSecrets = managedSecretStore;
_rekeyingTasks = rekeyingTaskStore;
_rekeyingTaskViewModel = rekeyingTaskViewModelDelegate;
}
public GameEntity CreateCell(int row, int column, string objectId, GameEntity occupant = null)
{
var entity = Contexts.sharedInstance.game.CreateEntity();
var objectData = database.Get <ObjectData>(objectId);
var prefabPath = database.Get <string>(objectData.prefab);
entity.AddGameObject(objectData.objectId, objectData.typeId, Utils.GenerateUniqueId(database));
entity.AddResource(prefabPath);
entity.AddCell(row, column, occupant);
var view = FactoryPool.GetPooled(prefabPath);
var viewMono = view.GetComponent <ViewMonoComponent>();
entity.AddView(view, viewMono != null ? viewMono.HUDpivot : view.transform);
#if UNITY_EDITOR
entity.viewObject.name = string.Format("cell_{0}_{1}_{2}_{3}_{4}", entity.objectId, entity.typeId, entity.row, entity.column, entity.uniqueId);
#endif
EventDispatcherService <GameEntity> .Dispatch(Constants.EVENT_CELL_ENTITY_CREATION, entity);
return(entity);
}
private void MoveToNextStep()
{
if (!hasComplete)
{
EventDispatcherService <T> .Dispatch(Constants.EVENT_TUT_STEP_COMPLETE, currentStep);
stepIndex++;
if (hasComplete)
{
TutorialService <T> .CompleteTutorial(id);
}
else
{
current = TutorialState.AwakeStep;
elapseTime = 0f;
Update();
}
}
}
public ManagedSecretsService(
IOptions <AuthJanitorCoreConfiguration> configuration,
IIdentityService identityService,
ICryptographicImplementation cryptographicImplementation,
EventDispatcherService eventDispatcher,
ProviderManagerService providerManager,
IDataStore <ManagedSecret> managedSecretStore,
IDataStore <Resource> resourceStore,
Func <ManagedSecret, ManagedSecretViewModel> managedSecretViewModelDelegate)
{
_configuration = configuration.Value;
_identityService = identityService;
_cryptographicImplementation = cryptographicImplementation;
_eventDispatcher = eventDispatcher;
_providerManager = providerManager;
_managedSecrets = managedSecretStore;
_resources = resourceStore;
_managedSecretViewModel = managedSecretViewModelDelegate;
}
public async Task ShouldMaintainOvenTemperature()
{
//Arrange
const int minOvenTemperature = 5;
const int maxOvenTemperature = 15;
var eventDispatcher = new EventDispatcherService();
BiscuitMachine machine = CreateBiscuitMachine(eventDispatcher, minOvenTemperature, maxOvenTemperature, 2, 2);
//Act
await machine.TurnOn();
await HeatOven(eventDispatcher);
var temperatureLog = await LogOvenTemperatureChanges(eventDispatcher, 20);
await machine.TurnOff();
//Assert
Assert.True(temperatureLog.TrueForAll(x => x >= minOvenTemperature && x <= maxOvenTemperature));
}
public void Init(T[] steps, GUIService guiService, DataBindingService databinding)
{
this.steps = steps;
this.guiService = guiService;
this.databinding = databinding;
stepIndex = 0;
LogWrapper.DebugLog("[{0}] {1} init with step count {2}", GetType(), id, steps.Length);
// setup the awake function
current = TutorialState.AwakeStep;
elapseTime = 0f;
panelView = guiService.GetPanelView(Constants.PANEL_VIEW_ID_TUTORIAL);
if (panelView == null)
{
throw new System.NullReferenceException("Could not find tutorial panel, please condif a panle in the gui config file with id: " + Constants.PANEL_VIEW_ID_TUTORIAL);
}
EventDispatcherService <ActiveTutorial <T> > .Dispatch(Constants.EVENT_TUT_INIT, this);
}
public async Task ShouldStartProductionAfterOvenHeated()
{
//Arrange
var isOvenHeated = false;
var extractedBiscuitsBeforeOvenHeated = 0;
var extractedBiscuitsAfterOvenHeated = 0;
var eventDispatcher = new EventDispatcherService();
eventDispatcher.RegisterHandler <BiscuitExtractedEvent>(async e =>
{
if (!isOvenHeated)
{
extractedBiscuitsBeforeOvenHeated++;
}
else
{
extractedBiscuitsAfterOvenHeated++;
}
await Task.Delay(0);
});
BiscuitMachine machine = CreateBiscuitMachine(eventDispatcher, 40, 60, 2, 2);
//Act
await machine.TurnOn();
await Task.Delay(2000);
await HeatOven(eventDispatcher);
isOvenHeated = true;
await Task.Delay(2000);
await machine.TurnOff();
//Assert
Assert.Equal(0, extractedBiscuitsBeforeOvenHeated);
Assert.True(extractedBiscuitsAfterOvenHeated > 0);
}
public OrderListSystem()
{
EventDispatcherService <GameEntity> .Subscribe(this, Constants.EVENT_ENTITY_START_DRAG);
EventDispatcherService <GameEntity> .Subscribe(this, Constants.EVENT_ENTITY_CANCEL_DRAG);
}
