public SpriteOutlineModule(ISpriteEditor sem, IEventSystem es, IUndoSystem us, IAssetDatabase ad, IGUIUtility gu, IShapeEditorFactory sef, ITexture2D outlineTexture)
{
spriteEditorWindow = sem;
undoSystem = us;
eventSystem = es;
assetDatabase = ad;
guiUtility = gu;
shapeEditorFactory = sef;
m_OutlineTexture = outlineTexture;
m_ShapeSelectionUI = new ShapeEditorRectSelectionTool(gu);
m_ShapeSelectionUI.RectSelect += RectSelect;
m_ShapeSelectionUI.ClearSelection += ClearSelection;
}
private void OnEnable()
{
this.m_EventSystem = new EventSystem();
this.m_UndoSystem = new UndoSystem();
this.m_AssetDatabase = new AssetDatabaseSystem();
this.m_GUIUtility = new GUIUtilitySystem();
base.minSize = new Vector2(360f, 200f);
base.titleContent = SpriteEditorWindow.SpriteEditorWindowStyles.spriteEditorWindowTitle;
SpriteEditorWindow.s_Instance = this;
this.m_UndoSystem.RegisterUndoCallback(new Undo.UndoRedoCallback(this.UndoRedoPerformed));
EditorApplication.modifierKeysChanged = (EditorApplication.CallbackFunction)Delegate.Combine(EditorApplication.modifierKeysChanged, new EditorApplication.CallbackFunction(this.ModifierKeysChanged));
this.ResetWindow();
this.RefreshPropertiesCache();
this.RefreshRects();
this.InitModules();
}
public override void Setup(IEventSystem eventSystem, IPoolManager poolManager)
{
Components = new Type[] { typeof(HealthComponent) };
Func <IEntity, ReactiveProperty <bool> > checkIsDead = (e) =>
{
var health = e.GetComponent <HealthComponent> ();
health.CurrentHealth.Value = health.StartingHealth;
var isDead = health.CurrentHealth.DistinctUntilChanged().Select(value => value <= 0).ToReactiveProperty();
return(isDead);
};
Predicates.Add(checkIsDead);
base.Setup(eventSystem, poolManager);
}
protected ViewHandler(IPoolManager poolManager, IEventSystem eventSystem, IInstantiator instantiator)
{
PoolManager = poolManager;
EventSystem = eventSystem;
Instantiator = instantiator;
_viewCache = new Dictionary <Guid, GameObject>();
_destructionSubscription = EventSystem.Receive <ComponentRemovedEvent>()
.Where(x => x.Component is ViewComponent && _viewCache.ContainsKey(x.Entity.Id))
.Subscribe(x =>
{
var view = _viewCache[x.Entity.Id];
_viewCache.Remove(x.Entity.Id);
DestroyView(view);
});
}
public SoundEffectSystem(EnemyAttackSounds enemyAttackSounds, PlayerAttackSounds playerAttackSounds,
WalkingSounds walkingSounds, DeathSounds deathSounds, DrinkSounds drinkSounds,
FoodSounds foodSounds, IEventSystem eventSystem)
{
_enemyAttackSounds = enemyAttackSounds;
_playerAttackSounds = playerAttackSounds;
_walkingSounds = walkingSounds;
_deathSounds = deathSounds;
_drinkSounds = drinkSounds;
_foodSounds = foodSounds;
_eventSystem = eventSystem;
var soundEffectObject = GameObject.Find("SoundEffectSource");
_soundEffectSource = soundEffectObject.GetComponent <AudioSource>();
}
public override void Setup(IEventSystem eventSystem, IPoolManager poolManager, GroupFactory groupFactory)
{
base.Setup(eventSystem, poolManager, groupFactory);
var group = GroupFactory.Create(new Type[] { typeof(HealthComponent), typeof(ViewComponent), typeof(UnityEngine.AI.NavMeshAgent) });
group.OnAdd().Subscribe(entity =>
{
var viewComponent = entity.GetComponent <ViewComponent>();
var navMeshAgent = entity.GetComponent <NavMeshAgent> ();
var health = entity.GetComponent <HealthComponent> ();
Observable.EveryUpdate().Subscribe(_ =>
{
if (Target == null)
{
var go = GameObject.FindGameObjectWithTag("Player");
if (go == null)
{
return;
}
Target = go.transform;
if (Target == null)
{
return;
}
TargetHealth = Target.GetComponent <EntityBehaviour> ().Entity.GetComponent <HealthComponent> ();
if (TargetHealth == null)
{
return;
}
}
if (health.CurrentHealth.Value > 0 && TargetHealth.CurrentHealth.Value > 0)
{
navMeshAgent.SetDestination(Target.position);
}
else
{
navMeshAgent.enabled = false;
}
}).AddTo(navMeshAgent).AddTo(health);
}).AddTo(this);
}
protected PooledViewResolverSystem(IPoolManager poolManager, IEventSystem eventSystem)
{
PoolManager = poolManager;
EventSystem = eventSystem;
PrefabTemplate = ResolvePrefabTemplate();
EventSystem.Receive <EntityRemovedEvent>()
.Subscribe(x =>
{
GameObject view;
if (_views.TryGetValue(x.Entity, out view))
{
RecycleView(view);
_views.Remove(x.Entity);
}
});
}
public static IObservable <T> OnEvent <T>(this IEventSystem eventSystem, bool onlyOnMainThread = false)
{
IObservable <T> result = null;
if (typeof(T) == typeof(object) || typeof(ISerializableEvent).IsAssignableFrom(typeof(T)))
{
result = eventSystem.Receive(typeof(T)).Select(evt => (T)evt);
}
else
{
result = eventSystem.Receive <T>();
}
if (onlyOnMainThread)
{
result = result.ObserveOnMainThread();
}
return(result);
}
public EventPipe(string source, IEventSystem factory)
{
Source = source;
var consumers = factory.CreateConsumers(Source);
if (consumers == null)
{
return;
}
foreach (var consumer in consumers)
{
_errorHandler.AddIf(consumer);
_eventHandler.AddIf(consumer);
_scopeHandler.AddIf(consumer);
}
}
public GraphicsSystem(IEventSystem eventSystem)
{
_drawShapeComponent = DrawShapeComponent;
_drawComponent = DrawAnimatedComponent;
_eventSystem = eventSystem;
_eventSystem.Subscribe <CollisionEvent>(this, (sender, collision) =>
{
_collisionArguments.Add(collision);
});
_eventSystem.Subscribe <UserInputInfo>(this, (sender, userInputInfo) =>
{
switch (userInputInfo.VirtualKey)
{
case VirtualKey.Number1 when userInputInfo.IsPressed:
_drawPositionHistory = _drawPositionHistory == null ? DrawPositionHistory : default(Action <CanvasDrawingSession, GameObject>);
break;
public override void Setup(IEventSystem eventSystem, IPoolManager poolManager, GroupFactory groupFactory)
{
base.Setup(eventSystem, poolManager, groupFactory);
EventSystem.OnEvent <DeathEvent> ().Where(_ => _.Target.HasComponent <InputComponent> ()).Subscribe(_ =>
{
Observable.EveryUpdate().Subscribe(__ =>
{
if (Input.GetMouseButton(0))
{
EventSystem.Publish(new LoadSceneEvent()
{
SceneName = "Level_01"
});
Disposer.Clear();
}
}).AddTo(Disposer).AddTo(this);
}).AddTo(this);
}
public FilesManager(IListManager listManager, IEventSystem eventSystem, IImageIndexer imageIndexer)
: base(listManager, eventSystem)
{
ReactOn <PrepareLoadEvent>(_ => Filter = string.Empty);
ReactOn <DeleteEvent>(c =>
{
try
{
imageIndexer
.GetEntity(c.Index)
.IfHasValue(ic =>
{
File.Delete(ic.FilePath);
imageIndexer.Remove(ic.Index);
});
}
catch (Exception e)
{
MessageBox.Show(e.Message, "Fehler", MessageBoxButton.OK, MessageBoxImage.Error);
}
});
var imageSource = listManager.GetList <ImageComponent>();
_filter = Track(new ReactiveProperty <SearchQuery>(initialValue: SearchQuery.Empty), nameof(Filter));
var filter = _filter.Select(sq => new Func <ImageComponent, bool>(sq.FilterAction));
DisposeThis(imageSource
.Connect()
.Filter(filter)
.ObserveOnDispatcher()
.Bind(Filtered)
.Subscribe());
DisposeThis(imageSource
.Connect()
.AutoRefreshOnObservable(ic => ic.IsFavorite)
.Where(c => c.IsFavorite.Value)
.ObserveOnDispatcher()
.Bind(Favorites)
.Subscribe());
}
protected PooledViewResolverSystem(IPoolManager poolManager, IEventSystem eventSystem, IInstantiator instantiator)
{
PoolManager = poolManager;
Instantiator = instantiator;
EventSystem = eventSystem;
_viewCache = new Dictionary <Guid, GameObject>();
_entitySubscription = EventSystem
.Receive <ComponentRemovedEvent>()
.Where(x => x.Component is ViewComponent && _viewCache.ContainsKey(x.Entity.Id))
.Subscribe(x =>
{
var view = _viewCache[x.Entity.Id];
RecycleView(view);
_viewCache.Remove(x.Entity.Id);
});
PrefabTemplate = ResolvePrefabTemplate();
}
public BulletCollisionSystem(IPoolManager poolManager, IEventSystem eventSystem)
{
_pool = poolManager.GetPool("");
_eventSystem = eventSystem;
_destructiblesAccessor = poolManager
.CreateGroupAccessor(new Group(
typeof(DestructibleComponent)
));
_subscriptions = new List <IDisposable>();
_eventSystem.Receive <LevelEvent>()
.Where(x => x.action == LevelActions.START)
.Subscribe(x =>
{
var destructiblesGo = GameObject.Find("Map/Destructibles");
_destructiblesTilemap = destructiblesGo.GetComponent <Tilemap>();
})
.AddTo(_subscriptions);
}
public override void Setup(IEventSystem eventSystem, IPoolManager poolManager, GroupFactory groupFactory)
{
base.Setup(eventSystem, poolManager, groupFactory);
EventSystem.OnEvent <LoadSceneEvent> ().Subscribe(e =>
{
LoadScene(e.SceneName);
// UnloadSceneAsync("Level_01").ToObservable()
// .SelectMany(x => LoadSceneAsync(e.SceneName))
// .Subscribe(x =>
// {
// // Debug.Log("Loading Complete!");
// });
}).AddTo(this);
EventSystem.OnEvent <UnloadSceneEvent> ().Subscribe(e =>
{
StartCoroutine(UnloadSceneAsync(e.SceneName));
}).AddTo(this);
}
public UISystem(IEventSystem eventSystem, IPoolManager poolManager)
{
var playerHealthPanelCountGo = GameObject.Find("PlayerHealthPanel/Count");
_playerHealthPanelCount = playerHealthPanelCountGo.GetComponent <Text>();
var scoreCountGo = GameObject.Find("ScorePanel/Count");
_scoreCount = scoreCountGo.GetComponent <Text>();
_totalScore = 0;
_pauseButtonGo = GameObject.Find("PauseButton");
_pauseToggle = _pauseButtonGo.GetComponent <Toggle>();
var resetButtonGo = GameObject.Find("ResetButton");
_resetBtnButton = resetButtonGo.GetComponent <Button>();
var pauseGo = GameObject.Find("PauseButton/Pause");
_pauseImage = pauseGo.GetComponent <Image>();
var playGo = GameObject.Find("PauseButton/Play");
_playImage = playGo.GetComponent <Image>();
_directionJoystick = GameObject.Find("DirectionJoystick");
_rotationJoystick = GameObject.Find("RotationJoystick");
_restartPanelGo = GameObject.Find("RestartPanel");
_pauseTextGo = GameObject.Find("PauseText");
var playerHealthBarGo = GameObject.Find("PlayerHealthPanel/Bar");
_playerHealthBarSlider = playerHealthBarGo.GetComponent <Slider>();
_curtainGo = GameObject.Find("Curtain");
_curtainImage = _curtainGo.GetComponent <Image>();
_dashButtonGo = GameObject.Find("DashButton");
var restartPanelScoreCountGo = GameObject.Find("RestartPanel/ScoreCount");
_restartPanelScoreCount = restartPanelScoreCountGo.GetComponent <Text>();
_eventSystem = eventSystem;
_subscriptions = new List <IDisposable>();
_playersAccessor = poolManager
.CreateGroupAccessor(new Group(
typeof(PlayerComponent),
typeof(ViewComponent)
));
}
public override void Initialize(IEventSystem eventSystem, IPoolManager poolManager, GroupFactory groupFactory, PrefabFactory prefabFactory)
{
base.Initialize(eventSystem, poolManager, groupFactory, prefabFactory);
foreach (var system in RuntimeSystems)
{
system.Initialize(eventSystem, poolManager, groupFactory, prefabFactory);
system.IsOn.DistinctUntilChanged().Where(_ => this.isActiveAndEnabled).Subscribe(b =>
{
if (b)
{
system.OnEnable();
}
else
{
system.OnDisable();
}
}).AddTo(this.Disposer);
}
}
private void ClearNodes()
{
NodeWidth = 300;
NodeHeight = 150;
wantsMouseMove = true;
Nodes = new List <IDrawable>();
Connections = new List <IDrawable>();
NodeEvents = new NodeWindowEventSystem();
NodeEvents.OnContextClick += CreateContextMenu;
ConnectionCreatedEvent += OnConnectionCreated;
NodeEvents.OnMouseUp += e =>
{
if (CurrentAcceptingDrag != null)
{
return;
}
CurrentAcceptingDrag = null;
CurrentSendingDrag = null;
};
}
public SystemExecutor(IPoolManager poolManager, IEventSystem eventSystem,
IReactToEntitySystemHandler reactToEntitySystemHandler, IReactToGroupSystemHandler reactToGroupSystemHandler,
ISetupSystemHandler setupSystemHandler, IReactToDataSystemHandler reactToDataSystemHandler,
IManualSystemHandler manualSystemHandler)
{
PoolManager = poolManager;
EventSystem = eventSystem;
ReactToEntitySystemHandler = reactToEntitySystemHandler;
ReactToGroupSystemHandler = reactToGroupSystemHandler;
SetupSystemHandler = setupSystemHandler;
ReactToDataSystemHandler = reactToDataSystemHandler;
ManualSystemHandler = manualSystemHandler;
EventSystem.Receive <EntityAddedEvent>().Subscribe(OnEntityAddedToPool);
EventSystem.Receive <EntityRemovedEvent>().Subscribe(OnEntityRemovedFromPool);
EventSystem.Receive <ComponentAddedEvent>().Subscribe(OnEntityComponentAdded);
EventSystem.Receive <ComponentRemovedEvent>().Subscribe(OnEntityComponentRemoved);
_systems = new List <ISystem>();
_systemSubscriptions = new Dictionary <ISystem, IList <SubscriptionToken> >();
}
/// <summary>
/// Unregisters all event names in a simple events class
/// </summary>
/// <param name="eventSystem"></param>
/// <param name="eventList"></param>
public static void UnregisterEvents(IEventSystem eventSystem, IEventList eventList)
{
if (eventSystem == null)
{
throw new ArgumentNullException(nameof(eventSystem));
}
if (eventList == null)
{
throw new ArgumentNullException(nameof(eventList));
}
foreach (var name in eventList.SimpleEvents)
{
eventSystem.UnregisterEvent(name);
}
foreach (var eventType in eventList.EventTypes)
{
eventSystem.UnregisterEvent(EventName(eventType));
}
}
public override void Setup(IEventSystem eventSystem, IPoolManager poolManager, GroupFactory groupFactory)
{
base.Setup(eventSystem, poolManager, groupFactory);
var group = GroupFactory.Create(new Type[] { typeof(InputComponent), typeof(ViewComponent), typeof(Animator) });
group.OnAdd().Subscribe(entity =>
{
var input = entity.GetComponent <InputComponent> ();
var horizontal = input.Horizontal.DistinctUntilChanged();
var vertical = input.Vertical.DistinctUntilChanged();
var animator = entity.GetComponent <Animator>();
Observable.CombineLatest(horizontal, vertical, (h, v) =>
{
return(h != 0f || v != 0f);
}).ToReadOnlyReactiveProperty().DistinctUntilChanged().Subscribe(value =>
{
animator.SetBool("IsWalking", value);
}).AddTo(input.Disposer);
}).AddTo(Disposer);
}
public void ApplyTo(IEventSystem eventSystem)
{
if (eventSystem == null)
{
throw new ArgumentNullException(nameof(eventSystem));
}
//To avoid issues where queued up events can be added to the operations list while applying operations,
//Use 2 lists to ensure no corruption occurs
var operations = _operations;
_operations = _swapList;
_swapList = operations;
foreach (var operation in _swapList)
{
operation.Execute(eventSystem);
}
_swapList.Clear();
}
public override void Setup(IEventSystem eventSystem, IPoolManager poolManager, GroupFactory groupFactory)
{
base.Setup(eventSystem, poolManager, groupFactory);
FloorMask = LayerMask.GetMask("Floor");
var group = GroupFactory.Create(new Type[] { typeof(ViewComponent), typeof(InputComponent), typeof(Rigidbody) });
Observable.EveryFixedUpdate().Subscribe(_ =>
{
foreach (var entity in group.Entities)
{
var input = entity.GetComponent <InputComponent> ();
input.Horizontal.Value = Input.GetAxisRaw("Horizontal");
input.Vertical.Value = Input.GetAxisRaw("Vertical");
var movement = Vector3.zero;
movement.Set(input.Horizontal.Value, 0f, input.Vertical.Value);
var speed = 6f;
movement = movement.normalized * speed * Time.deltaTime;
var rb = entity.GetComponent <Rigidbody>();
rb.MovePosition(rb.transform.position + movement);
// execute turning
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (Physics.Raycast(ray, out hit, 1000f, FloorMask))
{
Vector3 playerToMouse = hit.point - rb.transform.position;
playerToMouse.y = 0f;
Quaternion newRotation = Quaternion.LookRotation(playerToMouse);
rb.MoveRotation(newRotation);
}
}
}).AddTo(this);
}
private EventHandlerStandard <T_Event> GetSystem <T_Event>() where T_Event : struct
{
Type evType = typeof(T_Event);
if (evType == _cachedSystemEventType)
{
return((EventHandlerStandard <T_Event>)_cacheSystem);
}
IEventSystem system;
if (!_systemsCache.TryGetValue(evType, out system))
{
system = new EventHandlerStandard <T_Event>();
_systems.Add(system);
_systemsCache[evType] = system;
}
_cachedSystemEventType = evType;
_cacheSystem = system;
return((EventHandlerStandard <T_Event>)system);
}
public override void Setup(IEventSystem eventSystem, IPoolManager poolManager, GroupFactory groupFactory)
{
base.Setup(eventSystem, poolManager, groupFactory);
var group = GroupFactory.Create(new Type[] { typeof(Camera), typeof(FollowerComponent) });
group.OnAdd().Subscribe(entity =>
{
var follower = entity.GetComponent <FollowerComponent>();
follower.Offset = follower.transform.position - follower.Target.position;
Observable.EveryFixedUpdate().Subscribe(_ =>
{
if (follower.Target == null)
{
return;
}
Vector3 targetCamPos = follower.Target.position + follower.Offset;
follower.transform.position = Vector3.Lerp(follower.transform.position, targetCamPos, follower.Smoothing * Time.deltaTime);
}).AddTo(follower);
}).AddTo(this);
}
public void GlobalSetup()
{
_eventSystem = new EventSystem(new MessageBroker());
var entityFactory = new DefaultEntityFactory(_eventSystem);
var poolFactory = new DefaultEntityCollectionFactory(entityFactory, _eventSystem);
var groupAccessorFactory = new DefaultObservableObservableGroupFactory(_eventSystem);
_entityCollectionManager = new EntityCollectionManager(_eventSystem, poolFactory, groupAccessorFactory);
_availableComponents = _groupFactory.GetComponentTypes
.Select(x => Activator.CreateInstance(x) as IComponent)
.ToArray();
_testGroups = _groupFactory.CreateTestGroups().ToArray();
foreach (var group in _testGroups)
{
_entityCollectionManager.CreateObservableGroup(group);
}
_defaultEntityCollection = _entityCollectionManager.GetCollection();
}
public WorldState(
ILogger logger,
IEventSystem eventSystem,
IFileSystem fileSystem,
EntitySystemMetaData entitySystemMetaData,
IRenderer renderer,
IReadOnlyList <IModelFormatProvider> modelFormats)
{
if (modelFormats == null)
{
throw new ArgumentNullException(nameof(modelFormats));
}
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
_eventSystem = eventSystem ?? throw new ArgumentNullException(nameof(eventSystem));
_fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
Renderer = renderer ?? throw new ArgumentNullException(nameof(renderer));
BSPUtils = new BSPModelUtils(Framework.BSPModelNamePrefix, Framework.Directory.Maps, Framework.Extension.BSP);
EntitySystemMetaData = entitySystemMetaData ?? throw new ArgumentNullException(nameof(entitySystemMetaData));
_modelCreator = new ModelCreator(logger, fileSystem, modelFormats.Select(p => p.CreateLoader()));
RendererModels = Renderer.Models ?? throw new ArgumentNullException(nameof(Renderer.Models));
}
protected ViewHandler(IPoolManager poolManager, IEventSystem eventSystem, IInstantiator instantiator)
{
PoolManager = poolManager;
EventSystem = eventSystem;
Instantiator = instantiator;
}
public NewEnemyWaveEmitterSystem(IEventSystem system, IEntityCollection collection)
: base(system)
{
this.collection = collection;
}
public CoinSpawnSystem(IEventSystem eventSystem, IPoolManager poolManager) : base(eventSystem)
{
_pool = poolManager.GetPool("");
}
