private void ShortDistanceNavigate(PlayerMove_Sail __instance)
{
VectorLF3 dir = target.GetDirection(__instance.player);
Sail.SetDir(__instance, dir);
VectorLF3 advisePoint = VectorLF3.zero;
if (AdvisePointIfOcclusion(__instance, ref advisePoint, shortNavUncoverRange))
{
#if DEBUG
ModDebug.Log("Planet Navigate ToAdvisePoint:" + advisePoint);
#endif
dir = (advisePoint - __instance.player.uPosition).normalized;
Sail.SetDir(__instance, dir);
Sail.TrySpeedUp(this, __instance);
}
else
{
if (Target.IsFocusingNormalized(dir, __instance.player.uVelocity.normalized))
{
#if DEBUG
ModDebug.Log("Short Navigate - Speed Up");
#endif
Sail.TrySpeedUp(this, __instance);
}
else
{
#if DEBUG
ModDebug.Log("Short Navigate - No Speed Up");
#endif
}
}
}
void Update()
{
if (player != null)
{
if (Input.GetKeyDown(KeyCode.F1))
{
playerScale = playerScale * 2.0f;
player.gameObject.transform.localScale = playerScale;
}
else if (Input.GetKeyDown(KeyCode.F2))
{
playerScale = playerScale / 2.0f;
player.gameObject.transform.localScale = playerScale;
}
else if (Input.GetKeyDown(KeyCode.F3))
{
GameObject PlayerObject = Instantiate(player.gameObject);
}
}
if (GIRerInit)
{
GIRer.Update();
}
}
private void MoveInterpolated(Snapshot previous, Snapshot current, float ratio)
{
Vector3 previousRelativePosition = GetRelativePosition(previous);
Vector3 currentRelativePosition = GetRelativePosition(current);
Vector3 previousAbsolutePosition = GetAbsolutePosition(previous);
Vector3 currentAbsolutePosition = GetAbsolutePosition(current);
float deltaPosition = Vector3.Distance(previousRelativePosition, currentRelativePosition);
Vector3 velocity = (previousRelativePosition - currentRelativePosition) / (previous.Timestamp - current.Timestamp);
/*
* 170 is round about where vanilla warping starts, for better testing lower this to something like 30
* then you can trigger the warping animation by sailing at around 300
* when its at 170 you will probably not be able to see the effect ingame
*/
if (deltaPosition >= 170 && rootWarp != null)
{
rootWarp.startWarp();
}
else if (deltaPosition < 170 && rootWarp != null && rootWarp.warpState >= 0.9)
{
rootWarp.stopWarp();
}
rootWarp.updateVelocity(velocity);
localPlanetId = current.LocalPlanetId;
rootTransform.position = Vector3.Lerp(previousRelativePosition, currentRelativePosition, ratio);
rootTransform.rotation = Quaternion.Slerp(previous.Rotation, current.Rotation, ratio);
bodyTransform.rotation = Quaternion.Slerp(previous.BodyRotation, current.BodyRotation, ratio);
absolutePosition = Vector3.Lerp(previousAbsolutePosition, currentAbsolutePosition, ratio);
}
public VectorLF3 GetIntersection(Line3D line)
{
double rhs = VectorLF3.Dot(__normal, __ponit) - VectorLF3.Dot(__normal, line.src);
double lhs = rhs / VectorLF3.Dot(__normal, line.dir);
return(line.src + (line.dir * lhs));
}
public VectorLF3 GetAnyPoint()
{
VectorLF3 point = VectorLF3.zero;
System.Random rand = new System.Random();
do
{
double r1 = rand.NextDouble() * 1000;
double r2 = rand.NextDouble() * 1000;
double rhs = normal.x * (ponit.x - r1) + normal.y * (ponit.y - r2) + normal.z * ponit.z;
if (-0.00000001 < rhs && rhs < 0.00000001)
{
continue;
}
double r3 = rhs / normal.z;
point.x = r1;
point.y = r2;
point.z = r3;
break;
} while (true);
return(point);
}
public VectorLF3 GetIntersection(Line3D line)
{
#if LEGACY
double rhs = VectorLF3.Dot(__normal, __ponit) - VectorLF3.Dot(__normal, line.src);
#else
double rhs = VectorLF3.Dot(normal, (ponit - line.src));
#endif
double lhs = rhs / VectorLF3.Dot(normal, line.dir);
return(line.src + (line.dir * lhs));
}
public static bool IsOrbitReachable(EjectorComponent ejector, DysonSwarm swarm, AstroPose[] astroPoses, int orbitId)
{
if (!IsOrbitValid(orbitId, swarm))
{
return(false);
}
int planetIndex = ejector.planetId / 100 * 100;
float num4 = ejector.localAlt + ejector.pivotY + (ejector.muzzleY - ejector.pivotY) / Mathf.Max(0.1f, Mathf.Sqrt(1f - ejector.localDir.y * ejector.localDir.y));
Vector3 vector = new Vector3(ejector.localPosN.x * num4, ejector.localPosN.y * num4, ejector.localPosN.z * num4);
VectorLF3 vectorLF = astroPoses[ejector.planetId].uPos + Maths.QRotateLF(astroPoses[ejector.planetId].uRot, vector);
Quaternion q = astroPoses[ejector.planetId].uRot * ejector.localRot;
VectorLF3 uPos = astroPoses[planetIndex].uPos;
VectorLF3 b = uPos - vectorLF;
VectorLF3 vectorLF2 = uPos + VectorLF3.Cross(swarm.orbits[orbitId].up, b).normalized *(double)swarm.orbits[orbitId].radius;
VectorLF3 vec = vectorLF2 - vectorLF;
var targetDist = vec.magnitude;
vec.x /= targetDist;
vec.y /= targetDist;
vec.z /= targetDist;
Vector3 vector2 = Maths.QInvRotate(q, vec);
if ((double)vector2.y < 0.08715574 || vector2.y > 0.8660254f)
{
return(false);
}
for (int i = planetIndex + 1; i <= ejector.planetId + 2; i++)
{
if (i != ejector.planetId)
{
double num5 = (double)astroPoses[i].uRadius;
if (num5 > 1.0)
{
VectorLF3 vectorLF3 = astroPoses[i].uPos - vectorLF;
double num6 = vectorLF3.x * vectorLF3.x + vectorLF3.y * vectorLF3.y + vectorLF3.z * vectorLF3.z;
double num7 = vectorLF3.x * vec.x + vectorLF3.y * vec.y + vectorLF3.z * vec.z;
if (num7 > 0.0)
{
double num8 = num6 - num7 * num7;
num5 += 120.0;
if (num8 < num5 * num5)
{
return(false);
}
}
}
}
}
return(true);
}
private Vector3 GetRelativePosition(Snapshot snapshot)
{
// If we are on a local planet and the remote player is on the same local planet, we use the LocalPlanetPosition that is more precise.
if (GameMain.localPlanet != null && GameMain.localPlanet.id == snapshot.LocalPlanetId)
{
return(snapshot.LocalPlanetPosition.ToUnity());
}
// If the remote player is in space, we need to calculate the remote player relative position from our local player position.
VectorLF3 uPosition = new VectorLF3(snapshot.UPosition.x, snapshot.UPosition.y, snapshot.UPosition.z);
return(Maths.QInvRotateLF(GameMain.data.relativeRot, uPosition - GameMain.data.relativePos));
}
public static void OnGameLoadCompleted()
{
if (Initialized == false)
{
return;
}
Log.Info("Game has finished loading");
// Assign our own color
UpdatePlayerColor(LocalPlayer.PlayerId, LocalPlayer.Data.Color);
// Change player location from spawn to the last known
VectorLF3 UPosition = new VectorLF3(LocalPlayer.Data.UPosition.x, LocalPlayer.Data.UPosition.y, LocalPlayer.Data.UPosition.z);
if (UPosition != VectorLF3.zero)
{
GameMain.mainPlayer.planetId = LocalPlayer.Data.LocalPlanetId;
if (LocalPlayer.Data.LocalPlanetId == -1)
{
GameMain.mainPlayer.uPosition = UPosition;
}
else
{
GameMain.mainPlayer.position = LocalPlayer.Data.LocalPlanetPosition.ToUnity();
GameMain.mainPlayer.uPosition = new VectorLF3(GameMain.localPlanet.uPosition.x + GameMain.mainPlayer.position.x, GameMain.localPlanet.uPosition.y + GameMain.mainPlayer.position.y, GameMain.localPlanet.uPosition.z + GameMain.mainPlayer.position.z);
}
GameMain.mainPlayer.uRotation = Quaternion.Euler(LocalPlayer.Data.Rotation.ToUnity());
//Load player's saved data from the last session.
AccessTools.Property(typeof(Player), "package").SetValue(GameMain.mainPlayer, LocalPlayer.Data.Mecha.Inventory, null);
GameMain.mainPlayer.mecha.forge = LocalPlayer.Data.Mecha.Forge;
GameMain.mainPlayer.mecha.coreEnergy = LocalPlayer.Data.Mecha.CoreEnergy;
GameMain.mainPlayer.mecha.reactorEnergy = LocalPlayer.Data.Mecha.ReactorEnergy;
GameMain.mainPlayer.mecha.reactorStorage = LocalPlayer.Data.Mecha.ReactorStorage;
GameMain.mainPlayer.mecha.warpStorage = LocalPlayer.Data.Mecha.WarpStorage;
//Fix references that brokes during import
AccessTools.Property(typeof(MechaForge), "mecha").SetValue(GameMain.mainPlayer.mecha.forge, GameMain.mainPlayer.mecha, null);
AccessTools.Property(typeof(MechaForge), "player").SetValue(GameMain.mainPlayer.mecha.forge, GameMain.mainPlayer, null);
GameMain.mainPlayer.mecha.forge.gameHistory = GameMain.data.history;
//Update player's Mecha tech bonuses
LocalPlayer.Data.Mecha.TechBonuses.UpdateMech(GameMain.mainPlayer.mecha);
}
LocalPlayer.SetReady();
IsGameLoaded = true;
}
public void PlanetNavigation(PlayerMove_Sail __instance)
{
ModDebug.Assert(IsCurNavPlanet());
player = __instance.player;
if (IsCurNavPlanet())
{
double distance = (target.TargetPlanet.uPosition - __instance.player.uPosition).magnitude;
if ((enableLocalWrap &&
distance > localWrapMinDistance &&
distance > (target.TargetPlanet.realRadius + longNavUncoverRange))
||
target.IsLocalStarPlanet() == false)
{
PlanetData localPlanet = GameMain.localPlanet;
if (localPlanet != null &&
target.TargetPlanet != null &&
localPlanet.id != target.TargetPlanet.id)
{
#if DEBUG
ModDebug.Log("Leave Local Planet");
#endif
VectorLF3 dir = (__instance.player.uPosition - localPlanet.uPosition).normalized;
Sail.SetDir(__instance, dir);
}
else
{
#if DEBUG
ModDebug.Log("Local Long Distance Navigation");
#endif
LongDistanceNavigate(__instance);
}
}
else
{
#if DEBUG
ModDebug.Log("Local Short Distance Navigation");
#endif
ShortDistanceNavigate(__instance);
}
}
else
{
Arrive();
#if DEBUG
ModDebug.Error("PlanetNavigation - No Target");
#endif
}
}
private bool CheckCollision(List <VectorLF3> pts, VectorLF3 pt, double min_dist)
{
double num1 = min_dist * min_dist;
foreach (VectorLF3 pt1 in pts)
{
double num2 = pt.x - pt1.x;
double num3 = pt.y - pt1.y;
double num4 = pt.z - pt1.z;
if (num2 * num2 + num3 * num3 + num4 * num4 < num1)
{
return(true);
}
}
return(false);
}
private void Start()
{
rootTransform = GetComponent <Transform>();
bodyTransform = rootTransform.Find("Model");
localPlanetId = -1;
absolutePosition = Vector3.zero;
#if DEBUG
positionDebugger = GameObject.CreatePrimitive(PrimitiveType.Sphere);
GameObject.Destroy(positionDebugger.GetComponent <SphereCollider>());
positionDebugger.transform.SetParent(rootTransform, false);
positionDebugger.transform.localScale = Vector3.one * 30;
positionDebugger.GetComponent <MeshRenderer>().material = null;
positionDebugger.SetActive(false);
#endif
}
private void MoveInterpolated(Snapshot previous, Snapshot current, float ratio)
{
Vector3 previousRelativePosition = GetRelativePosition(previous);
Vector3 currentRelativePosition = GetRelativePosition(current);
Vector3 previousAbsolutePosition = GetAbsolutePosition(previous);
Vector3 currentAbsolutePosition = GetAbsolutePosition(current);
float deltaPosition = Vector3.Distance(previousRelativePosition, currentRelativePosition);
Vector3 velocity = (previousRelativePosition - currentRelativePosition) / (previous.Timestamp - current.Timestamp);
localPlanetId = current.LocalPlanetId;
rootTransform.position = Vector3.Lerp(previousRelativePosition, currentRelativePosition, ratio);
rootTransform.rotation = Quaternion.Slerp(previous.Rotation, current.Rotation, ratio);
bodyTransform.rotation = Quaternion.Slerp(previous.BodyRotation, current.BodyRotation, ratio);
absolutePosition = Vector3.Lerp(previousAbsolutePosition, currentAbsolutePosition, ratio);
}
public void StarNavigation(PlayerMove_Sail __instance)
{
ModDebug.Assert(IsCurNavStar());
player = __instance.player;
if (IsCurNavStar())
{
PlanetData localPlanet = GameMain.localPlanet;
if (localPlanet != null)
{
#if DEBUG
ModDebug.Log("Leave Local Planet");
#endif
VectorLF3 dir = (__instance.player.uPosition - localPlanet.uPosition).normalized;
Sail.SetDir(__instance, dir);
return;
}
else
{
if (DetermineArrive() && IsCloseToNearStar(__instance))
{
#if DEBUG
ModDebug.Log("StarNavigation Arrive");
#endif
Arrive();
Warp.TryLeaveWarp(__instance);
return;
}
else
{
LongDistanceNavigate(__instance);
return;
}
}
}
else
{
Arrive();
#if DEBUG
ModDebug.Error("StarNavigation - No Target");
#endif
}
}
public VectorLF3 GetDirection(Player __instance)
{
VectorLF3 dir = VectorLF3.zero;
if (TargetPlanet != null)
{
dir = (TargetPlanet.uPosition - __instance.uPosition).normalized;
}
else if (TargetStar != null)
{
dir = (TargetStar.uPosition - __instance.uPosition).normalized;
}
else
{
ModDebug.Error("GetDirection while no target!!!");
}
return(dir);
}
public VectorLF3 GetDir(AutoStellarNavigation __this, Player __instance)
{
VectorLF3 dir = VectorLF3.zero;
if (__this.IsCurNavStar())
{
dir = (TargetStar.uPosition - __instance.uPosition).normalized;
}
else if (__this.IsCurNavPlanet())
{
dir = (TargetPlanet.uPosition - __instance.uPosition).normalized;
}
else
{
ModDebug.Error("GetDir While No Target!!!");
}
return(dir);
}
public void PlanetNavigation(PlayerMove_Sail __instance)
{
ModDebug.Assert(IsCurNavPlanet);
player = __instance.player;
if (!IsCurNavPlanet)
{
Arrive();
#if DEBUG
ModDebug.Error("Planet navigation - Error target");
#endif
return;
}
if (NeedLocalLongDistanceNavigate(__instance))
{
PlanetData localPlanet = GameMain.localPlanet;
if (localPlanet != null &&
target.TargetPlanet != null &&
localPlanet.id != target.TargetPlanet.id)
{
#if DEBUG
ModDebug.Log("Leave Local Planet");
#endif
VectorLF3 dir = (__instance.player.uPosition - localPlanet.uPosition).normalized;
Sail.SetDir(__instance, dir);
}
else
{
#if DEBUG
ModDebug.Log("Local Long Distance Navigation");
#endif
LongDistanceNavigate(__instance);
}
return;
}
#if DEBUG
ModDebug.Log("Local Short Distance Navigation");
#endif
ShortDistanceNavigate(__instance);
}
private static VectorLF3 GetRelativeRotatedPlanetPos(StarData starData, PlanetData pData, ref bool isMoon)
{
VectorLF3 pos;
VectorLF3 dir;
Quaternion quaternion;
if (pData.orbitAroundPlanet != null)
{
VectorLF3 centerPos = GetRelativeRotatedPlanetPos(starData, pData.orbitAroundPlanet, ref isMoon);
isMoon = true;
pos = new VectorLF3(Mathf.Cos(pData.orbitPhase) * pData.orbitRadius * orbitScaler * 8 + centerPos.x, centerPos.y, Mathf.Sin(pData.orbitPhase) * pData.orbitRadius * orbitScaler * 8 + centerPos.z);
quaternion = Quaternion.Euler(pData.orbitInclination, pData.orbitInclination, pData.orbitInclination);
dir = quaternion * (pos - centerPos);
return(dir + centerPos);
}
pos = new VectorLF3(Mathf.Cos(pData.orbitPhase) * pData.orbitRadius * orbitScaler + starData.position.x, starData.position.y, Mathf.Sin(pData.orbitPhase) * pData.orbitRadius * orbitScaler + starData.position.z);
quaternion = Quaternion.Euler(pData.orbitInclination, pData.orbitInclination, pData.orbitInclination);
dir = quaternion * (pos - starData.position);
return(dir + starData.position);
}
public static void GameTick_Postfix(GameData __instance, long time)
{
if (!SimulatedWorld.Initialized || LocalPlayer.IsMasterClient)
{
if (SimulatedWorld.Initialized)
{
StationUIManager.DecreaseCooldown();
}
return;
}
// call StationComponent::InternalTickRemote() from here, see StationComponent_Patch.cs for info
int timeGene = (int)(time % 60L);
if (timeGene < 0)
{
timeGene += 60;
}
float dt = 0.016666668f;
GameHistoryData history = GameMain.history;
float shipSailSpeed = history.logisticShipSailSpeedModified;
float shipWarpSpeed = (!history.logisticShipWarpDrive) ? shipSailSpeed : history.logisticShipWarpSpeedModified;
int shipCarries = history.logisticShipCarries;
StationComponent[] gStationPool = __instance.galacticTransport.stationPool;
AstroPose[] astroPoses = __instance.galaxy.astroPoses;
VectorLF3 relativePos = __instance.relativePos;
Quaternion relativeRot = __instance.relativeRot;
bool starmap = UIGame.viewMode == EViewMode.Starmap;
foreach (StationComponent stationComponent in GameMain.data.galacticTransport.stationPool)
{
if (stationComponent != null && stationComponent.isStellar)
{
//Debug.Log("enter " + stationComponent.gid + " (" + GameMain.galaxy.PlanetById(stationComponent.planetId).displayName + ")");
StationComponent_Transpiler.ILSUpdateShipPos(stationComponent, timeGene, dt, shipSailSpeed, shipWarpSpeed, shipCarries, gStationPool, astroPoses, relativePos, relativeRot, starmap, null);
}
}
}
private double NearestPlanetDistance(PlayerMove_Sail __instance)
{
StarData localStar = GameMain.localStar;
double distance = (localStar.planets[0].uPosition - __instance.player.uPosition).magnitude;
//Distance set negative when local star is null
if (localStar == null)
{
return(-10.0);
}
for (int index = 0; index < localStar.planetCount; ++index)
{
PlanetData planet = localStar.planets[index];
VectorLF3 vectorLf3 = planet.uPosition - __instance.player.uPosition;
double magnitude = vectorLf3.magnitude;
if (magnitude < distance)
{
distance = magnitude;
}
}
return(distance);
}
public bool AdvisePointIfOcclusion(PlayerMove_Sail __instance, ref VectorLF3 advisePoint, double radiusOffest)
{
bool navPlanet = false;
bool navStar = false;
StarData localStar = GameMain.localStar;
VectorLF3 srcPoint = __instance.player.uPosition;
VectorLF3 dstPoint = VectorLF3.zero;
if (IsCurNavStar)
{
navStar = true;
dstPoint = target.TargetStar.uPosition;
}
else if (IsCurNavPlanet)
{
navPlanet = true;
dstPoint = target.TargetPlanet.uPosition;
}
else
{
ModDebug.Error("AdvisePointIfOcclusion When No Navigate!!!");
return(false);
}
bool hit = false;
Math.Line3D hitPlaneVertical = new Math.Line3D();
double uncoverRadius = 0;
Math.Line3D line = new Math.Line3D(srcPoint, dstPoint);
Math.Plane3D plane = new Math.Plane3D();
plane.normal = line.dir;
if (localStar != null)
{
//Planet occlusion
for (int index = 0; index < localStar.planetCount; ++index)
{
PlanetData planet = localStar.planets[index];
plane.ponit = planet.uPosition;
if (plane.IsParallel(line) == false)
{
//Target planet
if (navPlanet && planet.id == target.TargetPlanet.id)
{
continue;
}
VectorLF3 intersection = plane.GetIntersection(line);
double minHitRange = planet.realRadius + radiusOffest;
if (intersection.Distance(planet.uPosition) < minHitRange &&
intersection.Distance(srcPoint) + intersection.Distance(dstPoint) <= (dstPoint.Distance(srcPoint) + 0.1))
{
hit = true;
//Maximum radius plane
if (minHitRange > uncoverRadius)
{
uncoverRadius = minHitRange;
hitPlaneVertical.src = planet.uPosition;
if (planet.uPosition != intersection)
{
hitPlaneVertical.dst = intersection;
}
//Rare case
else
{
hitPlaneVertical.dst = plane.GetAnyPoint();
}
}
}
}
}
///Star occlusion
StarData star = localStar;
plane.ponit = star.uPosition;
//Target star
if (navStar && star.id == target.TargetStar.id)
{
}
else
{
if (plane.IsParallel(line) == false)
{
VectorLF3 intersection = plane.GetIntersection(line);
double minHitRange = star.physicsRadius + radiusOffest;
if (intersection.Distance(star.uPosition) < minHitRange)
{
hit = true;
//Maximum radius plane
if (minHitRange > uncoverRadius)
{
uncoverRadius = minHitRange;
hitPlaneVertical.src = star.uPosition;
if (star.uPosition != intersection)
{
hitPlaneVertical.dst = intersection;
}
//Rare case
else
{
hitPlaneVertical.dst = plane.GetAnyPoint();
}
}
}
}
}
}
if (hit)
{
#if DEBUG
ModDebug.Log("AdvisePointIfOcclusion Hit");
#endif
VectorLF3 uncoverOrbitPoint = hitPlaneVertical.src + (hitPlaneVertical.dir * (uncoverRadius + 10));
Math.Line3D uncoverLine = new Math.Line3D(dstPoint, uncoverOrbitPoint);
plane.normal = uncoverLine.dir;
plane.ponit = srcPoint;
advisePoint = plane.GetIntersection(uncoverLine);
}
return(hit);
}
private void RandomPoses(
int seed,
int maxCount,
double minDist,
double minStepLen,
double maxStepLen,
double flatten)
{
Random random = new Random(seed);
double num1 = random.NextDouble();
this.tmp_poses.Add(VectorLF3.zero);
int num2 = 6;
int num3 = 8;
if (num2 < 1)
{
num2 = 1;
}
if (num3 < 1)
{
num3 = 1;
}
int num4 = (int)(num1 * (double)(num3 - num2) + (double)num2);
for (int index = 0; index < num4; ++index)
{
int num5 = 0;
while (num5++ < 256)
{
double num6 = random.NextDouble() * 2.0 - 1.0;
double num7 = (random.NextDouble() * 2.0 - 1.0) * flatten;
double num8 = random.NextDouble() * 2.0 - 1.0;
double num9 = random.NextDouble();
double d = num6 * num6 + num7 * num7 + num8 * num8;
if (d <= 1.0 && d >= 1E-08)
{
double num10 = Math.Sqrt(d);
double num11 = (num9 * (maxStepLen - minStepLen) + minDist) / num10;
VectorLF3 pt = new VectorLF3(num6 * num11, num7 * num11, num8 * num11);
if (!this.CheckCollision(this.tmp_poses, pt, minDist))
{
this.tmp_drunk.Add(pt);
this.tmp_poses.Add(pt);
if (this.tmp_poses.Count >= maxCount)
{
return;
}
break;
}
}
}
}
int num12 = 0;
while (num12++ < 256)
{
for (int index = 0; index < this.tmp_drunk.Count; ++index)
{
if (random.NextDouble() <= 0.7)
{
int num5 = 0;
while (num5++ < 256)
{
double num6 = random.NextDouble() * 2.0 - 1.0;
double num7 = (random.NextDouble() * 2.0 - 1.0) * flatten;
double num8 = random.NextDouble() * 2.0 - 1.0;
double num9 = random.NextDouble();
double d = num6 * num6 + num7 * num7 + num8 * num8;
if (d <= 1.0 && d >= 1E-08)
{
double num10 = Math.Sqrt(d);
double num11 = (num9 * (maxStepLen - minStepLen) + minDist) / num10;
VectorLF3 pt = new VectorLF3(this.tmp_drunk[index].x + num6 * num11, this.tmp_drunk[index].y + num7 * num11, this.tmp_drunk[index].z + num8 * num11);
if (!this.CheckCollision(this.tmp_poses, pt, minDist))
{
this.tmp_drunk[index] = pt;
this.tmp_poses.Add(pt);
if (this.tmp_poses.Count >= maxCount)
{
return;
}
break;
}
}
}
}
}
}
}
public static bool UpdateUniversalPosition(ref PlanetSimulator __instance, ref StarSimulator ___star, ref bool ___isLocal, ref Transform ___lookCamera, Vector3 playerLPos, VectorLF3 playerUPos, Vector3 cameraPos)
{
if (__instance.planetData == null || __instance.planetData.loading || __instance.planetData.factoryLoading)
{
return(false);
}
__instance.SetLayers();
var localPlanet = GameMain.localPlanet;
var flag1 = ___isLocal != (localPlanet == __instance.planetData);
___isLocal = localPlanet == __instance.planetData;
var flag2 = PlanetSimulator.sOptionCastShadow != __instance.optionCastShadow;
if (flag1 || flag2)
{
foreach (var renderer in __instance.surfaceRenderer)
{
renderer.receiveShadows = ___isLocal;
renderer.shadowCastingMode = !___isLocal || !PlanetSimulator.sOptionCastShadow
? ShadowCastingMode.Off
: ShadowCastingMode.On;
}
__instance.optionCastShadow = PlanetSimulator.sOptionCastShadow;
}
__instance.reformRenderer.receiveShadows = ___isLocal;
var flag3 = ___isLocal && __instance.planetData.type != EPlanetType.Gas;
if (__instance.sphereCollider.enabled == flag3)
{
foreach (var collider in __instance.surfaceCollider)
{
collider.enabled = flag3;
}
if (__instance.oceanCollider != null)
{
__instance.oceanCollider.enabled = flag3;
}
__instance.sphereCollider.enabled = !flag3;
}
var uPosition = __instance.planetData.uPosition;
var quaternion = Quaternion.identity;
VectorLF3 vectorLf3;
if (localPlanet != null)
{
quaternion = localPlanet.runtimeRotation;
if (localPlanet == __instance.planetData)
{
vectorLf3 = VectorLF3.zero;
}
else
{
var v = uPosition - localPlanet.uPosition;
vectorLf3 = Maths.QInvRotateLF(quaternion, v);
}
}
else
{
vectorLf3 = uPosition - playerUPos;
}
var vscale = 1f;
Vector3 vpos;
UniverseSimulator.VirtualMapping(vectorLf3.x, vectorLf3.y, vectorLf3.z, cameraPos, out vpos, out vscale);
var vector3_1 = Vector3.one * vscale;
if (__instance.transform.localPosition != vpos)
{
__instance.transform.localPosition = vpos;
}
if (__instance.planetData == localPlanet)
{
if (__instance.transform.localPosition.sqrMagnitude > 0.0)
{
__instance.transform.localPosition = Vector3.zero;
}
if (__instance.transform.localRotation != Quaternion.identity)
{
__instance.transform.localRotation = Quaternion.identity;
}
}
else
{
__instance.transform.localRotation =
Quaternion.Inverse(quaternion) * __instance.planetData.runtimeRotation;
}
if (__instance.transform.localScale != vector3_1)
{
__instance.transform.localScale = vector3_1;
}
var vector3_2 = Quaternion.Inverse(quaternion) *
(__instance.planetData.star.uPosition - __instance.planetData.uPosition).normalized;
var lhs = ___lookCamera.localPosition - __instance.transform.localPosition;
var magnitude = lhs.magnitude;
var localRotation = __instance.transform.localRotation;
var vector4_1 = new Vector4(localRotation.x, localRotation.y, localRotation.z, localRotation.w);
if (__instance.surfaceRenderer != null && __instance.surfaceRenderer.Length > 0)
{
var sharedMaterial = __instance.surfaceRenderer[0].sharedMaterial;
sharedMaterial.SetVector("_SunDir", vector3_2);
sharedMaterial.SetVector("_Rotation",
new Vector4(localRotation.x, localRotation.y, localRotation.z, localRotation.w));
sharedMaterial.SetFloat("_Distance", magnitude);
}
if (__instance.reformRenderer != null &&
__instance.reformMat != null && __instance.planetData.factory != null)
{
var platformSystem = __instance.planetData.factory.platformSystem;
var reformOffsetsBuffer = platformSystem.reformOffsetsBuffer;
var reformDataBuffer = platformSystem.reformDataBuffer;
__instance.reformMat.SetFloat("_LatitudeCount", platformSystem.latitudeCount);
__instance.reformMat.SetVector("_SunDir", vector3_2);
__instance.reformMat.SetFloat("_Distance", magnitude);
__instance.reformMat.SetVector("_Rotation", vector4_1);
if (platformSystem.reformData != null && reformDataBuffer != null)
{
reformOffsetsBuffer.SetData(platformSystem.reformOffsets);
reformDataBuffer.SetData(platformSystem.reformData);
__instance.reformMat.SetBuffer("_OffsetsBuffer", reformOffsetsBuffer);
__instance.reformMat.SetBuffer("_DataBuffer", reformDataBuffer);
}
}
if (!(__instance.atmoTrans0 != null))
{
return(false);
}
__instance.atmoTrans0.rotation = ___lookCamera.localRotation;
Vector4 vector4_2 = !(GameCamera.generalTarget == null)
? GameCamera.generalTarget.position
: Vector3.zero;
// ********************************* Fix Here for release :)
var positionOffset = 0;
if (localPlanet != null)
{
if (localPlanet.type != EPlanetType.Gas)
{
positionOffset = Mathf.RoundToInt(Mathf.Abs(localPlanet.radius - 200) / 2);
}
}
Patch.Debug("positionOffset " + positionOffset, LogLevel.Debug, Patch.DebugAtmoBlur);
__instance.atmoTrans1.localPosition = new Vector3(0, 0,
Mathf.Clamp(Vector3.Dot(lhs, ___lookCamera.forward) + 10f / __instance.planetData.GetScaleFactored(), 0.0f, Math.Max(320f, 320f * __instance.planetData.GetScaleFactored())));
var num1 = Mathf.Clamp01(8000f * __instance.planetData.GetScaleFactored() / magnitude);
var num2 = Mathf.Clamp01(4000f * __instance.planetData.GetScaleFactored() / magnitude);
var atmoMatRadiusParam = __instance.atmoMatRadiusParam;
atmoMatRadiusParam.z = atmoMatRadiusParam.x +
(float)((__instance.atmoMatRadiusParam.z - (double)__instance.atmoMatRadiusParam.x) *
(2.70000004768372 - num2 * 1.70000004768372));
Patch.Debug("__instance.atmoTrans1 " + __instance.atmoTrans1.localScale, LogLevel.Debug, Patch.DebugAtmoBlur);
var vector4_3 = atmoMatRadiusParam * vscale * __instance.planetData.GetScaleFactored();
Patch.Debug("vector4_3 " + __instance.planetData.name + vector4_3, LogLevel.Debug, Patch.DebugAtmoBlur);
__instance.atmoMat.SetVector("_PlanetPos", __instance.transform.localPosition);
__instance.atmoMat.SetVector("_SunDir", vector3_2);
__instance.atmoMat.SetVector("_PlanetRadius", vector4_3);
__instance.atmoMat.SetColor("_Color4", ___star.sunAtmosColor);
__instance.atmoMat.SetColor("_Sky4", ___star.sunriseAtmosColor);
__instance.atmoMat.SetVector("_LocalPos", vector4_2);
__instance.atmoMat.SetFloat("_SunRiseScatterPower",
Mathf.Max(60f * __instance.planetData.GetScaleFactored(),
(float)((magnitude - __instance.planetData.realRadius * 2.0) * 0.180000007152557)));
__instance.atmoMat.SetFloat("_IntensityControl", num1);
__instance.atmoMat.renderQueue = __instance.planetData != localPlanet ? 2989 : 2991;
return(false);
}
private static void ShowSolarSystem(UIVirtualStarmap starmap, int starIndex)
{
// start planet compute thread if not done already
PlanetModelingManager.StartPlanetComputeThread();
// add star
StarData starData = starmap._galaxyData.StarById(starIndex + 1); // because StarById() decrements by 1
AddStarToStarmap(starmap, starData);
starmap.clickText = starData.id.ToString();
Debug.Log("Setting it to " + starmap.clickText + " " + starData.id);
for (int i = 0; i < starData.planetCount; i++)
{
// add planets
PlanetData pData = starData.planets[i];
Color color = starmap.neutronStarColor;
float scaleFactor = 0.6f;
bool isMoon = false;
VectorLF3 pPos = GetRelativeRotatedPlanetPos(starData, pData, ref isMoon);
// request generation of planet surface data to display its details when clicked and if not already loaded
if (!pData.loaded)
{
PlanetModelingManager.RequestLoadPlanet(pData);
}
// create fake StarData to pass _OnLateUpdate()
StarData dummyStarData = new StarData
{
position = pPos,
color = starData.color,
id = pData.id
};
Vector3 scale = (pData.realRadius / 100) * scaleFactor * Vector3.one;
if (scale.x > 3 || scale.y > 3 || scale.z > 3)
{
scale = new Vector3(3, 3, 3);
}
starmap.starPool[i + 1].active = true;
starmap.starPool[i + 1].starData = dummyStarData;
starmap.starPool[i + 1].pointRenderer.material.SetColor("_TintColor", color);
starmap.starPool[i + 1].pointRenderer.transform.localPosition = pPos;
starmap.starPool[i + 1].pointRenderer.transform.localScale = scale;
starmap.starPool[i + 1].pointRenderer.gameObject.SetActive(true);
starmap.starPool[i + 1].nameText.text = pData.displayName + " (" + pData.typeString + ")";
starmap.starPool[i + 1].nameText.color = Color.Lerp(color, Color.white, 0.5f);
starmap.starPool[i + 1].nameText.rectTransform.sizeDelta = new Vector2(starmap.starPool[i + 1].nameText.preferredWidth, starmap.starPool[i + 1].nameText.preferredHeight);
starmap.starPool[i + 1].nameText.rectTransform.anchoredPosition = new Vector2(-2000f, -2000f);
starmap.starPool[i + 1].textContent = pData.displayName + " (" + pData.typeString + ")";
starmap.starPool[i + 1].nameText.gameObject.SetActive(true);
// add orbit renderer
starmap.connPool[i].active = true;
starmap.connPool[i].lineRenderer.material.SetColor("_LineColorA", Color.Lerp(color, Color.white, 0.65f));
if (starmap.connPool[i].lineRenderer.positionCount != 61)
{
starmap.connPool[i].lineRenderer.positionCount = 61;
}
for (int j = 0; j < 61; j++)
{
float f = (float)j * 0.017453292f * 6f; // ty dsp devs :D
Vector3 cPos = GetCenterOfOrbit(starData, pData, ref isMoon);
Vector3 position;
if (isMoon)
{
position = new Vector3(Mathf.Cos(f) * pData.orbitRadius * orbitScaler * 8 + (float)cPos.x, cPos.y, Mathf.Sin(f) * pData.orbitRadius * orbitScaler * 8 + (float)cPos.z);
}
else
{
position = new Vector3(Mathf.Cos(f) * pData.orbitRadius * orbitScaler + (float)cPos.x, cPos.y, Mathf.Sin(f) * pData.orbitRadius * orbitScaler + (float)cPos.z);
}
// rotate position around center by orbit angle
Quaternion quaternion = Quaternion.Euler(pData.orbitInclination, pData.orbitInclination, pData.orbitInclination);
Vector3 dir = quaternion * (position - cPos);
position = dir + cPos;
starmap.connPool[i].lineRenderer.SetPosition(j, position);
}
starmap.connPool[i].lineRenderer.gameObject.SetActive(true);
}
}
public static void CreateStar(ref GalaxyData galaxy, ref VectorLF3 pos, ref int id, int seed, ref EStarType needtype, ref ESpectrType needSpectr, ref StarData __result)
{
//Console.WriteLine($"CreateStar() id: {__result.id}\r\n\tage: {__result.age}\r\n\tclassFactor: {__result.classFactor}\r\n\tcolor: {__result.color}\r\n\tluminosity: {__result.luminosity}\r\n\tradius: {__result.radius}\r\n\ttemperature: {__result.temperature}\r\n\tspectr: {__result.spectr}\r\n\tlifetime: {__result.lifetime}\r\n\tlightBalanceRaddius: {__result.lightBalanceRadius}\r\n\ttype: {__result.type}");
}
public static bool IsFocusing(VectorLF3 lineL, VectorLF3 lineR)
{
return(IsFocusingNormalized(lineL.normalized, lineR.normalized));
}
public static bool IsFocusingNormalized(VectorLF3 dirL, VectorLF3 dirR)
{
return((dirL - dirR).magnitude < s_FocusParam);
}
public static bool InternalTickRemote_Prefix(StationComponent __instance, int timeGene, double dt, float shipSailSpeed, float shipWarpSpeed, int shipCarries, StationComponent[] gStationPool, AstroPose[] astroPoses, VectorLF3 relativePos, Quaternion relativeRot, bool starmap, int[] consumeRegister)
{
if (Multiplayer.IsActive && !Multiplayer.Session.LocalPlayer.IsHost)
{
// skip vanilla code entirely and use our modified version instead (which focuses on ship movement)
// call our InternalTickRemote() for every StationComponent in game. Normally this would be done by each PlanetFactory, but as a client
// we dont have every PlanetFactory at hand.
// so iterate over the GameMain.data.galacticTransport.stationPool array which should also include the fake entries for factories we have not loaded yet.
// but do this at another place to not trigger it more often than needed (GameData::GameTick())
return(false);
}
return(true);
}
public static void SetDir(PlayerMove_Sail __instance, VectorLF3 dir) => __instance.sailPoser.targetURot = Quaternion.LookRotation(dir);
private void LongDistanceNavigate(PlayerMove_Sail __instance)
{
VectorLF3 dir = target.GetDirection(__instance.player);
Sail.SetDir(__instance, dir);
VectorLF3 advisePoint = VectorLF3.zero;
if (AdvisePointIfOcclusion(__instance, ref advisePoint, longNavUncoverRange))
{
#if DEBUG
ModDebug.Log("LongDistanceNavigate - ToAdvisePoint:" + advisePoint);
#endif
dir = (advisePoint - __instance.player.uPosition).normalized;
Sail.SetDir(__instance, dir);
Sail.TrySpeedUp(this, __instance);
}
else if (Target.IsFocusingNormalized(dir, __instance.player.uVelocity.normalized) && !__instance.player.warping)
{
if (__instance.player.mecha.coreEnergy >= wrapEnergylimit && Warp.TryWrap(this, __instance))
{
#if DEBUG
ModDebug.Log("Enter Wrap");
#endif
return;
}
else if (IsCurNavPlanet && target.IsLocalStarPlanet == true)
{
#if DEBUG
ModDebug.Log("Local Planet Navigate No Wrap Chance SpeedUp");
#endif
Sail.TrySpeedUp(this, __instance);
return;
}
else if (LongDistanceNavigateNeedSpeedUp())
{
#if DEBUG
ModDebug.Log("Long Distance Navigate Need SpeedUp");
#endif
Sail.TrySpeedUp(this, __instance);
}
else
{
#if DEBUG
ModDebug.Log("Long Distance Navigate No SpeedUp And Warp");
#endif
}
}
bool LongDistanceNavigateNeedSpeedUp()
{
if (__instance.player.mecha.coreEnergy >= speedUpEnergylimit)
{
if (__instance.player.mecha.thrusterLevel < THRUSTER_LEVEL_WARP)
{
return(true);
}
//else if (Warp.GetWarperCount(__instance) <= 0)
else if (!Warp.HasWarper(__instance))
{
return(true);
}
return(true);
}
//Prepare warp
if (__instance.player.mecha.coreEnergy < wrapEnergylimit)
{
return(false);
}
return(false);
}
}
