/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
GameEntityFactory.GraphicsDevice = GraphicsDevice;
frameCounterSystem = new FrameCounterSystem(true, this.Window);
modelRenderSystem = new ModelRenderSystem();
modelRenderSystem.graphicsDevice = GraphicsDevice;
playerInputSystem = new PlayerInputSystem();
cameraSystem = new CameraSystem();
uiSystem = new UIRenderSystem();
collisionHandlingSystem = new CollisionHandlingSystem();
aiSystem = new AiSystem();
collisionDetectionSystem = new CollisionDetectionSystem(false);
frictionSystem = new FrictionSystem();
gravitySystem = new GravitySystem();
transformSystem = new TransformSystem();
SystemManager.Instance.AddToUpdateables(
cameraSystem,
collisionDetectionSystem,
transformSystem,
gravitySystem,
frictionSystem,
playerInputSystem,
collisionHandlingSystem,
aiSystem,
frameCounterSystem
);
SystemManager.Instance.AddToDrawables(modelRenderSystem, frameCounterSystem, uiSystem);
base.Initialize();
}
public void Init(
IEnumerable <PlanetContext> planets,
GravitySystem gravitySystem,
SystemsUpdater systemsUpdater,
HealthsContainer healthsContainer,
RocketState[] rocketsStates
)
{
MovementSystem = new RocketsMovementSystem(gravitySystem);
systemsUpdater.AddPhysicsTicker(MovementSystem);
_rocketsFactory = new RocketsFactory(
_rockets,
MovementSystem,
_rocketsParent,
healthsContainer,
_cameraTransform
);
_rocketsFactory.CreateRockets(rocketsStates);
foreach (var planet in planets)
{
planet.CannonProvider.SetFactory(_rocketsFactory);
var cannon = planet.CannonProvider.GetCannon();
systemsUpdater.AddFrameTicker(cannon);
}
}
/*
* Circular Orbit Prediction
*
* x(t)=acos( (2π(t−t0)) / T)
* y(t)=asin( (2π(t−t0)) / T)
*
* T=2π * sqrt( a^3 / q )
*
* of the central body
* q = G * M
*/
public static OrbitPrediction GetStaticOrbitPrediction(float t, GravitySystem gravitySystem)
{
GravitySystem parentSystem = gravitySystem.parentSystem;
// No Central body, thus no prediction
if (!parentSystem)
{
return(new OrbitPrediction(t, gravitySystem));
}
float q = instance.gravityConstant * parentSystem.GetMass();
float a = gravitySystem.localStartPosition.magnitude;
float T = 2 * Mathf.PI * Mathf.Sqrt(Mathf.Pow(a, 3) / q);
float t0 = gravitySystem.t0;
float x = a * Mathf.Cos((2 * Mathf.PI * (t - t0)) / T);
float y = a * Mathf.Sin((2 * Mathf.PI * (t - t0)) / T);
float xV = -a *Mathf.Sin((2 * Mathf.PI * (t - t0)) / T) * (2 * Mathf.PI) / T;
float yV = a * Mathf.Cos((2 * Mathf.PI * (t - t0)) / T) * (2 * Mathf.PI) / T;
Vector2 localPosition = new Vector2(x, y);
Vector2 localVelocity = new Vector2(xV, yV);
return(new OrbitPrediction(t, localPosition, localVelocity));
}
public static float GetT0(GravitySystem gravitySystem)
{
GravitySystem parentSystem = gravitySystem.parentSystem;
// No Central body, thus no prediction
if (!parentSystem)
{
return(0);
}
float x = gravitySystem.localStartPosition.x;
float y = gravitySystem.localStartPosition.y;
float q = instance.gravityConstant * parentSystem.GetMass();
float a = gravitySystem.localStartPosition.magnitude;
float T = 2 * Mathf.PI * Mathf.Sqrt(Mathf.Pow(a, 3) / q);
float xt0 = -(Mathf.Acos(x / a) * T) / (2 * Mathf.PI);
float yt0 = -(Mathf.Asin(y / a) * T) / (2 * Mathf.PI);
string s = gravitySystem.name + "\n";
s += "X: " + x + " xT0: " + xt0 + "\n";
s += "Y: " + y + " yT0: " + yt0 + "\n";
print(s);
float t0 = 0;
t0 = y > 0 ? xt0 : yt0;
t0 = y < 0 && x < 0 ? -xt0: t0;
return(t0);
}
/// <summary>
/// In Editor
/// </summary>
public void CheckSystem()
{
mass = 0;
if (!renderer)
{
renderer = GetComponentInChildren <SpriteRenderer>();
}
//Radius of Influence
GravitySystem parentSystem = null;
if (transform.parent)
{
parentSystem = transform.parent.GetComponent <GravitySystem>();
}
if (parentSystem)
{
float distToParentSytem = ((Vector2)parentSystem.transform.position - (Vector2)transform.position).magnitude;
radiusOfInfluence = OrbitMath.CircleOfInfluence(distToParentSytem, GetMass(), parentSystem.GetMass());
}
else
{
radiusOfInfluence = 10000;
}
// Add Siblings in RadiusOfInfluence
if (parentSystem)
{
GravitySystem[] siblingSystems = parentSystem.GetChildSystems();
foreach (GravitySystem siblingSystem in siblingSystems)
{
if (siblingSystem == this)
{
continue;
}
float distance = Vector2.Distance(transform.position, siblingSystem.transform.position);
if (distance < radiusOfInfluence && siblingSystem.GetMass() < GetMass())
{
siblingSystem.transform.SetParent(transform);
}
if (distance < siblingSystem.radiusOfInfluence && siblingSystem.GetMass() > GetMass())
{
transform.SetParent(siblingSystem.transform);
}
}
}
// Check if this system exited another System
if (parentSystem)
{
float distance = Vector2.Distance(transform.position, parentSystem.transform.position);
if (distance > parentSystem.radiusOfInfluence)
{
transform.SetParent(parentSystem.transform.parent);
}
}
}
public void Init(IEnumerable <PlanetContext> planets)
{
GravitySystem = new GravitySystem(_gravitySettings);
foreach (var planet in planets)
{
GravitySystem.Add(planet.Rb);
}
GravitySystem.Add(_sun);
}
private void Start()
{
var systemSize = 2000; //PlayerPrefs.GetInt(InformationPanel.SYSTEM_SIZE_PREF, DEFAULT_SYSTEM_SIZE);
var system = GetComponent <ParticleSystem>();
GravitySystem = new GravitySystem(system, systemSize);
_bursts = new Burst[systemSize];
_soundMaker = GetComponent <SoundMaker>();
_impulseSource = GetComponent <CinemachineImpulseSource>();
}
public void ChangeSystem(GravitySystem newSystem)
{
// Same System
if (gravitySystem == newSystem)
{
return;
}
if (!newSystem)
{
return;
}
OrbitPrediction newSystemPrediction = newSystem.GetPrediction(time);
// From World Space
if (!gravitySystem)
{
if (!newSystem.parentSystem)
{
//Sun
gravitySystem = newSystem;
return;
}
else
{
//
localPosition -= newSystemPrediction.localPosition;
localVelocity -= newSystemPrediction.localVelocity;
gravitySystem = newSystem;
return;
}
}
// From ParentSystem
if (gravitySystem == newSystem.parentSystem)
{
localPosition -= newSystemPrediction.localPosition;
localVelocity -= newSystemPrediction.localVelocity;
gravitySystem = newSystem;
return;
}
// From Child System
if (gravitySystem.parentSystem = newSystem)
{
OrbitMath.OrbitPrediction childPrediction = gravitySystem.GetPrediction(time);
localPosition += childPrediction.localPosition;
localVelocity += childPrediction.localVelocity;
gravitySystem = newSystem;
return;
}
gravitySystem = newSystem;
}
private void Awake()
{
masses = GameObject.FindObjectsOfType <Gravity>();
rbs = new Rigidbody[masses.Length];
if (Instance != null)
{
throw new System.Exception("GravitySystem singleton already exists");
}
Instance = this;
}
public void Awake()
{
if (transform.parent)
{
parentSystem = transform.parent.GetComponent <GravitySystem>();
}
else
{
sunSystem = this;
}
}
void Awake()
{
if (instance == null)
{
instance = this;
}
else
{
Destroy(gameObject);
return;
}
DontDestroyOnLoad(gameObject);
}
public GravitySystem[] GetChildSystems()
{
List <GravitySystem> childSystems = new List <GravitySystem>();
foreach (Transform child in transform)
{
GravitySystem childSystem = child.GetComponent <GravitySystem>();
if (childSystem)
{
childSystems.Add(childSystem);
}
}
return(childSystems.ToArray());
}
public void FixedUpdate()
{
currentSystem = player.GetCurrentSystem();
//Position
middle = currentSystem.transform.position;
if (currentSystem == GravitySystem.sunSystem)
{
middle = player.transform.position;
}
//Size
size = Vector2.one * currentSystem.radiusOfInfluence * 2;
newOSize = ToOrthographicSize(size);
}
public void Init(
GravitySystem gravitySystem,
OrbitsSystem orbitsSystem,
PlanetsStorage planetsStorage
)
{
HealthsContainer = new HealthsContainer();
foreach (var planet in planetsStorage.Planets)
{
HealthsContainer.AddHealth(planet.HealthProvider.GetHealth());
}
HealthsContainer.OnKilled += gravitySystem.Remove;
HealthsContainer.OnKilled += orbitsSystem.Remove;
HealthsContainer.OnKilled += planetsStorage.RemovePlanet;
}
public GameSystemLoader(EntityWorld world,
// Single
LoadButtonConfigurationSystem loadButtonConfigurationSystem,
// Update
GravitySystem gravitySystem,
PhysicsSystem physicsSystem,
PlayerStateSystem playerStateSystem,
EntityCollisionSystem entityCollisionSystem,
LevelCollisionSystem levelCollisionSystem,
CameraSystem cameraSystem,
SpriteSystem spriteSystem,
HeartbeatSystem heartbeatSystem,
DebugSystem debugSystem,
DebugTextSystem debugTextSystem,
// Draw
RenderSystem renderSystem,
RenderLevelSystem renderLevelSystem,
RenderCollisionBoxSystem renderCollisionBoxSystem,
RenderTextSystem renderTextSystem,
RenderStaticGraphicSystem renderStaticGraphicSystem,
RenderLifeBarSystem renderLifeBarSystem)
: base(world)
{
// Single
_loadButtonConfigurationSystem = loadButtonConfigurationSystem;
// Update
_gravitySystem = gravitySystem;
_physicsSystem = physicsSystem;
_playerStateSystem = playerStateSystem;
_entityCollisionSystem = entityCollisionSystem;
_levelCollisionSystem = levelCollisionSystem;
_cameraSystem = cameraSystem;
_spriteSystem = spriteSystem;
_heartbeatSystem = heartbeatSystem;
_debugSystem = debugSystem;
_debugTextSystem = debugTextSystem;
// Draw
_renderSystem = renderSystem;
_renderLevelSystem = renderLevelSystem;
_renderCollisionBoxSystem = renderCollisionBoxSystem;
_renderTextSystem = renderTextSystem;
_renderStaticGraphicSystem = renderStaticGraphicSystem;
_renderLifeBarSystem = renderLifeBarSystem;
}
void FixedUpdate()
{
if (GS == null)
{
GS = FindObjectOfType <GravitySystem>();
return;
}
if (GS.gravityDirection == GravitySystem.GravityType.ToCenter)
{
m_Rigidbody2D.AddForce((center.transform.position - transform.position).normalized * GS.gravityForce);
}
else if (GS.gravityDirection == GravitySystem.GravityType.Down)
{
m_Rigidbody2D.AddForce(Vector3.down * GS.gravityForce);
}
}
private void Update()
{
currentSystem = player.GetCurrentSystem();
//Move to position
Vector3 focusPosition = middle;
focusPosition.z = transform.position.z;
focusPosition.x = Mathf.SmoothDamp(transform.position.x, focusPosition.x, ref smoothVelocityX, horizontalSmoothTime);
focusPosition.x = lockX ? 0 : focusPosition.x;
focusPosition.y = Mathf.SmoothDamp(transform.position.y, focusPosition.y, ref smoothVelocityY, verticalSmoothTime);
transform.position = (Vector3)focusPosition;
//Size
float oSize = Mathf.SmoothDamp(Camera.main.orthographicSize, newOSize, ref smoothVelocitySize, sizeSmoothTime, 1000, Time.fixedUnscaledDeltaTime);
Camera.main.orthographicSize = Mathf.Clamp(oSize, minimumSize, maximumSize);
}
private void Start()
{
//Orbit Prediction Setup
localStartPosition = transform.localPosition;
t0 = OrbitMath.GetT0(this);
//Collect ChildSystems
List <GravitySystem> systems = new List <GravitySystem>();
foreach (Transform child in transform)
{
GravitySystem system = child.GetComponent <GravitySystem>();
if (system)
{
systems.Add(system);
}
}
childSystems = systems.ToArray();
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
GravitySystem gravitySytem = (GravitySystem)target;
GUILayout.BeginHorizontal();
if (GUILayout.Button("SetUp System"))
{
gravitySytem.SetUp();
}
if (GUILayout.Button("Check System"))
{
gravitySytem.CheckSystem();
}
//gravitySytem.CheckSystem();
GUILayout.EndHorizontal();
}
// Update is called once per frame
void Update()
{
if (GS == null)
{
GS = FindObjectOfType <GravitySystem>();
}
if (GS.gravityDirection == GravitySystem.GravityType.ToCenter)
{
if (center == null)
{
center = (GameObject.FindGameObjectsWithTag("GravityCenter"))[0];
}
Vector3 gravityUp = (transform.position - center.transform.position).normalized;
Quaternion targetRotatoion = Quaternion.FromToRotation(transform.up, gravityUp) * transform.rotation;
transform.rotation = Quaternion.Slerp(transform.rotation, targetRotatoion, 50 * Time.deltaTime);
}
else if (GS.gravityDirection == GravitySystem.GravityType.Down)
{
transform.rotation = Quaternion.identity;
}
}
public RocketsMovementSystem(GravitySystem gravitySystem)
{
_gravitySystem = gravitySystem;
_rockets = new SortedList <int, Rocket>();
}
private void Start()
{
player = Player.instance;
currentSystem = player.GetCurrentSystem();
}
public void AddSystem(GravitySystem system)
{
system.transform.SetParent(transform);
}
private void Start()
{
_gravitySystem = new GravitySystem(_gravitySettings);
_gravitySystem.Add(_testPlanets);
_testRocket.velocity = _rocketStartVelocity;
}
public OrbitPrediction(float time, GravitySystem gs)
{
this.time = time;
this.localPosition = gs.transform.localPosition;
this.localVelocity = Vector2.zero;
}
