void MoveToTargetPosition() { if (this._visualArc) { long progress = FixedMath.Create(this.AliveTime) / 32; long height = this.arcStartHeight + this.arcStartVerticalSpeed.Mul(progress) - Gravity.Mul(progress.Mul(progress)); this.Position.z = height; } else { this.Position.z = FixedMath.MoveTowards(this.Position.z, TargetHeight, this.linearHeightSpeed); } LSProjectile.tempDirection = TargetPosition - this.Position.ToVector2d(); if (LSProjectile.tempDirection.Dot(this.lastDirection.x, this.lastDirection.y) < 0L || tempDirection == Vector2d.zero) { this.Hit(); //Debug.Log("asdf"); } else { //Debug.Log("asdf2"); LSProjectile.tempDirection.Normalize(); Forward = tempDirection; this.lastDirection = LSProjectile.tempDirection; LSProjectile.tempDirection *= this.speedPerFrame; this.Position.Add(LSProjectile.tempDirection.ToVector3d()); } }
public void Simulate() { this.AliveTime++; if (this.AliveTime > this.MaxDuration) { ProjectileManager.EndProjectile(this); return; } switch (this.TargetingBehavior) { case TargetingType.Timed: this.CountDown--; if (this.CountDown == 0) { this.Hit(); } break; case TargetingType.Homing: if (this._visualArc) { long progress = FixedMath.Create(this.AliveTime) / 32; long height = this.arcStartHeight + this.arcStartVerticalSpeed.Mul(progress) - Gravity.Mul(progress.Mul(progress)); this.Position.z = height; } else { this.TargetHeight = this.Target.Body.HeightPos + Target.Body.Height / 2; this.Position.z = FixedMath.MoveTowards(this.Position.z, TargetHeight, this.linearHeightSpeed); } if (this.CheckCollision()) { this.TargetPosition = this.Target.Body._position; this.Hit(); } else { LSProjectile.tempDirection = this.Target.Body._position - this.Position.ToVector2d(); if (LSProjectile.tempDirection.Dot(this.lastDirection.x, this.lastDirection.y) < 0L) { this.TargetPosition = this.Target.Body._position; this.Hit(); } else { LSProjectile.tempDirection.Normalize(); Forward = tempDirection; this.lastDirection = LSProjectile.tempDirection; LSProjectile.tempDirection *= this.speedPerFrame; this.Position.Add(LSProjectile.tempDirection.ToVector3d()); } } break; case TargetingType.Free: RaycastMove(this.Velocity); break; } }
public static int GenerateDeltaCount(int size) { long fixSize = FixedMath.Create(size); int ret = FixedMath.Mul(FixedMath.Mul(fixSize, fixSize), FixedMath.Pi).CeilToInt(); return(ret); }
public static void FixedNumberAngle(string label, ref long Value) { double roundedDisplay = 0; roundedDisplay = Math.Round(Math.Asin(Value.ToDouble()) * RadToDeg, 2, MidpointRounding.AwayFromZero); Value = FixedMath.Create(Math.Sin(DegToRad * EditorGUILayout.DoubleField(label, roundedDisplay))); }
public long GetHeight(int mapIndex, Vector2d position) { if (mapIndex >= Maps.Length) { return(this.HeightBounds.x); } HeightMap map = Maps[mapIndex]; long normX = (position.x - this._bottomLeft.x).Div(Interval); long normY = (position.y - this._bottomLeft.y).Div(Interval); int gridX = FixedMath.ToInt(normX); int gridY = FixedMath.ToInt(normY); long fractionX = (normX - FixedMath.Create(gridX)); long fractionY = (normY - FixedMath.Create(gridY)); long baseHeight = map.GetHeight(gridX, gridY); int nextX = Mathf.Clamp(gridX + 1, 0, map.Map.Width); int nextY = Mathf.Clamp(gridY + 1, 0, map.Map.Height); //bilinear lerp long h1 = FixedMath.Lerp(baseHeight, map.GetHeight(nextX, gridY), fractionX); long h2 = FixedMath.Lerp(map.GetHeight(gridX, nextY), map.GetHeight(nextX, nextY), fractionX); return(FixedMath.Lerp(h1, h2, fractionY) + this.BonusHeight); }
/// <summary> /// Tries to parse string into fixed point number. /// </summary> /// <returns><c>true</c>, if parse was tried, <c>false</c> otherwise.</returns> /// <param name="s">S.</param> /// <param name="result">Result.</param> public static bool TryParse(string s, out long result) { string[] NewValues = s.Split('.'); if (NewValues.Length <= 2) { long Whole; if (long.TryParse(NewValues[0], out Whole)) { if (NewValues.Length == 1) { result = Whole << SHIFT_AMOUNT; return(true); } else { long Numerator; if (long.TryParse(NewValues[1], out Numerator)) { int fractionDigits = NewValues[1].Length; long Denominator = 1; for (int i = 0; i < fractionDigits; i++) { Denominator *= 10; } result = (Whole << SHIFT_AMOUNT) + FixedMath.Create(Numerator, Denominator); return(true); } } } } result = 0; return(false); }
public void init(float x, float y, float halfx, float halfy) { m_Center.x = FixedMath.Create(x); m_Center.y = FixedMath.Create(y); m_Half.x = FixedMath.Create(halfx); m_Half.y = FixedMath.Create(halfy); setRotation((long)0); }
public void update(float x, float y, float halfx, float halfy) { m_Center.x = FixedMath.Create(x); m_Center.y = FixedMath.Create(y); m_Half.x = FixedMath.Create(halfx); m_Half.y = FixedMath.Create(halfy); init(m_Center, m_Half.x, m_Half.y); }
public static void FixedNumberField(string label, ref long Value, long max = 0) { var value = FixedMath.Create(EditorGUILayout.DoubleField(label, Math.Round(FixedMath.ToDouble(Value), 2, MidpointRounding.AwayFromZero))); if (max == 0 || value <= max) { Value = value; } else { Value = max; } }
protected override void OnLateInitialize() { long gridWidth = FixedMath.Create(GridManager.Width); long gridHeight = FixedMath.Create(GridManager.Height); long widthEdgeOffset = (gridWidth - _mapWidth) / 2; long heightEdgeOffset = (gridHeight - _mapHeight) / 2; Area gridArea = new Area( GridManager.OffsetX, GridManager.OffsetY, GridManager.OffsetX + gridWidth, GridManager.OffsetY + gridHeight ); Area noBlockArea = new Area( gridArea.XCorner1 + widthEdgeOffset, gridArea.YCorner1 + heightEdgeOffset, gridArea.XCorner2 - widthEdgeOffset, gridArea.YCorner2 - heightEdgeOffset ); //block top ManualBlocker.BlockArea(new Area( gridArea.XMin, noBlockArea.YMax, gridArea.XMax, gridArea.YMax )); //block bottom ManualBlocker.BlockArea(new Area( gridArea.XMin, gridArea.YMin, gridArea.XMax, noBlockArea.YMin )); //block right ManualBlocker.BlockArea(new Area( noBlockArea.XMax, noBlockArea.YMin, gridArea.XMax, noBlockArea.YMax )); //block left ManualBlocker.BlockArea(new Area( gridArea.XMin, noBlockArea.YMin, noBlockArea.XMin, noBlockArea.XMax )); }
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) { SerializedProperty angle = property.FindPropertyRelative("_angle"); SerializedProperty timescaled = property.FindPropertyRelative("_timescaled"); double scale = LSEditorUtility.Scale(timescaled.boolValue); angle.doubleValue = EditorGUILayout.DoubleField(label, angle.doubleValue * scale) / scale; timescaled.boolValue = EditorGUILayout.Toggle("Timescaled", timescaled.boolValue); double angleInRadians = angle.doubleValue * Math.PI / 180d; property.FindPropertyRelative("_cos").longValue = FixedMath.Create(Math.Cos(angleInRadians)); property.FindPropertyRelative("_sin").longValue = FixedMath.Create(Math.Sin(angleInRadians)); }
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) { double scale = ((FixedNumberAngleAttribute)this.attribute).Timescaled ? LockstepManager.FrameRate : 1; double angle = Math.Round(Math.Asin(property.longValue.ToDouble()) * RadToDeg, 2, MidpointRounding.AwayFromZero); angle = EditorGUI.DoubleField(position, label, angle * scale) / scale; double max = ((FixedNumberAngleAttribute)this.attribute).Max; if (max > 0 && angle > max) { angle = max; } property.longValue = FixedMath.Create(Math.Sin(DegToRad * angle)); }
// Update is called once per frame void FixedUpdate() { if (!m_bArrived) { if (!m_bFindPath) { m_MyPath.FastClear(); StartPos = new Vector2d(FixedMath.Create(transform.position.x), FixedMath.Create(transform.position.z)); EndPos = new Vector2d(FixedMath.Create(m_Destination.x), FixedMath.Create(m_Destination.z)); if (m_Blocker) { m_Blocker.RemoveAllCoordinates(); } ++m_SearchCount; if (Pathfinder.FindPath(StartPos, EndPos, m_MyPath)) { m_Index = 0; m_bFindPath = true; m_bArrivedMiddle = true; } else { m_bFindPath = false; m_bArrived = true; } if (m_Blocker) { m_Blocker.ReAddAllCoordinates(); } } if (m_bFindPath) { if (m_Index < m_MyPath.Count) { if (m_bArrivedMiddle) { m_Target = m_MyPath[m_Index]; ++m_Index; m_bArrivedMiddle = false; m_TargetPos = m_Target.ToVector3(transform.position.y); transform.LookAt(m_TargetPos); //GetComponent<Rigidbody>().velocity = transform.forward * 10; m_CurDis = Vector2.Distance(transform.position, m_TargetPos); m_LastDis = m_CurDis + 1.0f; } } } } }
public static void SetField(string name, float value, FieldType fieldType) { SerializedProperty prop = GetProperty(name); switch (fieldType) { case FieldType.FixedNumber: prop.longValue = FixedMath.Create(value); break; case FieldType.Interval: prop.intValue = Mathf.RoundToInt(value * LockstepManager.FrameRate); break; case FieldType.Rate: prop.intValue = Mathf.RoundToInt((1 / value) * LockstepManager.FrameRate); break; } Apply(); }
public short[,] Scan(int scanLayers) { int widthPeriods = Size.x.Div(Interval).CeilToInt(); int heightPeriods = Size.y.Div(Interval).CeilToInt(); short[,] heightMap = new short[widthPeriods, heightPeriods]; Vector3 startPos = _bottomLeft.ToVector3(HeightBounds.y.ToFloat()); Vector3 scanPos = startPos; float dist = (HeightBounds.y - HeightBounds.x).ToFloat(); float fRes = Interval.ToFloat(); for (int x = 0; x < widthPeriods; x++) { scanPos.z = startPos.z; for (int y = 0; y < heightPeriods; y++) { RaycastHit hit; long height; if (Physics.Raycast(scanPos, Vector3.down, out hit, dist, scanLayers, QueryTriggerInteraction.UseGlobal)) { height = FixedMath.Create(hit.point.y); } else { height = HeightBounds.x; } heightMap[x, y] = Compress(height); scanPos.z += fRes; } scanPos.x += fRes; } return(heightMap); }
public void setRotation(float rotation) { setRotation(FixedMath.Create(rotation)); }
public static long GetRandomOne() { return(FixedMath.Create(GetRandom(), int.MaxValue)); }
public Vector3d(int X, int Y, int Z) { this.x = FixedMath.Create(X); this.y = FixedMath.Create(Y); this.z = FixedMath.Create(Z); }
public Vector2dHeight(Vector3 vec3) { _x = FixedMath.Create(vec3.x); _y = FixedMath.Create(vec3.z); _height = vec3.y; }
public static void FixedNumberField(GUIContent content, ref long Value) { Value = FixedMath.Create(EditorGUILayout.DoubleField(content, Math.Round(FixedMath.ToDouble(Value), 2, MidpointRounding.AwayFromZero))); }
public static void DoubleField(Rect position, GUIContent label, ref long value, bool timescaled = false) { double scale = Scale(timescaled); value = FixedMath.Create(EditorGUI.DoubleField(position, label, value.ToDouble() * scale) / scale); }
public Vector2d(Vector3 vec) { this.x = FixedMath.Create(vec.x); this.y = FixedMath.Create(vec.z); }
public Vector2d(Vector2 vec2) { this.x = FixedMath.Create(vec2.x); this.y = FixedMath.Create(vec2.y); }
public long z; //Height public Vector3d(Vector3 vec3) { this.x = FixedMath.Create(vec3.x); this.y = FixedMath.Create(vec3.z); this.z = FixedMath.Create(vec3.y); }
public static long GetWorldY(int gridY) { return((FixedMath.Create(gridY + BoundY)) << AdditionalShiftSize); }
public static long GetRelativeY(long yPos) { return((yPos >> AdditionalShiftSize) - (FixedMath.Create(BoundY))); }
public GridSettings() { Init(256, 256, FixedMath.Create(-128), FixedMath.Create(-128), true); }
public Vector2d(float xFloat, float yFloat) { this.x = FixedMath.Create(xFloat); this.y = FixedMath.Create(yFloat); }
/// <summary> /// World pos to relative position on grid. /// </summary> /// <returns>The relative x.</returns> /// <param name="xPos">X position.</param> public static long GetRelativeX(long xPos) { return((xPos >> AdditionalShiftSize) - (FixedMath.Create(BoundX))); }
public Vector2d(double xDoub, double yDoub) { this.x = FixedMath.Create(xDoub); this.y = FixedMath.Create(yDoub); }