public override void EventFired(object sender, Event e)
{
if (e is SelectSoundEvent s)
{
Sounds = s.Sounds;
SelectedElementIndex = 0;
SelectedPropertyIndex = 0;
ListFromIndex = 0;
ComponentLocked = false;
SwitchTo = (Owner.Systems[ComponentSystem.IdentifierOf <ModalFocusSystem>()] as ModalFocusSystem).CurrentSystem;
}
else if (e is ModalChangeEvent ce)
{
ModalActive = true;
ModalVisible = true;
}
else if (e is BeginModalChangeEvent bmce)
{
if (ComponentLocked)
{
ComponentLocked = false;
}
else
{
bmce.SystemName = SwitchTo;
ModalActive = false;
ModalVisible = false;
}
}
}
public override void Setup()
{
base.Setup();
NotificationUIManager = ComponentSystem.RegisterComponent <NotificationUI>(20);
this.OnEvent <uFrame.Kernel.GameReadyEvent>().Subscribe(_ => { DisableAllNotificationUIFilter(_); }).DisposeWith(this);
this.OnEvent <Playfab.NotificationMessage>().Subscribe(_ => { DisplayNotificationMessageFilter(_); }).DisposeWith(this);
}
public override void Setup()
{
base.Setup();
PlayerManager = ComponentSystem.RegisterComponent <Player>(3);
HealthComponentManager = ComponentSystem.RegisterComponent <HealthComponent>(2);
this.OnEvent <test.AttackEvent>().Subscribe(_ => { HealthSystemAttackEventFilter(_); }).DisposeWith(this);
}
public override void EventFired(object sender, Event e)
{
if (e is StartObjectEditEvent s)
{
SelectedPropertyIndex = 0;
Members.Clear();
Object = s.Object;
Title = s.Title;
ReturnTo = s.ReturnTo;
foreach (FieldInfo field in Object.GetType().GetFields())
{
Members.Add(new FieldSummary(Owner, field, Object));
}
foreach (PropertyInfo property in Object.GetType().GetProperties())
{
Members.Add(new PropertySummary(Owner, property, Object));
}
if (ReturnTo == null)
{
ReturnTo = (Owner.Systems[ComponentSystem.IdentifierOf <ModalFocusSystem>()] as ModalFocusSystem)?.CurrentSystem ?? "editor_menu";
}
}
else if (e is ModalChangeEvent)
{
ModalActive = true;
ModalVisible = true;
}
else if (e is BeginModalChangeEvent bmce)
{
bmce.SystemName = ReturnTo;
ModalActive = false;
ModalVisible = false;
}
}
public override void Setup()
{
base.Setup();
TitleDataManager = ComponentSystem.RegisterGroup <TitleDataGroup, ITitleData>();
TitleDataManager.CreatedObservable.Subscribe(LoadComponentTitleDataFilter).DisposeWith(this);
this.OnEvent <Playfab.LoadData>().Subscribe(_ => { LoadTitleDataFilter(_); }).DisposeWith(this);
}
/// <summary>
/// Computes a transform node's world scale.
/// This function uses the computeWorldMatrix function to compute the world
/// matrix (bypassing caching), and returns the scale of that.
///
/// Because lossy scale does not include skew, it does not include enough
/// information to recreate a full 4x4 matrix from rotation, position, and
/// lossy scale in 3D.
///
/// This function can be quite resource intensive. If possible, read the
/// LocalToWorld component instead.
/// </summary>
public static float3 ComputeWorldScaleLossy(ComponentSystem callingSystem, Entity node)
{
float4x4 wm = ComputeWorldMatrix(callingSystem, node);
float3 s = new float3(math.length(wm[0].xyz), math.length(wm[1].xyz), math.length(wm[2].xyz));
return(s);
}
public override void Setup()
{
base.Setup();
MenuComponentManager = ComponentSystem.RegisterComponent <MenuComponent>(3);
HealthManager = ComponentSystem.RegisterComponent <Health>(1);
this.OnEvent <uFrame.ECS.UnityUtilities.MouseDownDispatcher>().Subscribe(_ => { InputSystemOnMouseDownFilter(_); }).DisposeWith(this);
}
public void AddSystem(ComponentSystem componentSystem)
{
if (componentSystem == null)
{
return;
}
var debugSystems = componentSystem as DebugSystems;
if (debugSystems != null)
{
debugSystems.gameObject.transform.SetParent(_gameObject.transform, false);
}
Type componentSystemType = componentSystem.GetType();
if (componentSystemType.GetMethod("OnStart").DeclaringType == componentSystemType)
{
_startSystemInfos.Add(new SystemInfo(componentSystem));
_startSystems.Add(componentSystem);
}
if (componentSystemType.GetMethod("OnUpdate").DeclaringType == componentSystemType)
{
_updateSystemInfos.Add(new SystemInfo(componentSystem));
_updateSystems.Add(componentSystem);
}
if (componentSystemType.GetMethod("OnFixedUpdate").DeclaringType == componentSystemType)
{
_fixedUpdateSystemInfos.Add(new SystemInfo(componentSystem));
_fixedUpdateSystems.Add(componentSystem);
}
}
public virtual void unregisterEventHandler(ComponentSystem handler)
{
foreach (SetMultimap <Type, EventHandlerInfo> eventHandlers in componentSpecificHandlers.Values)
{
IEnumerator <EventHandlerInfo> eventHandlerIterator = eventHandlers.values().GetEnumerator();
while (eventHandlerIterator.MoveNext())
{
EventHandlerInfo eventHandler = eventHandlerIterator.Current;
if (eventHandler.Handler.Equals(handler))
{
eventHandlerIterator.remove();
}
}
}
IEnumerator <EventHandlerInfo> eventHandlerIterator = generalHandlers.values().GetEnumerator();
while (eventHandlerIterator.MoveNext())
{
EventHandlerInfo eventHandler = eventHandlerIterator.Current;
if (eventHandler.Handler.Equals(handler))
{
eventHandlerIterator.remove();
}
}
}
/// <summary>
/// Helper function for transforming from world to window coordinates.
/// This only works if the cameraEntity has a valid LocalToWorld
/// component. Returns windowPos (window position) and windowSize (window size) in
/// the same coordinates.
/// </summary>
public static float2 WorldToWindow(ComponentSystem callingSystem, Entity cameraEntity, float3 worldPos, float2 windowSize)
{
var mgr = callingSystem.EntityManager;
DisplayListCamera dlc = mgr.GetComponentData <DisplayListCamera>(cameraEntity);
Camera2D c2d = mgr.GetComponentData <Camera2D>(cameraEntity);
float aspect = windowSize.x / windowSize.y;
float2 camsize;
camsize.x = c2d.halfVerticalSize * aspect;
camsize.y = c2d.halfVerticalSize;
// transform from world to window
float3 viewpos;
viewpos = math.transform(dlc.inverseWorld, worldPos);
// to normalized window
float2 windowPos;
windowPos.x = viewpos.x / camsize.x;
windowPos.y = viewpos.y / camsize.y;
// to output window
windowPos.x = (windowPos.x * .5f + .5f) * windowSize.x;
windowPos.y = (windowPos.y * .5f + .5f) * windowSize.y;
return(windowPos);
}
public override void EventFired(object sender, Event e)
{
if (e is StartSpriteSourceEditEvent s)
{
SelectedPropertyIndex = 0;
Members.Clear();
Sprite = s.Sprite;
ReturnTo = s.ReturnTo;
if (ReturnTo == null)
{
ReturnTo = (Owner.Systems[ComponentSystem.IdentifierOf <ModalFocusSystem>()] as ModalFocusSystem).CurrentSystem;
}
foreach (FieldInfo field in typeof(Sprite).GetFields())
{
Members.Add(new FieldSummary(Owner, field, Sprite));
}
foreach (PropertyInfo property in typeof(Sprite).GetProperties())
{
Members.Add(new PropertySummary(Owner, property, Sprite));
}
}
else if (e is ModalChangeEvent)
{
ModalActive = true;
ModalVisible = true;
}
else if (e is BeginModalChangeEvent bmce)
{
bmce.SystemName = ReturnTo;
ModalActive = false;
ModalVisible = false;
}
}
/// <summary>
/// Helper function for transforming from window to world coordinates.
/// This only works if cameraEntity has a valid LocalToWorld
/// component. The windowPos (window position) and windowSize (window size) should be
/// in the same coordinates. The Z coordinate is set to 0.
/// </summary>
public static float3 WindowToWorld(ComponentSystem callingSystem, Entity cameraEntity, float2 windowPos, float2 windowSize)
{
var mgr = callingSystem.EntityManager;
if (!mgr.HasComponent <DisplayListCamera>(cameraEntity) ||
!mgr.HasComponent <Camera2D>(cameraEntity))
{
return(float3.zero);
}
DisplayListCamera dlc = mgr.GetComponentData <DisplayListCamera>(cameraEntity);
Camera2D c2d = mgr.GetComponentData <Camera2D>(cameraEntity);
float aspect = windowSize.x / windowSize.y;
float2 camsize;
camsize.x = c2d.halfVerticalSize * aspect;
camsize.y = c2d.halfVerticalSize;
float2 normalizedWindow;
normalizedWindow.x = (windowPos.x / windowSize.x) * 2.0f - 1.0f;
normalizedWindow.y = (windowPos.y / windowSize.y) * 2.0f - 1.0f;
float3 viewpos;
viewpos.x = normalizedWindow.x * camsize.x;
viewpos.y = normalizedWindow.y * camsize.y;
viewpos.z = 0;
float3 worldPos = math.transform(dlc.world, viewpos);
return(worldPos);
}
private static float3 InverseTransformPoint(ComponentSystem callingSystem, Entity node, float3 p)
{
float4x4 wm = ComputeWorldMatrix(callingSystem, node);
wm = math.inverse(wm);
return(math.transform(wm, p));
}
/// <summary>
/// Computes a transform node's world rotation.
/// This function uses the computeWorldMatrix function to compute the world
/// matrix (bypassing caching), and returns the rotation of that.
///
/// This function can be quite resource intensive. When possible, read the
/// LocalToWorld component instead.
/// </summary>
public static quaternion ComputeWorldRotation(ComponentSystem callingSystem, Entity node)
{
float4x4 wm = ComputeWorldMatrix(callingSystem, node);
float3x3 rotpart = new float3x3(wm[0].xyz, wm[1].xyz, wm[2].xyz);
return(new quaternion(rotpart));
}
public override void Setup()
{
base.Setup();
MenuComponentManager = ComponentSystem.RegisterComponent <MenuComponent>(3);
HealthManager = ComponentSystem.RegisterComponent <Health>(1);
this.OnEvent <test.DamageEvent>().Subscribe(_ => { DamageSystemDamageEventFilter(_); }).DisposeWith(this);
}
public override void Setup()
{
base.Setup();
LobbyButtonManager = ComponentSystem.RegisterComponent <LobbyButton>();
RoomManager = ComponentSystem.RegisterComponent <Room>();
DriverManager = ComponentSystem.RegisterComponent <Driver>();
this.OnEvent <uFrame.Kernel.GameReadyEvent>().Subscribe(_ => { PhotonSystemGameReadyFilter(_); }).DisposeWith(this);
}
public override void Setup()
{
base.Setup();
UserLoginInfoManager = ComponentSystem.RegisterComponent <UserLoginInfo>(23);
BlackBoardSystem.EnsureBlackBoard <UserLoginInfo>();
this.OnEvent <Playfab.UserLoggedIn>().Subscribe(_ => { LoginSystemUserLoggedInFilter(_); }).DisposeWith(this);
this.OnEvent <Playfab.UserLoggedOut>().Subscribe(_ => { LoginSystemUserLoggedOutFilter(_); }).DisposeWith(this);
}
public ReflectedEventHandlerInfo(ComponentSystem handler, Method method, int priority, ICollection <Type> filterComponents, ICollection <Type> componentParams)
{
this.handler = handler;
this.method = method;
this.filterComponents = ImmutableList.copyOf(filterComponents);
this.componentParams = ImmutableList.copyOf(componentParams);
this.priority = priority;
}
public override void Setup()
{
base.Setup();
healthCompManager = ComponentSystem.RegisterComponent <healthComp>(2);
playerCompManager = ComponentSystem.RegisterComponent <playerComp>(3);
NewGroupNodeManager = ComponentSystem.RegisterGroup <NewGroupNodeGroup, NewGroupNode>();
this.OnEvent <uFrame.ECS.UnityUtilities.MouseDownDispatcher>().Subscribe(_ => { inpSysOnMouseDownFilter(_); }).DisposeWith(this);
}
public override void Setup()
{
base.Setup();
DriverManager = ComponentSystem.RegisterComponent <Driver>();
this.OnEvent <uFrame.Kernel.GameReadyEvent>().Subscribe(_ => { KernelGameReadyFilter(_); }).DisposeWith(this);
this.OnEvent <DireDungeons.LoadSceneEvent>().Subscribe(_ => { KernelLoadSceneEventFilter(_); }).DisposeWith(this);
this.OnEvent <DireDungeons.UnloadSceneEvent>().Subscribe(_ => { KernelUnloadSceneEventFilter(_); }).DisposeWith(this);
}
public override void Setup()
{
base.Setup();
healthCompManager = ComponentSystem.RegisterComponent <healthComp>(2);
playerCompManager = ComponentSystem.RegisterComponent <playerComp>(3);
NewGroupNodeManager = ComponentSystem.RegisterGroup <NewGroupNodeGroup, NewGroupNode>();
this.OnEvent <test.NewEventNode>().Subscribe(_ => { healthSysNewEventNodeFilter(_); }).DisposeWith(this);
}
public override void Setup()
{
base.Setup();
HealthManager = ComponentSystem.RegisterComponent <Health>(1);
SwordManager = ComponentSystem.RegisterComponent <Sword>(3);
ShieldManager = ComponentSystem.RegisterComponent <Shield>(2);
OrcManager = ComponentSystem.RegisterGroup <OrcGroup, Orc>();
}
public void Update(ComponentSystem cs)
{
cachedGetSprite2DRenderer = cs.GetComponentDataFromEntity <Sprite2DRenderer>();
cachedGetSprite2DPrivate = cs.GetComponentDataFromEntity <Sprite2DPrivate>();
cachedGetSprite2DRendererOptions = cs.GetComponentDataFromEntity <Sprite2DRendererOptions>();
cachedGetSprite2D = cs.GetComponentDataFromEntity <Sprite2D>();
cachedGetSprite2DBorder = cs.GetComponentDataFromEntity <Sprite2DBorder>();
}
private double MonitorSystemFixedUpdateDuration(ComponentSystem _componentSystem)
{
_stopwatch.Reset();
_stopwatch.Start();
_componentSystem.OnFixedUpdate();
_stopwatch.Stop();
return(_stopwatch.Elapsed.TotalMilliseconds);
}
public override void Setup()
{
base.Setup();
ShootingGunsManager = ComponentSystem.RegisterGroup <ShootingGunsGroup, ShootingGuns>();
PlayerGunnerManager = ComponentSystem.RegisterGroup <PlayerGunnerGroup, PlayerGunner>();
GunManager = ComponentSystem.RegisterComponent <Gun>(2);
GunnerInputManager = ComponentSystem.RegisterComponent <GunnerInput>(3);
GunnerManager = ComponentSystem.RegisterComponent <Gunner>(1);
}
public override void Setup()
{
base.Setup();
PlayerGunnerManager = ComponentSystem.RegisterGroup <PlayerGunnerGroup, PlayerGunner>();
MovableManager = ComponentSystem.RegisterComponent <Movable>(23);
HazardManager = ComponentSystem.RegisterComponent <Hazard>(9);
WavesGameManager = ComponentSystem.RegisterComponent <WavesGame>(15);
PlayerManager = ComponentSystem.RegisterComponent <Player>(22);
}
public override void Setup()
{
base.Setup();
HealthManager = ComponentSystem.RegisterComponent <Health>(3);
OrcManager = ComponentSystem.RegisterGroup <OrcGroup, Orc>();
SwordManager = ComponentSystem.RegisterComponent <Sword>(1);
ShieldManager = ComponentSystem.RegisterComponent <Shield>(2);
this.OnEvent <uFrame.Kernel.GameReadyEvent>().Subscribe(_ => { DebugSystemGameReadyFilter(_); }).DisposeWith(this);
}
private static float3 InverseTransformScale(ComponentSystem callingSystem, Entity node, float3 s)
{
float4x4 wm = ComputeWorldMatrix(callingSystem, node);
wm = math.inverse(wm);
float3 sm = new float3(math.length(wm[0].xyz), math.length(wm[1].xyz), math.length(wm[2].xyz));
return(sm * s);
}
public override void Setup()
{
base.Setup();
LobbyButtonManager = ComponentSystem.RegisterComponent <LobbyButton>();
LobbyMenuManager = ComponentSystem.RegisterComponent <LobbyMenu>();
UpdateConnectedManager = ComponentSystem.RegisterComponent <UpdateConnected>();
this.OnEvent <uFrame.ECS.PointerClickDispatcher>().Subscribe(_ => { LobbySystemPointerClickFilter(_); }).DisposeWith(this);
this.OnEvent <uFrame.ECS.OnConnectedToMasterDispatcher>().Subscribe(_ => { LobbySystemOnConnectedToMasterFilter(_); }).DisposeWith(this);
}
/// <summary>
/// Returns the size of the childTransform's parent. If the childTransform
/// doesn't have a parent, returns the screen size.
/// </summary>
public static float2 GetRectTransformSizeOfParent(ComponentSystem sys, Entity parent)
{
// If there is no parent, return screen size.
if (parent == Entity.Null)
{
return(GetScreenSize(sys));
}
return(GetRectTransformSizeOfEntity(sys, parent));
}
