//-------------------------------------------------
// UNITY FUNCTIONS
//-------------------------------------------------
void Awake()
{
PhotonNetwork.autoJoinLobby = false;
PhotonNetwork.automaticallySyncScene = true;
_contexts = Contexts.sharedInstance;
_systems = new Feature("Launcher Systems");
_serverSystems = new Feature("Server Systems");
_systems.Add(new ModifyPseudoSystem(_contexts, PseudoField));
_systems.Add(new ValidateButtonSystem(_contexts, ValidateButton));
_systems.Add(new ConnectionSystem(_contexts, this, Settings));
_systems.Add(new ConnectionUiSystem(_contexts, LoadingScreen));
_serverSystems.Add(new LoadingLobbySystem(_contexts, Settings));
}
static Systems CreateSystems(Pool pool)
{
Systems systems;
#if (UNITY_EDITOR)
systems = new DebugSystems();
#else
systems = new Systems();
#endif
systems
.Add(pool.CreateGameStartSystem())
.Add(pool.CreateGameOverSystem())
.Add(pool.CreateGameBoardCacheSystem())
.Add(pool.CreateCreateGameBoardSystem())
.Add(pool.CreateTurnSystem())
.Add(pool.CreateInputSystem())
.Add(pool.CreateAIMoveSystem())
.Add(pool.CreateExitSystem())
.Add(pool.CreateFoodSystem())
.Add(pool.CreateDestructibleSystem())
// Render
.Add(pool.CreateAnimationSystem())
.Add(pool.CreateDamageSpriteSystem())
.Add(pool.CreateRemoveViewSystem())
.Add(pool.CreateAddViewSystem())
.Add(pool.CreateRenderPositionSystem())
.Add(pool.CreateSmoothMoveSystem());
return systems;
}
public override Systems CreateUpdateSystems(IContexts contexts)
{
Contexts _contexts = (Contexts)contexts;
//SingletonManager.Get<MapConfigManager>().SetCurrentMap(_contexts.session.clientSessionObjects.MapId);
_gameModule = CreateCompositeGameModule(_contexts);
var systems = new Entitas.Systems();
systems.Add(new LocalizeSessionSystem(this, _contexts.session.commonSession.AssetManager));
systems.Add(new BaseConfigurationInitModule(this, _contexts.session.commonSession.AssetManager));
systems.Add(new ClientPreLoginFeature(
"BasePreparing",
_gameModule,
_contexts.session.commonSession
));
return(systems);
}
public override Systems CreateUpdateSystems(IContexts contexts)
{
Contexts _contexts = (Contexts)contexts;
var systems = new Entitas.Systems();
systems.Add(new RequestSceneInfoSystem(_contexts, this));
/*MakeWeaponLogicManager(_contexts);*/
return(systems);
}
public override Systems CreateUpdateSystems(IContexts contexts)
{
Contexts _contexts = (Contexts)contexts;
var systems = new Entitas.Systems();
systems.Add(new RequestSnapshotSystem(_contexts, this));
return(systems);
}
private void SetupSystems()
{
//a feature is a group of systems
_unpausableUpdateSystems = new Feature();
_unpausableUpdateSystems.Add(_pool.CreateSystem <VelocitySystem> ());
_unpausableUpdateSystems.Add(_pool.CreateSystem <AcceptInputSystem> ());
_unpausableUpdateSystems.Add(_pool.CreateSystem <DestroySystem> ());
_unpausableUpdateSystems.Initialize();
_unpausableUpdateSystems.ActivateReactiveSystems();
// I'm not sure this is useful, but I saw something similar in Entitas presentation slides - srivello
_pool.SetEntitas
(
null,
_unpausableUpdateSystems,
null
);
//Debug.Log("pausableUpdateSystems: " + Pools.pool.entitas.unpausableUpdateSystems);
}
public static void CollectSystems(string name, Systems feature)
{
var sysType = typeof(ISystem);
var ssType = typeof(Systems);
var types = AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(s => s.GetTypes())
.Where(p => p.IsClass &&
p.IsPublic &&
!p.IsAbstract &&
sysType.IsAssignableFrom(p) &&
!ssType.IsAssignableFrom(p));
var attribType = typeof(FeatureAttribute);
var c = new List <SystemProxy>();
foreach (var p in types)
{
var attribs = p.GetCustomAttributes(attribType, false)
.Where(attr => ((FeatureAttribute)attr).name == name);
string n = UnnamedFeature.NAME;
int w = 0;
foreach (var attr in attribs)
{
var attrib = (FeatureAttribute)attr;
n = attrib.name;
w = attrib.priority;
}
if (n != name)
{
continue;
}
var system = (ISystem)Activator.CreateInstance(p);
c.Add(new SystemProxy(system, w));
}
c.Sort();
int count = c.Count;
for (int i = 0; i < count; i++)
{
feature.Add(c[i].system);
}
}
public override Systems CreateUpdateSystems(IContexts contexts)
{
Contexts _contexts = (Contexts)contexts;
//SingletonManager.Get<MapConfigManager>().SetCurrentMap(_contexts.session.clientSessionObjects.MapId);
_gameModule = CreateCompositeGameModule(_contexts);
var systems = new Entitas.Systems();
systems.Add(new ClientPreLoginFeature(
"PreLoginState",
_gameModule,
_contexts.session.commonSession
));
return(systems);
}
public override Systems CreateUpdateSystems(IContexts contexts)
{
Contexts _contexts = (Contexts)contexts;
//SingletonManager.Get<MapConfigManager>().SetCurrentMap(_contexts.session.clientSessionObjects.MapId);
var gameModule = new SubResourceConfigurationInitModule(this);
var systems = new Entitas.Systems();
systems.Add(new ClientPreLoginFeature(
"SubResourceLoad",
gameModule,
_contexts.session.commonSession
));
return(systems);
}
private void SetupSystems()
{
//a feature is a group of systems
_pausableUpdateSystems = new Feature();
_pausableUpdateSystems.Add(_pool.CreateSystem <StartNextRoundSystem> ());
_pausableUpdateSystems.Add(_pool.CreateSystem <VelocitySystem> ());
_pausableUpdateSystems.Add(_pool.CreateSystem <AcceptInputSystem> ());
_pausableUpdateSystems.Add(_pool.CreateSystem <AISystem> ());
_pausableUpdateSystems.Add(_pool.CreateSystem <GoalSystem> ());
_pausableUpdateSystems.Add(_pool.CreateSystem <DestroySystem> ());
// 'Collision' as NOT physics based - as an example
_pausableUpdateSystems.Add(_pool.CreateSystem <BoundsBounceSystem> ());
_pausableUpdateSystems.Add(_pool.CreateSystem <BoundsConstrainSystem> ());
_pausableUpdateSystems.Initialize();
_pausableUpdateSystems.ActivateReactiveSystems();
_pausableFixedUpdateSystems = new Feature();
// 'Collision as Physics based - as an example.
_pausableFixedUpdateSystems.Add(_pool.CreateSystem <CollisionSystem> ());
_pausableFixedUpdateSystems.Initialize();
_pausableFixedUpdateSystems.ActivateReactiveSystems();
//for demo only, an example of an unpausable system
_unpausableUpdateSystems = new Feature();
_unpausableUpdateSystems.Add(_pool.CreateSystem <TimeSystem> ());
_unpausableUpdateSystems.Initialize();
_unpausableUpdateSystems.ActivateReactiveSystems();
// This is custom and optional. I use it to store the systems in case I need them again.
// This is the only place I put a component directly on a _pool. It is supported.
// I'm not sure this is useful, but I saw something similar in Entitas presentation slides - srivello
_pool.SetEntitas
(
_pausableUpdateSystems,
_unpausableUpdateSystems,
_pausableUpdateSystems
);
//Debug.Log("pausableUpdateSystems: " + Pools.pool.entitas.pausableUpdateSystems);
}
static Systems CreateSystems(Pool pool)
{
Systems systems;
#if (UNITY_EDITOR)
systems = new DebugSystems();
#else
systems = new Systems();
#endif
systems
.Add(pool.CreateSystem<CoroutineSystem>())
.Add(pool.CreateSystem<GameStartSystem>())
.Add(pool.CreateSystem<GameOverSystem>())
.Add(pool.CreateSystem<GameBoardCacheSystem>())
.Add(pool.CreateSystem<CreateGameBoardSystem>())
.Add(pool.CreateSystem<TurnSystem>())
.Add(pool.CreateSystem<InputSystem>())
.Add(pool.CreateSystem<AIMoveSystem>())
.Add(pool.CreateSystem<ExitSystem>())
.Add(pool.CreateSystem<FoodSystem>())
.Add(pool.CreateSystem<DestructibleSystem>())
// Render
.Add(pool.CreateSystem<AnimationSystem>())
.Add(pool.CreateSystem<DamageSpriteSystem>())
.Add(pool.CreateSystem<RemoveViewSystem>())
.Add(pool.CreateSystem<AddViewSystem>())
.Add(pool.CreateSystem<RenderPositionSystem>())
.Add(pool.CreateSystem<SmoothMoveSystem>());
return systems;
}
public GameController(Context ctx) : base(ctx)
{
_systems = new Entitas.Systems();
_indexsystem = new IndexSystem(Contexts.sharedInstance.game);
_mapsystem = new MapSystem(Contexts.sharedInstance.game);
_joinsystem = new JoinSystem(Contexts.sharedInstance.game);
_myplayersystem = new MyPlayerSystem(Contexts.sharedInstance.game);
_systems.Add(_indexsystem)
.Add(_mapsystem)
.Add(_joinsystem)
.Add(_myplayersystem);
// 4, protocol
_syncmsg1 = new byte[4];
NetPack.Packli(_syncmsg1, 0, 1);
EventListenerCmd listener2 = new EventListenerCmd(MyEventCmd.EVENT_SETUP_MAP, SetupMap);
_ctx.EventDispatcher.AddCmdEventListener(listener2);
//EventListenerCmd listener3 = new EventListenerCmd(MyEventCmd.EVENT_SETUP_VIEW, SetupCamera);
//_ctx.EventDispatcher.AddCmdEventListener(listener3);
}
void when_systems()
{
Pool pool = null;
before = () => {
pool = new Pool(10);
};
context["fixtures"] = () => {
it["initializes InitializeSystemSpy"] = () => {
var initializeSystem = new InitializeSystemSpy();
initializeSystem.initialized.should_be_false();
initializeSystem.Initialize();
initializeSystem.initialized.should_be_true();
};
it["executes ExecuteSystemSpy"] = () => {
var initializeSystem = new ExecuteSystemSpy();
initializeSystem.executed.should_be_false();
initializeSystem.Execute();
initializeSystem.executed.should_be_true();
};
it["initializes and executes InitializeExecuteSystemSpy"] = () => {
var initializeSystem = new InitializeExecuteSystemSpy();
initializeSystem.initialized.should_be_false();
initializeSystem.executed.should_be_false();
initializeSystem.Initialize();
initializeSystem.Execute();
initializeSystem.initialized.should_be_true();
initializeSystem.executed.should_be_true();
};
it["executes ReactiveSystemSpy"] = () => {
var system = createReactiveSystem(pool);
var spy = (ReactiveSubSystemSpy)system.subsystem;
spy.didExecute.should_be(0);
spy.initialized.should_be_false();
system.Execute();
spy.didExecute.should_be(1);
spy.initialized.should_be_false();
};
};
context["systems"] = () => {
Systems systems = null;
before = () => {
systems = new Systems();
};
it["returns systems when adding system"] = () => {
systems.Add(new InitializeSystemSpy()).should_be_same(systems);
};
it["initializes IInitializeSystem"] = () => {
var system = new InitializeSystemSpy();
systems.Add(system);
systems.Initialize();
system.initialized.should_be_true();
};
it["executes IExecuteSystem"] = () => {
var system = new ExecuteSystemSpy();
systems.Add(system);
systems.Execute();
system.executed.should_be_true();
};
it["initializes and executes IInitializeSystem, IExecuteSystem"] = () => {
var system = new InitializeExecuteSystemSpy();
systems.Add(system);
systems.Initialize();
systems.Execute();
system.initialized.should_be_true();
system.executed.should_be_true();
};
it["initializes and executes ReactiveSystem"] = () => {
var system = createReactiveSystem(pool);
systems.Add(system);
systems.Initialize();
systems.Execute();
systems.Execute();
var spy = (ReactiveSubSystemSpy)system.subsystem;
spy.didExecute.should_be(1);
spy.initialized.should_be_true();
};
it["clears reactive systems"] = () => {
var system = createReactiveSystem(pool);
systems.Add(system);
systems.Initialize();
systems.ClearReactiveSystems();
systems.Execute();
var spy = (ReactiveSubSystemSpy)system.subsystem;
spy.didExecute.should_be(0);
spy.initialized.should_be_true();
};
it["clears reactive systems recursively"] = () => {
var system = createReactiveSystem(pool);
systems.Add(system);
var parentSystems = new Systems();
parentSystems.Add(systems);
parentSystems.Initialize();
parentSystems.ClearReactiveSystems();
parentSystems.Execute();
var spy = (ReactiveSubSystemSpy)system.subsystem;
spy.didExecute.should_be(0);
spy.initialized.should_be_true();
};
it["deactivates reactive systems"] = () => {
var system = createReactiveSystem(pool);
systems.Add(system);
systems.Initialize();
systems.DeactivateReactiveSystems();
systems.Execute();
var spy = (ReactiveSubSystemSpy)system.subsystem;
spy.didExecute.should_be(0);
spy.initialized.should_be_true();
};
it["deactivates reactive systems recursively"] = () => {
var system = createReactiveSystem(pool);
systems.Add(system);
var parentSystems = new Systems();
parentSystems.Add(systems);
parentSystems.Initialize();
parentSystems.DeactivateReactiveSystems();
parentSystems.Execute();
var spy = (ReactiveSubSystemSpy)system.subsystem;
spy.didExecute.should_be(0);
spy.initialized.should_be_true();
};
it["activates reactive systems"] = () => {
var system = createReactiveSystem(pool);
systems.Add(system);
systems.Initialize();
systems.DeactivateReactiveSystems();
systems.ActivateReactiveSystems();
systems.Execute();
var spy = (ReactiveSubSystemSpy)system.subsystem;
spy.didExecute.should_be(0);
spy.initialized.should_be_true();
pool.CreateEntity().AddComponentA();
systems.Execute();
spy.didExecute.should_be(1);
};
it["activates reactive systems recursively"] = () => {
var system = createReactiveSystem(pool);
systems.Add(system);
var parentSystems = new Systems();
parentSystems.Add(systems);
parentSystems.Initialize();
parentSystems.DeactivateReactiveSystems();
parentSystems.ActivateReactiveSystems();
parentSystems.Execute();
var spy = (ReactiveSubSystemSpy)system.subsystem;
spy.didExecute.should_be(0);
spy.initialized.should_be_true();
pool.CreateEntity().AddComponentA();
systems.Execute();
spy.didExecute.should_be(1);
};
};
}
void when_systems()
{
Contexts contexts = null;
before = () => {
contexts = new Contexts { test = new Context(10) };
};
context["fixtures"] = () => {
it["initializes InitializeSystemSpy"] = () => {
var system = new InitializeSystemSpy();
system.didInitialize.should_be(0);
system.Initialize();
system.didInitialize.should_be(1);
};
it["executes ExecuteSystemSpy"] = () => {
var system = new ExecuteSystemSpy();
system.didExecute.should_be(0);
system.Execute();
system.didExecute.should_be(1);
};
it["cleans up CleanupSystemSpy"] = () => {
var system = new CleanupSystemSpy();
system.didCleanup.should_be(0);
system.Cleanup();
system.didCleanup.should_be(1);
};
it["tears down TearDownSystemSpy"] = () => {
var system = new TearDownSystemSpy();
system.didTearDown.should_be(0);
system.TearDown();
system.didTearDown.should_be(1);
};
it["initializes, executes, cleans up and tears down system"] = () => {
var system = new ReactiveSystemSpy(contexts.test.CreateCollector(Matcher.AllOf(CID.ComponentA)));
contexts.test.CreateEntity().AddComponentA();
system.didInitialize.should_be(0);
system.Initialize();
system.didInitialize.should_be(1);
system.didExecute.should_be(0);
system.Execute();
system.didExecute.should_be(1);
system.didCleanup.should_be(0);
system.Cleanup();
system.didCleanup.should_be(1);
system.didTearDown.should_be(0);
system.TearDown();
system.didTearDown.should_be(1);
};
it["executes ReactiveSystemSpy"] = () => {
var system = createReactiveSystem(contexts);
system.Execute();
system.entities.Length.should_be(1);
};
};
context["systems"] = () => {
Systems systems = null;
before = () => {
systems = new Systems();
};
it["returns systems when adding system"] = () => {
systems.Add(new InitializeSystemSpy()).should_be_same(systems);
};
it["initializes IInitializeSystem"] = () => {
var system = new InitializeSystemSpy();
systems.Add(system);
systems.Initialize();
system.didInitialize.should_be(1);
};
it["executes IExecuteSystem"] = () => {
var system = new ExecuteSystemSpy();
systems.Add(system);
systems.Execute();
system.didExecute.should_be(1);
};
it["wraps IReactiveSystem in a ReactiveSystem"] = () => {
var system = new ReactiveSystemSpy(contexts.test.CreateCollector(Matcher.AllOf(CID.ComponentA)));
systems.Add(system);
contexts.test.CreateEntity().AddComponentA();
systems.Execute();
system.didExecute.should_be(1);
};
it["adds ReactiveSystem"] = () => {
var system = new ReactiveSystemSpy(contexts.test.CreateCollector(Matcher.AllOf(CID.ComponentA)));
systems.Add(system);
contexts.test.CreateEntity().AddComponentA();
systems.Execute();
system.didExecute.should_be(1);
};
it["cleans up ICleanupSystem"] = () => {
var system = new CleanupSystemSpy();
systems.Add(system);
systems.Cleanup();
system.didCleanup.should_be(1);
};
it["initializes, executes, cleans up and tears down InitializeExecuteCleanupTearDownSystemSpy"] = () => {
var system = new ReactiveSystemSpy(contexts.test.CreateCollector(Matcher.AllOf(CID.ComponentA)));
contexts.test.CreateEntity().AddComponentA();
systems.Add(system);
system.didInitialize.should_be(0);
systems.Initialize();
system.didInitialize.should_be(1);
system.didExecute.should_be(0);
systems.Execute();
system.didExecute.should_be(1);
system.didCleanup.should_be(0);
systems.Cleanup();
system.didCleanup.should_be(1);
system.didTearDown.should_be(0);
systems.TearDown();
system.didTearDown.should_be(1);
};
it["initializes, executes, cleans up and tears down ReactiveSystem"] = () => {
var system = createReactiveSystem(contexts);
systems.Add(system);
system.didInitialize.should_be(0);
systems.Initialize();
system.didInitialize.should_be(1);
system.didExecute.should_be(0);
systems.Execute();
systems.Execute();
system.didExecute.should_be(1);
system.didCleanup.should_be(0);
systems.Cleanup();
system.didCleanup.should_be(1);
system.didTearDown.should_be(0);
systems.TearDown();
system.didTearDown.should_be(1);
};
it["initializes, executes, cleans up and tears down systems recursively"] = () => {
var system = createReactiveSystem(contexts);
systems.Add(system);
var parentSystems = new Systems();
parentSystems.Add(systems);
system.didInitialize.should_be(0);
parentSystems.Initialize();
system.didInitialize.should_be(1);
system.didExecute.should_be(0);
parentSystems.Execute();
parentSystems.Execute();
system.didExecute.should_be(1);
system.didCleanup.should_be(0);
parentSystems.Cleanup();
system.didCleanup.should_be(1);
system.didTearDown.should_be(0);
parentSystems.TearDown();
system.didTearDown.should_be(1);
};
it["clears reactive systems"] = () => {
var system = createReactiveSystem(contexts);
systems.Add(system);
systems.Initialize();
system.didInitialize.should_be(1);
systems.ClearReactiveSystems();
systems.Execute();
system.didExecute.should_be(0);
};
it["clears reactive systems recursively"] = () => {
var system = createReactiveSystem(contexts);
systems.Add(system);
var parentSystems = new Systems();
parentSystems.Add(systems);
parentSystems.Initialize();
system.didInitialize.should_be(1);
parentSystems.ClearReactiveSystems();
parentSystems.Execute();
system.didExecute.should_be(0);
};
it["deactivates reactive systems"] = () => {
var system = createReactiveSystem(contexts);
systems.Add(system);
systems.Initialize();
system.didInitialize.should_be(1);
systems.DeactivateReactiveSystems();
systems.Execute();
system.didExecute.should_be(0);
};
it["deactivates reactive systems recursively"] = () => {
var system = createReactiveSystem(contexts);
systems.Add(system);
var parentSystems = new Systems();
parentSystems.Add(systems);
parentSystems.Initialize();
system.didInitialize.should_be(1);
parentSystems.DeactivateReactiveSystems();
parentSystems.Execute();
system.didExecute.should_be(0);
};
it["activates reactive systems"] = () => {
var system = createReactiveSystem(contexts);
systems.Add(system);
systems.Initialize();
system.didInitialize.should_be(1);
systems.DeactivateReactiveSystems();
systems.ActivateReactiveSystems();
systems.Execute();
system.didExecute.should_be(0);
contexts.test.CreateEntity().AddComponentA();
systems.Execute();
system.didExecute.should_be(1);
};
it["activates reactive systems recursively"] = () => {
var system = createReactiveSystem(contexts);
systems.Add(system);
var parentSystems = new Systems();
parentSystems.Add(systems);
parentSystems.Initialize();
system.didInitialize.should_be(1);
parentSystems.DeactivateReactiveSystems();
parentSystems.ActivateReactiveSystems();
parentSystems.Execute();
system.didExecute.should_be(0);
contexts.test.CreateEntity().AddComponentA();
systems.Execute();
system.didExecute.should_be(1);
};
};
}
