public void ServerOnPlayerSwitchGrenadeType(uint playerId)
{
var playerObjectComponent = PlayerObjectSystem.Instance.FindPlayerObjectComponent(playerId);
if (playerObjectComponent == null)
{
return;
}
var grenadeSlots = playerObjectComponent.State.GrenadeSlots;
for (var iOffset = 1; iOffset < grenadeSlots.Length; iOffset++)
{
var grenadeSlotIndex = MathfExtensions.Wrap(
playerObjectComponent.State.CurrentGrenadeSlotIndex + iOffset,
0,
grenadeSlots.Length - 1
);
var grenadeSlot = grenadeSlots[grenadeSlotIndex];
if (grenadeSlot.GrenadeCount > 0)
{
playerObjectComponent.State.CurrentGrenadeSlotIndex = (byte)grenadeSlotIndex;
}
}
}
public virtual IEnumerator MoveRoutine(List <Bullet> bullets)
{
List <BulletEntry> bulletEntries = new List <BulletEntry>();
foreach (Bullet bullet in bullets)
{
BulletEntry bulletEntry = new BulletEntry(bullet);
if (bulletEntry.yMoveDirection != 0)
{
Retarget(bullet, Vector3.up * bulletEntry.yMoveDirection);
bulletEntries.Add(bulletEntry);
}
}
while (bulletEntries.Count > 0)
{
for (int i = 0; i < bulletEntries.Count; i++)
{
BulletEntry bulletEntry = (BulletEntry)bulletEntries[i];
if (MathfExtensions.Sign(GameManager.GetSingleton <PlayerMouse>().trs.position.y - bulletEntry.bullet.trs.position.y) != bulletEntry.yMoveDirection)
{
bulletEntries.RemoveAt(i);
i--;
}
}
yield return(new WaitForEndOfFrame());
}
foreach (Bullet bullet in bullets)
{
Retarget(bullet);
}
}
public static Vector2 GetVelocity(SteeringAgent2D agent, float feelerLength)
{
var feelers = CreateFeelers(agent, feelerLength);
Vector2 steeringForce = Vector2.zero;
foreach (var feeler in feelers)
{
int currentWallIndex = 0;
int closestWallIndex = -1;
float distToThisIP = 0f;
float distToClosestIP = float.MaxValue;
Vector2 point = Vector2.zero;
Vector2 closestIP = Vector2.zero;
Vector2 feelerSteeringForce = Vector2.zero;
foreach (var wall in World2D.Instance.Walls)
{
try {
Vector2 feelerFrom = agent.transform.position;
Vector2 feelerTo = feeler;
//if (MathfExtensions.SegmentIntersection2D(feelerFrom, feelerTo, wall.From, wall.To, out distToThisIP, out point)) {
if (MathfExtensions.LineSegementsIntersect(feelerFrom, feelerTo, wall.From, wall.To, out point))
{
distToThisIP = (feelerFrom - point).magnitude;
if (distToThisIP < distToClosestIP)
{
distToClosestIP = distToThisIP;
closestWallIndex = currentWallIndex;
closestIP = point;
}
}
currentWallIndex++;
} catch {
//Do nothing
}
} //Next wall
if (closestWallIndex >= 0)
{
Vector2 overShoot = (feeler - closestIP) * agent.Rigidbody2D.velocity.magnitude;
var closestWall = World2D.Instance.Walls[closestWallIndex];
var feelerDirection = feeler - agent.Rigidbody2D.position;
if (Vector2.Angle(feelerDirection, closestWall.Normal) > 90)
{
feelerSteeringForce = closestWall.Normal * overShoot.magnitude;
}
else
{
feelerSteeringForce = closestWall.InverseNormal * overShoot.magnitude;
}
}
steeringForce += feelerSteeringForce;
} //Next feeler
return(steeringForce);
}
private AnimationCurve CreateNewEasingCurve(Ease ease, int timesteps)
{
if (timesteps <= 0)
{
return(null);
}
EaseFunction easeFunction = EaseManager.ToEaseFunction(ease);
var curve = new AnimationCurve();
// Adds all the required keys
for (int i = 0; i < timesteps; i++)
{
float time = MathfExtensions.Remap(i, 0, timesteps, 0, Duration);
var result = EaseManager.Evaluate(ease, easeFunction, time, Duration, EaseOvershoot, EasePeriod);
curve.AddKey(time, result);
}
#if UNITY_EDITOR
// Set the tangent mode to Clamped Auto for all keys
for (int i = 0; i < curve.length; i++)
{
var tangentMode = AnimationUtility.TangentMode.Linear;
AnimationUtility.SetKeyLeftTangentMode(curve, i, tangentMode);
AnimationUtility.SetKeyRightTangentMode(curve, i, tangentMode);
}
#endif
return(curve);
}
public static Quaternion GetMouseRotationInput(float mouseSensitivity = 2f, float minTiltAngle = -75f, float maxTiltAngle = 45f)
{
float mouseX = Input.GetAxis("Mouse X");
float mouseY = Input.GetAxis("Mouse Y");
if (Input.GetMouseButtonDown(1))
{
move = false;
}
if (Input.GetMouseButtonUp(1))
{
move = true;
}
if (!move)
{
mouseX = 0;
mouseY = 0;
}
// Adjust the look angle (Y Rotation)
lookAngle += mouseX * mouseSensitivity;
lookAngle %= 360f;
// Adjust the tilt angle (X Rotation)
tiltAngle += mouseY * mouseSensitivity;
tiltAngle %= 360f;
tiltAngle = MathfExtensions.ClampAngle(tiltAngle, minTiltAngle, maxTiltAngle);
var controlRotation = Quaternion.Euler(/*20f*/ -tiltAngle, lookAngle, 0f);
return(controlRotation);
}
public void DoUpdate()
{
foreach (NoteMaker noteMaker in noteMakers)
{
midPoint = new Vector2();
foreach (Transform trs in noteMaker.transforms)
{
midPoint += (Vector2)trs.position;
}
midPoint /= noteMaker.transforms.Length;
if ((noteMaker.positionOfPreviousNote - midPoint).sqrMagnitude > worldDistanceBetweenNotesSqr)
{
noteFrequency = GetNoteFromPosition(midPoint);
noteFrequency = Mathf.Lerp(noteGroup.noteFrequencies[0], noteGroup.noteFrequencies[noteGroup.noteFrequencies.Length - 1], noteFrequency);
noteFrequency = MathfExtensions.GetClosestNumber(noteFrequency, noteGroup.noteFrequencies) * multiplyNoteFrequency;
noteMaker.positionOfPreviousNote = midPoint;
audioSource.volume = 0;
position = 0;
if (!stream)
{
AudioClip audioClip = AudioClip.Create("Note", (int)(sampleRate * noteNormalizedFrequencyOverTime.keys[noteNormalizedFrequencyOverTime.keys.Length - 1].time), 1, sampleRate, false, OnAudioRead, OnAudioSetPosition);
audioSource.clip = audioClip;
audioSource.Play();
}
timeOfLastNote = Time.time;
}
}
audioSource.volume = noteVolumeOverTime.Evaluate(Time.time - timeOfLastNote);
targetFrequency = noteFrequency * noteNormalizedFrequencyOverTime.Evaluate(Time.time - timeOfLastNote);
frequency = Mathf.Lerp(frequency, targetFrequency, frequencyLerpRate * Time.deltaTime);
}
private void IdentifyGift()
{
ResourceType resourceType = default;
int addingValue = 0;
if (Random.Range(0f, 1f) < Mediator.Instance.GameConfig.EnergyDropChance)
{
resourceType = ResourceType.Energy;
}
_surpriseImage.sprite = resourceType == ResourceType.Chips ? _chipsSprite : _energySprite;
addingValue = resourceType == ResourceType.Chips ? MathfExtensions.RoundTenDigit(Mediator.Instance.GameConfig.RangeChipValue.GetRandomValue()) : Mediator.Instance.GameConfig.RangeEnergyValue.GetRandomValue();
_surpriseImage.GetComponentInChildren <Text>().text = addingValue.ToString();
if (resourceType == ResourceType.Chips)
{
Mediator.Instance.ResourcesStorage.Chips.AddResources(addingValue);
}
else if (resourceType == ResourceType.Energy)
{
Mediator.Instance.ResourcesStorage.Energy.AddResources(addingValue);
}
_isGettedSurprise = true;
}
public static void TwoBoneIk(
Transform bone1Transform, float bone1Length, Transform bone2Transform, float bone2Length,
Vector3 targetPosition, Vector3 elbowTargetPosition, bool getPositiveAngleSolution
)
{
// Get thetas.
var targetOffsetFromBone1 = targetPosition - bone1Transform.position;
var targetDistanceFromBone1 = targetOffsetFromBone1.magnitude;
float theta1InRadians, theta2InRadians;
MathfExtensions.GetTwoBoneIkAngles(
bone1Length, bone2Length, targetDistanceFromBone1, getPositiveAngleSolution,
out theta1InRadians, out theta2InRadians
);
// Rotate bone1 to point to the target, and point the up vector towards the elbow target.
var elbowTargetOffsetFromBone1 = elbowTargetPosition - bone1Transform.position;
var lookAtUpDirection = Vector3Extensions.Reject(elbowTargetOffsetFromBone1, targetOffsetFromBone1);
bone1Transform.LookAt(targetPosition, lookAtUpDirection);
// Apply thetas.
bone1Transform.Rotate(-Vector3.right, Mathf.Rad2Deg * theta1InRadians, Space.Self);
bone2Transform.localRotation = Quaternion.AngleAxis(Mathf.Rad2Deg * theta2InRadians, -Vector3.right);
}
public virtual void Update()
{
#endif
if (snapValues.Length > 0)
{
slider.value = MathfExtensions.GetClosestNumber(slider.value, snapValues);
}
}
public virtual void OnValueChanged(float value)
{
if (snapValues.Length > 0)
{
slider.value = MathfExtensions.GetClosestNumber(value, snapValues);
}
SetDisplayValue();
}
public virtual void HandleMouseInput()
{
if (InputManager.UsingGamepad)
{
return;
}
if (!leftClickInput && previousLeftClickInput && !controllingWithJoystick)
{
inControlMode = false;
}
foreach (_Selectable selectable in selectables)
{
if (currentSelected != selectable && IsMousedOverSelectable(selectable) && CanSelectSelectable(selectable))
{
ChangeSelected(selectable);
return;
}
}
if (leftClickInput)
{
if (currentInputField != null)
{
currentInputField.readOnly = true;
}
_Slider slider = currentSelected.GetComponent <_Slider>();
if (slider != null)
{
Vector2 closestPointToMouseCanvasNormalized = new Vector2();
if (currentSelected.canvas.renderMode == RenderMode.ScreenSpaceOverlay)
{
if (selectable != null)
{
closestPointToMouseCanvasNormalized = slider.slidingArea.GetRectInCanvasNormalized(selectable.canvasRectTrs).ClosestPoint(slider.canvasRectTrs.GetWorldRect().ToNormalizedPosition(InputManager.GetMousePosition(MathfExtensions.NULL_INT)));
}
}
else if (selectable != null)
{
closestPointToMouseCanvasNormalized = slider.slidingArea.GetRectInCanvasNormalized(selectable.canvasRectTrs).ClosestPoint(slider.canvasRectTrs.GetWorldRect().ToNormalizedPosition(selectable.canvas.worldCamera.ScreenToWorldPoint(InputManager.GetMousePosition(MathfExtensions.NULL_INT))));
}
float normalizedValue = slider.slidingArea.GetRectInCanvasNormalized(slider.canvasRectTrs).ToNormalizedPosition(closestPointToMouseCanvasNormalized).x;
slider.slider.value = Mathf.Lerp(slider.slider.minValue, slider.slider.maxValue, normalizedValue);
if (slider.snapValues.Length > 0)
{
slider.slider.value = MathfExtensions.GetClosestNumber(slider.slider.value, slider.snapValues);
}
}
else
{
InputField inputField = currentSelected.GetComponent <InputField>();
if (inputField != null)
{
currentInputField = inputField;
currentInputField.readOnly = false;
}
}
}
}
private void CalculateSecondAttackPos(Vector2Int finishMovePos)
{
var xDistance = finishMovePos.x - NextTargetPos.x;
var yDistance = finishMovePos.y - NextTargetPos.y;
var secondPosX = NextTargetPos.x - MathfExtensions.GetSign(xDistance);
var secondPosY = NextTargetPos.y - MathfExtensions.GetSign(yDistance);
secondTargetPos = new Vector2Int(secondPosX, secondPosY);
}
public void ApplyGravity(bool isGrounded = false)
{
if (!isGrounded)
{
this.currentVerticalSpeed =
MathfExtensions.ApplyGravity(this.VerticalSpeed, this.GravitySettings.GravityStrength, this.GravitySettings.MaxFallSpeed);
}
else
{
this.currentVerticalSpeed = -this.GravitySettings.GroundedGravityForce;
}
}
public virtual void Awake ()
{
#if UNITY_EDITOR
if (!Application.isPlaying)
return;
#endif
if (displayValue != null)
initDisplayValue = displayValue.text;
SetDisplayValue ();
if (snapValues.Length > 0)
indexOfCurrentSnapValue = MathfExtensions.GetIndexOfClosestNumber(slider.value, snapValues);
}
public virtual void HandleMouseInput()
{
bool justCanceledControlMode = false;
if (Input.GetMouseButtonUp(0) && !controllingWithJoystick)
{
inControlMode = false;
justCanceledControlMode = true;
}
foreach (_Selectable selectable in selectables)
{
if (IsMousedOverSelectable(selectable))
{
if (justCanceledControlMode || currentSelected != selectable)
{
ChangeSelected(selectable);
return;
}
}
}
if (Input.GetMouseButton(0))
{
_Slider slider = currentSelected.GetComponent <_Slider>();
if (slider != null)
{
Vector2 closestPointToMouseCanvasNormalized = new Vector2();
if (currentSelected.canvas.renderMode == RenderMode.ScreenSpaceOverlay)
{
if (selectable != null)
{
closestPointToMouseCanvasNormalized = slider.slidingArea.GetRectInCanvasNormalized(selectable.canvasRectTrs).ClosestPoint(slider.canvasRectTrs.GetRectInWorld().ToNormalizedPosition(Input.mousePosition));
}
}
else
{
if (selectable != null)
{
closestPointToMouseCanvasNormalized = slider.slidingArea.GetRectInCanvasNormalized(selectable.canvasRectTrs).ClosestPoint(slider.canvasRectTrs.GetRectInWorld().ToNormalizedPosition(Camera.main.ScreenToWorldPoint(Input.mousePosition)));
}
}
float normalizedValue = slider.slidingArea.GetRectInCanvasNormalized(slider.canvasRectTrs).ToNormalizedPosition(closestPointToMouseCanvasNormalized).x;
slider.slider.value = Mathf.Lerp(slider.slider.minValue, slider.slider.maxValue, normalizedValue);
if (slider.snapValues.Length > 0)
{
slider.slider.value = MathfExtensions.GetClosestNumber(slider.slider.value, slider.snapValues);
}
}
}
}
public void FlipTowards(Transform trs)
{
Vector2 toTrs = trs.position - transform.position;
if (MathfExtensions.AreOppositeSigns(facing.x, toTrs.x))
{
spriteRenderer.flipX = !spriteRenderer.flipX;
facing.x *= -1;
}
if (MathfExtensions.AreOppositeSigns(facing.y, toTrs.y))
{
spriteRenderer.flipY = !spriteRenderer.flipY;
facing.y *= -1;
}
}
private void Update()
{
if (rotating)
{
return;
}
Vector3 localMovement = new Vector2();
if (Input.GetKey(KeyCode.W) || Input.GetKey(KeyCode.UpArrow))
{
localMovement.z += panSpeed;
}
if (Input.GetKey(KeyCode.S) || Input.GetKey(KeyCode.DownArrow))
{
localMovement.z -= panSpeed;
}
if (Input.GetKey(KeyCode.A) || Input.GetKey(KeyCode.LeftArrow))
{
localMovement.x -= panSpeed;
}
if (Input.GetKey(KeyCode.D) || Input.GetKey(KeyCode.RightArrow))
{
localMovement.x += panSpeed;
}
Vector3 worldMovement = transform.TransformDirection(localMovement);
transform.position = MathfExtensions.Clamp(worldMovement + transform.position, minCamera, maxCamera);
if (Input.GetKeyDown(KeyCode.Q))
{
Rotate(-90);
}
if (Input.GetKeyDown(KeyCode.E))
{
Rotate(90);
}
if (Input.mouseScrollDelta.y > 0 || Input.GetKeyDown(KeyCode.R) || Input.GetKeyDown(KeyCode.Plus) || Input.GetKeyDown(KeyCode.KeypadPlus))
{
Zoom(-zoomAmount);
}
if (Input.mouseScrollDelta.y < 0 || Input.GetKeyDown(KeyCode.F) || Input.GetKeyDown(KeyCode.Minus) || Input.GetKeyDown(KeyCode.KeypadMinus))
{
Zoom(zoomAmount);
}
}
public IEnumerable <Ray> ShotRays(WeaponDefinition weaponDefinition, Ray aimRay)
{
if (weaponDefinition.Type == WeaponType.Shotgun)
{
for (var i = 0; i < OsFps.ShotgunBulletsPerShot; i++)
{
var currentShotRay = MathfExtensions.GetRandomRayInCone(aimRay, weaponDefinition.ShotConeAngleInDegrees);
yield return(currentShotRay);
}
}
else
{
var shotRay = MathfExtensions.GetRandomRayInCone(aimRay, weaponDefinition.ShotConeAngleInDegrees);
yield return(shotRay);
}
}
public void Init(RewardType rewardType = RewardType.Daily, int chipsCountReward = 0)
{
ShowRewardText(rewardType);
if (chipsCountReward == 0)
{
RangeValueInt chipsRewardRange = Mediator.Instance.GameConfig.RangeChipValue;
_chipsReward = MathfExtensions.RoundTenDigit(Random.Range(chipsRewardRange.Min, chipsRewardRange.Max));
}
else
{
_chipsReward = chipsCountReward;
}
_chipsCountField.text = _chipsReward.ToString();
}
public static Quaternion GetMouseRotationInput(float mouseSensitivity = 3f, float minTiltAngle = -75f, float maxTiltAngle = 45f)
{
float mouseX = Input.GetAxis("Mouse X");
float mouseY = Input.GetAxis("Mouse Y");
// Adjust the look angle (Y Rotation)
lookAngle += mouseX * mouseSensitivity;
lookAngle %= 360f;
// Adjust the tilt angle (X Rotation)
tiltAngle += mouseY * mouseSensitivity;
tiltAngle %= 360f;
tiltAngle = MathfExtensions.ClampAngle(tiltAngle, minTiltAngle, maxTiltAngle);
var controlRotation = Quaternion.Euler(-tiltAngle, lookAngle, 0f);
return(controlRotation);
}
public virtual void Awake()
{
#if UNITY_EDITOR
if (!Application.isPlaying)
{
return;
}
#endif
if (displayValue != null)
{
initDisplayValue = displayValue.text;
}
SetDisplayValue();
if (snapValues.Length > 0)
{
indexOfCurrentSnapValue = MathfExtensions.GetIndexOfClosestNumber(slider.value, snapValues);
}
slider.onValueChanged.AddListener(delegate { OnValueChanged(slider.value); });
}
private void ClientUpdateThisPlayer(Client client, PlayerObjectComponent playerObjectComponent)
{
var playerObjectState = playerObjectComponent.State;
playerObjectState.Input = GetCurrentPlayersInput();
var unscaledDeltaMouse = new Vector2(Input.GetAxis("Mouse X"), Input.GetAxis("Mouse Y"));
var deltaMouse = client.GetMouseSensitivityForZoomLevel() * unscaledDeltaMouse;
playerObjectState.LookDirAngles = new Vector2(
Mathf.Clamp(MathfExtensions.ToSignedAngleDegrees(playerObjectState.LookDirAngles.x - deltaMouse.y), -90, 90),
Mathf.Repeat(playerObjectState.LookDirAngles.y + deltaMouse.x, 360)
);
if (Input.GetButtonDown("Reload") && playerObjectState.CanReload)
{
client.Reload(playerObjectComponent);
}
if (playerObjectState.Input.IsFirePressed)
{
var wasTriggerJustPulled = Input.GetButtonDown("Fire");
if (
playerObjectState.CanTryToFireWeapon &&
(wasTriggerJustPulled || playerObjectState.CurrentWeapon.Definition.IsAutomatic)
)
{
ClientPlayerTryToShoot(client, playerObjectComponent);
}
}
if (Input.GetButtonDown("Throw Grenade") && playerObjectState.CanThrowGrenade)
{
ClientThrowGrenade(client, playerObjectState);
}
if (Input.GetButtonDown("Switch Grenade"))
{
ClientSwitchGrenadeType(client, playerObjectState);
}
}
void ReshapeTract(float deltaTime)
{
float amount = deltaTime * movementSpeed;
int newLastObstruction = -1;
for (int i = 0; i < n; i++)
{
float diam = diameter[i];
float targetDiam = targetDiameter[i];
if (diam <= 0)
{
newLastObstruction = i;
}
float slowReturn;
if (i < noseStart)
{
slowReturn = 0.6f;
}
else if (i >= tipStart)
{
slowReturn = 1.0f;
}
else
{
slowReturn = 0.6f + 0.4f * (i - noseStart) / (tipStart - noseStart);
}
diameter[i] = MathfExtensions.MoveTowards(diam, targetDiam, slowReturn * amount, 2.0f * amount);
}
if (lastObstruction > -1.0 && Mathf.Abs(newLastObstruction - -1.0f) < EPSILON && noseA[0] < 0.05f)
{
AddTransient(lastObstruction);
}
lastObstruction = newLastObstruction;
amount = deltaTime * movementSpeed;
noseDiameter[0] = MathfExtensions.MoveTowards(noseDiameter[0], velumTarget, amount * 0.25f, amount * 0.1f);
noseA[0] = noseDiameter[0] * noseDiameter[0];
}
void Update()
{
timerValue = toggleTimer.GetValue();
if (!Application.isPlaying)
{
HandleSetActive();
return;
}
float timeRemaining = timerValue;
if (toggleTimer.changeAmountMultiplier > 0)
{
timeRemaining = toggleTimer.value.max - timerValue;
}
if (timeRemaining > 1)
{
timerText.text = "" + MathfExtensions.RoundToInterval(timeRemaining, 1f);
}
else
{
timerText.text = "" + MathfExtensions.RoundToInterval(timeRemaining, .1f);
}
HandleSetActive();
}
public BulletEntry(Bullet bullet)
{
this.bullet = bullet;
yMoveDirection = MathfExtensions.Sign(GameManager.GetSingleton <PlayerMouse>().trs.position.y - bullet.trs.position.y);
}
public void OnEnable()
{
if (combineEntries.Length == 0)
{
return;
}
KeyValuePair <Mesh, Transform>[] meshesAndTransforms = new KeyValuePair <Mesh, Transform> [combineEntries.Length];
CombineInstance[] combineInstances = new CombineInstance[combineEntries.Length];
for (int i = 0; i < combineEntries.Length; i++)
{
CombineEntry combineEntry = combineEntries[i];
meshesAndTransforms[i] = new KeyValuePair <Mesh, Transform>(combineEntry.meshFilter.sharedMesh, combineEntry.trs);
CombineInstance combineInstance = combineInstances[i];
combineInstance.mesh = Instantiate(combineEntry.meshFilter.sharedMesh);
combineInstance.transform = combineEntry.trs.localToWorldMatrix;
combineEntry.trs.gameObject.SetActive(false);
combineInstances[i] = combineInstance;
}
for (int i = 0; i < meshesAndTransforms.Length; i++)
{
KeyValuePair <Mesh, Transform> meshAndTransform = meshesAndTransforms[i];
for (int i2 = 0; i2 < meshesAndTransforms.Length; i2++)
{
KeyValuePair <Mesh, Transform> otherMeshAndTransform = meshesAndTransforms[i2];
Vector3 toOtherTrs = otherMeshAndTransform.Value.position - meshAndTransform.Value.position;
if (toOtherTrs.sqrMagnitude == 1)
{
MeshExtensions.MeshTriangle[] meshTriangles = MeshExtensions.GetMeshTriangles(new KeyValuePair <Mesh, Transform>[1] {
meshAndTransform
});
MeshExtensions.MeshTriangle[] otherMeshTriangles = MeshExtensions.GetMeshTriangles(new KeyValuePair <Mesh, Transform>[1] {
otherMeshAndTransform
});
int toOtherTrsXSign = MathfExtensions.Sign(toOtherTrs.x);
int toOtherTrsYSign = MathfExtensions.Sign(toOtherTrs.y);
int toOtherTrsZSign = MathfExtensions.Sign(toOtherTrs.z);
if (toOtherTrsXSign != 0)
{
for (int i3 = 0; i3 < meshTriangles.Length; i3++)
{
MeshExtensions.MeshTriangle meshTriangle = meshTriangles[i3];
if (Mathf.Sign(meshTriangle.point1.x - meshAndTransform.Value.position.x) == toOtherTrsXSign && Mathf.Sign(meshTriangle.point2.x - meshAndTransform.Value.position.x) == toOtherTrsXSign && Mathf.Sign(meshTriangle.point3.x - meshAndTransform.Value.position.x) == toOtherTrsXSign)
{
meshTriangle.RemoveFromMesh();
for (int i4 = 0; i4 < meshTriangles.Length; i4++)
{
if (meshTriangles[i4].triangleIndex > meshTriangle.triangleIndex)
{
meshTriangles[i4].triangleIndex--;
}
}
}
}
for (int i3 = 0; i3 < otherMeshTriangles.Length; i3++)
{
MeshExtensions.MeshTriangle meshTriangle = otherMeshTriangles[i3];
if (Mathf.Sign(meshTriangle.point1.x - otherMeshAndTransform.Value.position.x) == -toOtherTrsXSign && Mathf.Sign(meshTriangle.point2.x - otherMeshAndTransform.Value.position.x) == -toOtherTrsXSign && Mathf.Sign(meshTriangle.point3.x - otherMeshAndTransform.Value.position.x) == -toOtherTrsXSign)
{
meshTriangle.RemoveFromMesh();
for (int i4 = 0; i4 < otherMeshTriangles.Length; i4++)
{
if (otherMeshTriangles[i4].triangleIndex > meshTriangle.triangleIndex)
{
otherMeshTriangles[i4].triangleIndex--;
}
}
}
}
}
else if (toOtherTrsYSign != 0)
{
for (int i3 = 0; i3 < meshTriangles.Length; i3++)
{
MeshExtensions.MeshTriangle meshTriangle = meshTriangles[i3];
if (Mathf.Sign(meshTriangle.point1.y - meshAndTransform.Value.position.y) == toOtherTrsYSign && Mathf.Sign(meshTriangle.point2.y - meshAndTransform.Value.position.y) == toOtherTrsYSign && Mathf.Sign(meshTriangle.point3.y - meshAndTransform.Value.position.y) == toOtherTrsYSign)
{
meshTriangle.RemoveFromMesh();
for (int i4 = 0; i4 < meshTriangles.Length; i4++)
{
if (meshTriangles[i4].triangleIndex > meshTriangle.triangleIndex)
{
meshTriangles[i4].triangleIndex--;
}
}
}
}
for (int i3 = 0; i3 < otherMeshTriangles.Length; i3++)
{
MeshExtensions.MeshTriangle meshTriangle = otherMeshTriangles[i3];
if (Mathf.Sign(meshTriangle.point1.y - otherMeshAndTransform.Value.position.y) == -toOtherTrsYSign && Mathf.Sign(meshTriangle.point2.y - otherMeshAndTransform.Value.position.y) == -toOtherTrsYSign && Mathf.Sign(meshTriangle.point3.y - otherMeshAndTransform.Value.position.y) == -toOtherTrsYSign)
{
meshTriangle.RemoveFromMesh();
for (int i4 = 0; i4 < otherMeshTriangles.Length; i4++)
{
if (otherMeshTriangles[i4].triangleIndex > meshTriangle.triangleIndex)
{
otherMeshTriangles[i4].triangleIndex--;
}
}
}
}
}
else
{
for (int i3 = 0; i3 < meshTriangles.Length; i3++)
{
MeshExtensions.MeshTriangle meshTriangle = meshTriangles[i3];
if (Mathf.Sign(meshTriangle.point1.z - meshAndTransform.Value.position.z) == toOtherTrsZSign && Mathf.Sign(meshTriangle.point2.z - meshAndTransform.Value.position.z) == toOtherTrsZSign && Mathf.Sign(meshTriangle.point3.z - meshAndTransform.Value.position.z) == toOtherTrsZSign)
{
meshTriangle.RemoveFromMesh();
for (int i4 = 0; i4 < meshTriangles.Length; i4++)
{
if (meshTriangles[i4].triangleIndex > meshTriangle.triangleIndex)
{
meshTriangles[i4].triangleIndex--;
}
}
}
}
for (int i3 = 0; i3 < otherMeshTriangles.Length; i3++)
{
MeshExtensions.MeshTriangle meshTriangle = otherMeshTriangles[i3];
if (Mathf.Sign(meshTriangle.point1.z - otherMeshAndTransform.Value.position.z) == -toOtherTrsZSign && Mathf.Sign(meshTriangle.point2.z - otherMeshAndTransform.Value.position.z) == -toOtherTrsZSign && Mathf.Sign(meshTriangle.point3.z - otherMeshAndTransform.Value.position.z) == -toOtherTrsZSign)
{
meshTriangle.RemoveFromMesh();
for (int i4 = 0; i4 < otherMeshTriangles.Length; i4++)
{
if (otherMeshTriangles[i4].triangleIndex > meshTriangle.triangleIndex)
{
otherMeshTriangles[i4].triangleIndex--;
}
}
}
}
}
}
}
}
MeshFilter meshFilter;
Rigidbody rigid = null;
if (outputGo == null)
{
outputGo = new GameObject();
meshFilter = outputGo.AddComponent <MeshFilter>();
outputGo.AddComponent <MeshRenderer>();
}
else
{
meshFilter = outputGo.GetComponent <MeshFilter>();
if (meshFilter == null)
{
meshFilter = outputGo.AddComponent <MeshFilter>();
}
if (autoAddRigidbody)
{
rigid = outputGo.GetComponent <Rigidbody>();
}
}
if (autoAddRigidbody)
{
if (rigid == null)
{
rigid = outputGo.AddComponent <Rigidbody>();
}
rigid.mass = combineEntries.Length;
}
if (autoSetColliders)
{
Collider[] colliders = outputGo.GetComponents <Collider>();
for (int i2 = 0; i2 < colliders.Length; i2++)
{
Collider collider = colliders[i2];
DestroyImmediate(collider);
}
for (int i = 0; i < combineEntries.Length; i++)
{
CombineEntry combineEntry = combineEntries[i];
BoxCollider boxCollider = outputGo.AddComponent <BoxCollider>();
Transform outputTrs = outputGo.GetComponent <Transform>();
boxCollider.center = outputTrs.InverseTransformPoint(combineEntry.trs.position);
boxCollider.size = outputTrs.InverseTransformPoint(combineEntry.trs.lossyScale);
}
}
meshFilter.sharedMesh = new Mesh();
meshFilter.sharedMesh.CombineMeshes(combineInstances);
// for (int i = 0; i < combineEntries.Length; i ++)
// DestroyImmediate(combineEntries[i].trs.gameObject);
outputGo = null;
combineEntries = new CombineEntry[0];
}
public virtual void ControlSelected()
{
if (!inControlMode)
{
return;
}
_Slider slider = currentSelected.GetComponent <_Slider>();
if (slider != null)
{
slider.indexOfCurrentSnapValue = Mathf.Clamp(slider.indexOfCurrentSnapValue + MathfExtensions.Sign(inputDirection.x), 0, slider.snapValues.Length - 1);
slider.slider.value = slider.snapValues[slider.indexOfCurrentSnapValue];
}
}
public virtual void Update(_Animation animation)
{
switch (timeSpanType)
{
case Type.AnimStartAndEnd:
startTime = 0;
endTime = startTime + animation.Duration;
duration = animation.Duration;
startFrame = Mathf.RoundToInt(startTime / (1f / animation.framesPerSecond));
endFrame = Mathf.RoundToInt(endTime / (1f / animation.framesPerSecond));
frameCount = endFrame - startFrame;
break;
case Type.AnimStartAndEndFrame:
startFrame = Mathf.Clamp(startFrame, 0, startFrame + animation.FrameCount);
startTime = startFrame * (1f / animation.framesPerSecond);
endFrame = Mathf.Clamp(endFrame, startFrame, startFrame + animation.FrameCount);
frameCount = animation.FrameCount;
endTime = startTime + animation.Duration;
duration = 1f / animation.framesPerSecond * frameCount;
break;
case Type.AnimStartAndEndTime:
startTime = MathfExtensions.SnapToInterval(startTime, 1f / animation.framesPerSecond);
startTime = Mathf.Clamp(startTime, 0, animation.Duration);
endTime = MathfExtensions.SnapToInterval(endTime, 1f / animation.framesPerSecond);
endTime = Mathf.Clamp(endTime, startTime, startTime + animation.Duration);
startFrame = Mathf.RoundToInt(startTime / (1f / animation.framesPerSecond));
startFrame = Mathf.Clamp(startFrame, 0, int.MaxValue);
endFrame = Mathf.RoundToInt(endTime / (1f / animation.framesPerSecond));
endFrame = Mathf.Clamp(endFrame, 0, int.MaxValue);
frameCount = endFrame - startFrame;
duration = endTime - startTime;
break;
case Type.AnimStartFrameAndCount:
startFrame = Mathf.Clamp(startFrame, 0, animation.FrameCount);
frameCount = Mathf.Clamp(frameCount, 0, animation.FrameCount);
startTime = 1f / animation.framesPerSecond * startFrame;
endFrame = startFrame + frameCount;
endTime = startTime + animation.Duration;
duration = 1f / animation.framesPerSecond * frameCount;
break;
case Type.AnimStartTimeAndDuration:
startTime = MathfExtensions.SnapToInterval(startTime, 1f / animation.framesPerSecond);
startTime = Mathf.Clamp(startTime, 0, startTime + animation.Duration);
duration = Mathf.Clamp(duration, 0, animation.Duration);
endTime = startTime + duration;
startFrame = Mathf.RoundToInt(startTime / (1f / animation.framesPerSecond));
endFrame = Mathf.RoundToInt(endTime / (1f / animation.framesPerSecond));
frameCount = endFrame - startFrame;
break;
case Type.FrameCount:
startTime = MathfExtensions.NULL_FLOAT;
endTime = MathfExtensions.NULL_FLOAT;
duration = MathfExtensions.NULL_FLOAT;
startFrame = MathfExtensions.NULL_INT;
endFrame = MathfExtensions.NULL_INT;
break;
case Type.StartAndEndTime:
startTime = Mathf.Clamp(startTime, 0, Mathf.Infinity);
endTime = Mathf.Clamp(endTime, startTime, Mathf.Infinity);
startFrame = MathfExtensions.NULL_INT;
endFrame = MathfExtensions.NULL_INT;
frameCount = MathfExtensions.NULL_INT;
duration = endTime - startTime;
break;
case Type.StartTimeAndDuration:
startTime = Mathf.Clamp(startTime, 0, Mathf.Infinity);
duration = Mathf.Clamp(duration, 0, Mathf.Infinity);
endTime = startTime + duration;
startFrame = MathfExtensions.NULL_INT;
endFrame = MathfExtensions.NULL_INT;
frameCount = MathfExtensions.NULL_INT;
break;
case Type.Infinite:
duration = Mathf.Infinity;
startTime = MathfExtensions.NULL_FLOAT;
endTime = MathfExtensions.NULL_FLOAT;
startFrame = MathfExtensions.NULL_INT;
endFrame = MathfExtensions.NULL_INT;
frameCount = MathfExtensions.NULL_INT;
break;
}
}
public BulletEntry(Bullet bullet)
{
this.bullet = bullet;
yMoveDirection = MathfExtensions.Sign(PlayerMouse.Instance.trs.position.y - bullet.trs.position.y);
}
public static float Max(this Vector3 that) => MathfExtensions.Max(that.x, that.y, that.z);
