private void UpdateState()
{
UpdateHorizontalSpeed();
UpdateVerticalSpeed();
Vector3 movement = _horizontalSpeed * GetMovementDirection() + _verticalSpeed * Vector3.up;
//Debug.Log(movement);
if (!_characterAnimator.UseRootMotion)
{
_characterController.Move(movement * Time.deltaTime);
}
if (_movementState == MovementState.Jump)
{
_characterController.Move(movement * Time.deltaTime);
}
OrientToTargetRotation(movement.SetY(0.0f));
IsGrounded = _characterController.isGrounded;
UpdateGroundState();
if (_characterAnimator != null)
{
_characterAnimator.UpdateState();
}
}
public override Bullet[] Shoot(Transform spawner, Bullet bulletPrefab, float positionOffset = 0)
{
Vector3 toPlayer = PlayerObject.CurrentActive.trs.position - spawner.position;
float x = toPlayer.SetY(0).magnitude;
float y = -toPlayer.y;
float speed = Mathf.Clamp(bulletSpeedMultiplierOverDistance.Evaluate(toPlayer.magnitude), 0, bulletPrefab.moveSpeed);
float speedSqr = speed * speed;
float gravity = Physics.gravity.y;
float parentheses = gravity * x * x + 2 * y * speedSqr;
float sqrt = Mathf.Sqrt(speedSqr * speedSqr - gravity * parentheses);
float denominator = gravity * x;
float angle1 = Mathf.Atan((speedSqr + sqrt) / denominator) * Mathf.Rad2Deg;
float angle2 = Mathf.Atan((speedSqr - sqrt) / denominator) * Mathf.Rad2Deg;
spawner.forward = toPlayer;
spawner.localEulerAngles = spawner.localEulerAngles.SetX(Mathf.Max(angle1, angle2));
Quaternion spawnerRotation = spawner.rotation;
spawner.Rotate(offsetDegrees);
Bullet bullet = GameManager.GetSingleton <ObjectPool>().SpawnComponent <Bullet>(bulletPrefab, spawner.position + spawner.forward * positionOffset, spawner.rotation);
spawner.rotation = spawnerRotation;
bullet.moveSpeed = speed;
bullet.rigid.velocity = bullet.trs.forward * speed;
return(new Bullet[] { bullet });
}
public void LookTowardsDirection(Vector3 direction)
{
if (Math.Abs(InputManager.Instance.RawHoritzontalAxis) >= 1 ||
Math.Abs(InputManager.Instance.RawVerticalAxis) >= 1)
{
Transform.rotation = Quaternion.LookRotation(direction.SetY(0), Vector3.up);
}
}
private IEnumerator TravelPath()
{
Vector3 a, b, c = _pathToTravel[0].Position;
HexCell baseCell, targetCell = null;
float t = Time.deltaTime * _travelSpeed;
for (int i = 1; i < _pathToTravel.Count; i++)
{
baseCell = _pathToTravel[i - 1];
targetCell = _pathToTravel[i];
a = c.SetY(baseCell.Height);
b = baseCell.Position.SetY(baseCell.Height);
c = ((b + targetCell.Position) * 0.5f).SetY(targetCell.Height);
for (; t < 1f; t += Time.deltaTime * _travelSpeed)
{
transform.localPosition = Bezier.GetPoint(a, b, c, t);
var dir = baseCell.Coordinates.GetRelatedDirection(targetCell.Coordinates);
Rotate(dir);
yield return(null);
}
t -= 1f;
}
baseCell = _pathToTravel[_pathToTravel.Count - 1];
a = c.SetY(baseCell.Height);;
b = baseCell.Position.SetY(baseCell.Height);
c = b;
for (; t < 1f; t += Time.deltaTime * _travelSpeed)
{
transform.localPosition = Bezier.GetPoint(a, b, c, t);
var dir = baseCell.Coordinates.GetRelatedDirection(targetCell.Coordinates);
Rotate(dir);
yield return(null);
}
transform.localPosition = _location.Position.SetY(targetCell.Height);
ResetAnimation();
ListPool <HexCell> .Add(_pathToTravel);
_pathToTravel = null;
}
protected override void StartState(RuntimeMoveData data, RoninController cc, Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
base.StartState(data, cc, animator, stateInfo, layerIndex);
Vector3 current = data.ccData.velocity;
current = current.SetY(data.playerInfo.jumpSpeed.Evaluate(1) * data.ccData.bouncingFactor);
cc.Move(current, false);
}
void TakeDamage(DamageInfo damageInfo)
{
Vector3 diff = (transform.position - damageInfo.owner.transform.position);
diff = diff.SetY(0);
diff.Normalize();
Knockback(damageInfo, diff * damageInfo.data.knockbackDistance);
}
public IEnumerator WalkingAround()
{
while (IsActive)
{
if (m_isFrozen)
{
countDownTxt.gameObject.GetComponent <MeshRenderer>().enabled = true;
int cd = 2;
while (cd > 0)
{
countDownTxt.text = cd.ToString();
yield return(new WaitForSeconds(1));
cd--;
}
countDownTxt.gameObject.GetComponent <MeshRenderer>().enabled = false;
m_isFrozen = false;
targetPos = AssignPosInRoom();
}
if (targetPos.y > -1)
{
//print("dis " + (targetPos - transform.position).SetY(0).magnitude);
if ((targetPos.SetY(0) - transform.position.SetY(0)).magnitude > 0.1f)
{
transform.Translate((targetPos.SetY(0) - transform.position.SetY(0)).normalized * Time.deltaTime * speed, Space.World);
//transform.position += (targetPos.SetY(0) - transform.position.SetY(0)).normalized * Time.deltaTime;
transform.forward = (targetPos.SetY(0) - transform.position.SetY(0));
}
else
{
targetPos = targetPos.SetY(-999);
}
}
else
{
yield return(StartCoroutine(TurnAround()));
}
yield return(null);
}
}
public static Vector3 SnapToVertex(Vector3 position)
{
Vector3 newPosition = position;
newPosition = newPosition.SetY(0.0f);
newPosition = newPosition.SetX(Mathf.Round(newPosition.x));
newPosition = newPosition.SetZ(Mathf.Round(newPosition.z));
return(newPosition);
}
void Move()
{
if (isGrounded)
{
move += GetMoveInput() * moveSpeed;
}
else
{
move = previousMoveInput.SetY(move.y);
}
}
bool IsNearPosition(Vector3 position)
{
Vector3 diff = position - transform.position;
if (Mathf.Abs(diff.y) > capsule.height * 1.2f)
{
return(false);
}
return(diff.SetY(0).magnitude < capsule.radius * 0.5f);
}
public static bool DoesWallExistBetweenXZPoints(Vector3 pointA, Vector3 pointB)
{
pointA = pointA.SetY(kFootPositionY);
pointB = pointB.SetY(kFootPositionY);
Vector3 aToB = pointB - pointA;
Ray aToBRay = new Ray(pointA, aToB.normalized);
int hits = Physics.RaycastNonAlloc(aToBRay, kRaycastResults_, maxDistance: aToB.magnitude, layerMask: InGameConstants.PlatformsLayerMask);
return(hits > 0);
}
public void Umath_Vectors_SetVector3()
{
var position = new Vector3(1, 1, 1);
Assert.AreEqual(new Vector3(2, 1, 1), position.SetX(2));
Assert.AreEqual(new Vector3(1, 2, 1), position.SetY(2));
Assert.AreEqual(new Vector3(1, 1, 2), position.SetZ(2));
Assert.AreEqual(new Vector3(2, 2, 1), position.SetXY(2, 2));
Assert.AreEqual(new Vector3(2, 1, 2), position.SetXZ(2, 2));
Assert.AreEqual(new Vector3(1, 2, 2), position.SetYZ(2, 2));
}
public static void FollowToScreenPos(GameObject go, Vector2 screenPos, float fixedHeight = 0.5f)
{
if (go == null)
{
return;
}
Vector3 dragItemScreenSpace = Camera.main.WorldToScreenPoint(go.transform.position);
Vector3 currentScreenSpace = new Vector3(screenPos.x, screenPos.y, dragItemScreenSpace.z);
Vector3 currentPosition = Camera.main.ScreenToWorldPoint(currentScreenSpace);
currentPosition = currentPosition.SetY(fixedHeight);
go.transform.position = currentPosition;
}
public void set_y_test()
{
//Arrange
Vector3 input = Vector3.zero;
//Act
input = input.SetY(1);
//Assert
Assert.AreEqual(0, input.x);
Assert.AreEqual(1, input.y);
Assert.AreEqual(0, input.z);
}
private void Spawn(Vector3 lowHumanPos, Vector3 highHumanPos)
{
float num = highHumanPos.y + showBehind;
float num2 = lowHumanPos.y - showAhead;
for (int i = 0; i < blocks.Count; i++)
{
if (!blocks[i].isSpawned && blocks[i].lineY > num2 && blocks[i].lineY < num)
{
blocks[i].SpawnLetters(lowHumanPos.SetY(blocks[i].lineY));
}
}
}
public IEnumerator ClimbGeometry(Vector3 target, Action action)
{
GetComponent <Collider>().enabled = false;
//SoundManager.Instance.Play(SoundManager.SoundEffect.EffortNoise);
iTween.MoveTo(gameObject,
target.SetY(target.y + 2.5f),
.4f);
action();
yield return(new WaitForSeconds(.4f));
GetComponent <Collider>().enabled = true;
yield break;
}
public static int[] GetAPIndices(TankBlock block, Vector3 Position)
{
List <int> list = new List <int>();
for (int k = 0; k < block.attachPoints.Length; k++)
{
Vector3 input = block.attachPoints[k] - Position;
if (input.sqrMagnitude < 1f && input.SetY(0f).sqrMagnitude > 0.1f)
{
list.Add(k);
}
}
return(list.ToArray());
}
private void UpdateState()
{
UpdateHorizontalSpeed();
UpdateVerticalSpeed();
Vector3 movement = _horizontalSpeed * GetMovementDirection() + _verticalSpeed * Vector3.up;
_characterController.Move(movement * Time.deltaTime);
OrientToTargetRotation(movement.SetY(0.0f));
IsGrounded = _characterController.isGrounded;
_characterAnimator.UpdateState();
}
public static bool TryGetGroundHeight(Vector3 postion, out float height)
{
RaycastHit hit;
var ray = new Ray(postion.SetY(150f), Vector3.down);
if (Physics.Raycast(ray, out hit, 200f, LayerUtil.WalkbleMask))
{
height = hit.point.y;
return(true);
}
else
{
height = 0f;
return(false);
}
}
void Start()
{
Terrain terrain = this.GetComponent<Terrain>();
for (int i = 0; i < this.SpawnCount; ++i)
{
Vector2 location = Random.insideUnitCircle * this.SpawnRadius;
Vector3 worldPosition = new Vector3(location.x, 0.0f, location.y);
float y = terrain.SampleHeight(worldPosition) + this.HeightAboveGround;
worldPosition = worldPosition.SetY(y);
GameObject collectableObject = (GameObject)GameObject.Instantiate(this.CollectableToPlace, worldPosition, this.CollectableToPlace.transform.rotation);
collectableObject.isStatic = true;
collectableObject.transform.parent = this.ParentGameObject.transform;
}
}
private void UpdateFuzzyTargetPosition()
{
Vector3 currentPosition = StateMachine_.Player.transform.position;
float accuracyInDegrees = StateMachine_.AIConfiguration.AccuracyInDegrees();
Vector3 targetVector = target_.transform.position - currentPosition;
if (targetVector == Vector3.zero)
{
return;
}
Quaternion rotationToTarget = Quaternion.LookRotation(targetVector);
if (fuzzyTargetPosition_ != null)
{
// check if target has moved out of accurancy cone, if so recompute fuzzyTargetPosition_
Vector3 targetPositionVector = (Vector3)fuzzyTargetPosition_ - currentPosition;
if (targetPositionVector != Vector3.zero)
{
Quaternion rotationToTargetPosition = Quaternion.LookRotation(targetPositionVector);
float angleToTarget = Quaternion.Angle(rotationToTarget, rotationToTargetPosition);
if (angleToTarget > accuracyInDegrees)
{
fuzzyTargetPosition_ = null;
}
}
}
if (fuzzyTargetPosition_ != null)
{
// update fuzzyTargetPosition_ to have same distance as target_ currently does
fuzzyTargetPosition_ = currentPosition + (((Vector3)fuzzyTargetPosition_ - currentPosition).normalized * targetVector.magnitude);
return;
}
Vector3 rotationToTargetEuler = rotationToTarget.eulerAngles;
// NOTE (darren): divide by three since 3 * standardDeviation is 95% percentile of generated normal deviation
float newYRotation = MathUtil.SampleGaussian(rotationToTargetEuler.y, accuracyInDegrees / 3.0f);
rotationToTargetEuler = rotationToTargetEuler.SetY(newYRotation);
Quaternion rotationToGeneratedTargetPosition = Quaternion.Euler(rotationToTargetEuler);
fuzzyTargetPosition_ = currentPosition + (rotationToGeneratedTargetPosition * Vector3.forward * targetVector.magnitude);
}
private void GenerateBackSea(float offset)
{
Vector3[] verts = backSeaMeshFilter.mesh.vertices;
for (int i = 0; i < verts.Length; i++)
{
Vector3 vert = verts[i];
vert = vert.SetY(Mathf.PerlinNoise(vert.x * seaSmooth + offset, vert.z * seaSmooth + offset) * seaSmoothScale);
float horizontalOffset = Mathf.PerlinNoise(vert.x * seaSmooth - offset * 0.3f, vert.z * seaSmooth - offset * 0.3f) * 0.6f;
vert = initialVertsPos[i].SetY(vert.y /*Mathf.Clamp( vert.y + seaRendererHeight, -10f, -0.41f)*/).AddToX(horizontalOffset).AddToZ(-horizontalOffset);
verts[i] = vert;
}
backSeaMeshFilter.mesh.RecalculateNormals();
backSeaMeshFilter.mesh.vertices = verts;
}
public override Bullet[] Shoot(Transform spawner, Bullet bulletPrefab, float positionOffset = 0)
{
Vector3 toPlayer = PlayerObject.CurrentActive.trs.position - spawner.position;
float x = toPlayer.SetY(0).magnitude;
float y = -toPlayer.y;
float speed = bulletPrefab.moveSpeed;
float speedSqr = speed * speed;
float gravity = Physics.gravity.y;
float parentheses = gravity * x * x + 2 * y * speedSqr;
float sqrt = Mathf.Sqrt(speedSqr * speedSqr - gravity * parentheses);
float denominator = gravity * x;
float angle1 = Mathf.Atan((speedSqr + sqrt) / denominator) * Mathf.Rad2Deg;
float angle2 = Mathf.Atan((speedSqr - sqrt) / denominator) * Mathf.Rad2Deg;
spawner.localEulerAngles = spawner.localEulerAngles.SetX(Mathf.Max(angle1, angle2));
return(base.Shoot(spawner, bulletPrefab, positionOffset));
}
private void Start()
{
var kuribo = GetComponent <Kuribo>();
var rb = GetComponent <Rigidbody>();
capsuleCollider = GetComponent <CapsuleCollider>();
kuribo.EnemyMoveable
.Skip(1)
.Where(x => !x)
.Do(_ => IsMoving = true)
.Delay(TimeSpan.FromSeconds(walkInterval))
.Subscribe(_ => IsMoving = false);
this.FixedUpdateAsObservable()
.Where(_ => !IsMoving && kuribo.EnemyMoveable.Value)
.Subscribe(_ =>
{
IsMoving = true;
do
{
moveVector3 = new Vector3(RandomValue, 0f, RandomValue).normalized;
} while (moveVector3.magnitude == 0f);
Observable.EveryFixedUpdate()
.TakeWhile(_2 => MoveJudge(moveVector3) && kuribo.EnemyMoveable.Value)
.TakeUntil(Observable.Timer(TimeSpan.FromSeconds(walkTime)))
.Subscribe(_2 =>
{
rb.velocity = moveVector3.SetY(rb.velocity.y);
}, () => Observable.Timer(TimeSpan.FromSeconds(walkInterval))
.TakeUntil(kuribo.EnemyMoveable.Where(x => !x))
.Subscribe(_3 => { IsMoving = false; })).AddTo(this);
});
//Observable.Timer(TimeSpan.FromSeconds(10000)).TakeWhile(_ => flag).Subscribe(_ => Debug.Log("onnest"), () => Debug.Log("fiish"));
//ReactiveProperty<bool> flag = new BoolReactiveProperty(true);
//Observable.Return(Unit.Default).TakeWhile(_ => flag.Value).Delay(TimeSpan.FromSeconds(10000)).Subscribe(_ => Debug.Log("onnest"), () => Debug.Log("fiish")).AddTo(this);
//Observable.EveryUpdate().TakeUntil(flag.Where(x => !x)).Subscribe(_ => Debug.Log("onnest"), () => Debug.Log("fiish")).AddTo(this);
//Observable.Timer(TimeSpan.FromSeconds(1000)).TakeWhile(_ => flag.Value).Subscribe(_ => Debug.Log("onnest"), () => Debug.Log("fiish")).AddTo(this);
//Observable.Timer(TimeSpan.FromSeconds(2)).Subscribe(_ => { flag.Value = false; Debug.Log("value change"); });
}
IEnumerator FindNewTargetAndTurnTo()
{
targetPos = AssignPosInRoom();
float angleBetween = Vector3.SignedAngle(
transform.forward.SetY(0), (targetPos.SetY(0) - transform.position.SetY(0)), Vector3.up);
int cnt = 0;
int frameToRotate = (int)(Mathf.Abs(angleBetween) / 3);
while (cnt < frameToRotate)
{
//transform.forward = (player.position - transform.position).SetY(0);
transform.Rotate(transform.up, angleBetween / frameToRotate);
cnt++;
yield return(null);
}
}
private void FindTargetBlock()
{
Vector3 forceDir = startPos - Camera.main.ScreenToWorldPoint(Input.mousePosition);
RaycastHit2D hit = Physics2D.Raycast(startPos, forceDir);
// Debug.DrawLine(startPos, Camera.main.ScreenToWorldPoint(Input.mousePosition));
if (hit.collider != null && hit.transform.CompareTag("Block"))
{
//print("hit " + hit.transform.name);
StartCoroutine(SwapHammerTo(hit.point - Vector2.left * 0.85f, () =>
{
// Give player complete freedom
//hit.transform.GetComponent<Rigidbody2D>().AddForceAtPosition(forceDir * forceDir.magnitude * 0.1f, hit.point, ForceMode2D.Impulse);
hit.transform.GetComponent<Rigidbody2D>().AddForceAtPosition(forceDir.SetY(-0.3f) * forceDir.magnitude * 0.1f, hit.point, ForceMode2D.Impulse);
}));
}
}
public FloatingText SpawnText(string str, Vector3 pos, Color color, int?fontSize = null, float?lifetime = null, Transform parent = null)
{
FloatingText newText = Instantiate(textPrefab, pos.SetY(yDistance), Quaternion.Euler(eulers));
if (lifetime.HasValue)
{
newText.lifeTime = lifetime.Value;
}
if (fontSize.HasValue)
{
newText.SetSize(fontSize.Value);
}
if (parent != null)
{
newText.SetParent(parent);
}
newText.SetString(str);
newText.SetColor(color);
return(newText);
}
private IEnumerator ClimbSurface(Vector3 target)
{
/*iTween.MoveTo(
* _playerGuyHooks.gameObject,
* iTween.Hash(
* "y",
* target.y + PlayerHeight / 2f,
* "time", .2f,
* "easetype",
* iTween.EaseType.easeInBack));*/
_playerGuyHooks.gameObject.transform.position =
_playerGuyHooks.gameObject.transform.position.SetY(target.y + PlayerHeight / 2f);
yield return(null);
//yield return _timerCoroutineFactory.CreateTimer(.25f / _speedLevel);
Debug.DrawLine(target, target.SetY(target.y + 2), Color.red);
}
public IEnumerator VerticalHoleTransition(Vector3 targetEndpoint, GrottoEntrance.EnterMethod enterMethod)
{
if (enterMethod == GrottoEntrance.EnterMethod.Fall)
{
iTween.MoveTo(gameObject, iTween.Hash("position", transform.position.SetY(transform.position.y - 5f), "time", .5f, "easetype", iTween.EaseType.easeInBack));
}
else if (enterMethod == GrottoEntrance.EnterMethod.Spring)
{
iTween.MoveTo(gameObject, iTween.Hash("position", transform.position.SetY(transform.position.y + 10f), "time", .5f, "easetype", iTween.EaseType.easeInOutSine));
}
yield return new WaitForSeconds(.25f);
yield return StartCoroutine(CameraManager.Instance.DoWipeOut(.5f));
yield return new WaitForSeconds(.5f);
CameraManager.Instance.GetCameraRig().position = targetEndpoint;
transform.position = targetEndpoint.SetY(targetEndpoint.y + 3f);
iTween.MoveTo(gameObject, iTween.Hash("position", targetEndpoint, "time", 1f, "easetype", iTween.EaseType.easeOutCirc));
yield return new WaitForSeconds(.25f);
yield return StartCoroutine(CameraManager.Instance.DoWipeIn(.5f));
}
private void OnDrawGizmos()
{
if (serializedVertexLocalPositions_ == null)
{
return;
}
for (int i = 0; i < serializedVertexLocalPositions_.Length - 1; i++)
{
Vector3 aPoint = serializedVertexLocalPositions_[i] + this.transform.position;
Vector3 bPoint = serializedVertexLocalPositions_[i + 1] + this.transform.position;
for (float y = 0; y <= 1.5f; y += 0.25f)
{
Vector3 raisedAPoint = aPoint.SetY(y);
Vector3 raisedBPoint = bPoint.SetY(y);
Gizmos.DrawLine(raisedAPoint, raisedBPoint);
}
}
}
Vector3 ApplyTransform(Vector3 v, string dir, float value, bool clamp = false)
{
string axis = dir.Substring(dir.Length - 1);
value = dir.Length == 1 ? value : -value;
if (axis == "x")
{
float x = Angle.ToStardard(v.x) + value;
return(v.SetX(clamp? Mathf.Clamp(x, -80, 80): x));
}
else if (axis == "y")
{
float y = Angle.ToStardard(v.y) + value;
return(v.SetY(clamp? Mathf.Clamp(y, -80, 80): y));
}
else
{
float z = Angle.ToStardard(v.z) + value;
return(v.SetZ(clamp? Mathf.Clamp(z, -80, 80): z));
}
}
/// <summary>
/// 使用技能 by吴江
/// </summary>
public virtual void UseAbility(AbilityInstance _instance)
{
if (IsSilent && _instance.thisSkillMode == SkillMode.CLIENTSKILL)
{
return; //客户端技能 沉默了才不能放
}
if (moveFSM != null && moveFSM.isMovingTo)
{
moveFSM.StopMovingTo();
}
curTryUseAbility = _instance;
if (abilityShadowEffecter != null)
{
GameCenter.spawner.DespawnAbilityShadowEffecter(abilityShadowEffecter);
}
if (_instance == null)
{
return;
}
if (_instance.HasWarnning && _instance.NeedPrepare && !_instance.HasServerConfirm)
{
Vector3 pos = ActorMoveFSM.LineCast(_instance.WarnningPos, !isDummy);
pos = pos.SetY(pos.y + 10.0f);
abilityShadowEffecter = GameCenter.spawner.SpawnAbilityShadowEffecter(pos, _instance.warnningDir, _instance.WarnningWidth,
_instance.WarnningLength, _instance.WarnningType, abilityWarnningColor, _instance.WarnningTime);
}
if (animFSM != null)
{
animFSM.Cast(_instance);
}
if (_instance.DirTurnType == TurnType.TURN)
{
FaceToNoLerp(_instance.DirY);
}
if (_instance.SkillReportID != 0)
{
GameCenter.messageMng.AddClientMsg(_instance.SkillReportID);
}
//StartCoroutine(DoAbilityHitEffect(_instance.BlinkLateTime / 1000f));
}
void Update()
{
if(playerCards == null || opponentCards == null) return;
//set up card cost glowing material first time
if (cardGlowMat == null && playerCards.Count > 1)
{
cardOutlineMat = playerCards[0].cardView.costText.fontSharedMaterial;
cardGlowMat = new Material(cardOutlineMat);
cardGlowMat.SetFloat(ShaderUtilities.ID_GlowPower, 0.4f);
cardGlowMat.SetFloat(ShaderUtilities.ID_OutlineWidth, 0.0f);
}
//position opponents cards
//might need to DRY it up sometime but rule of three still holds
cardAngleSpread = -13f + (0.8f * opponentCards.Count);
for(int c = 0; c < opponentCards.Count; c++)
{
var card = opponentCards[c];
if(card.activated) continue;
var rectTransform = card.rectTransform;
var cardCountOffset = 0 - ((opponentCards.Count - 1) / 2) + c;
rectTransform.rotation = Quaternion.Euler(new Vector3(0, 0, 180f + cardCountOffset * cardAngleSpread));
rectTransform.Rotate(Vector3.up, 180f, Space.Self);
dest = PointOnCircle(cardCircleRadius, 270f + cardCountOffset * cardAngleSpread, opponentCardCircleCenter);
dest = dest.SetZ(dest.z + (-1.0f * c));
rectTransform.anchorMax = opponentAnchorPosition;
rectTransform.anchorMin = opponentAnchorPosition;
rectTransform.pivot = opponentAnchorPosition;
rectTransform.anchoredPosition3D = iTween.Vector3Update(rectTransform.anchoredPosition3D, dest, 10.0f);
}
//and now players cards
cardAngleSpread = -16f + (1.2f * playerCards.Count);
for(int c = 0; c < playerCards.Count; c++)
{
var card = playerCards[c];
if(card.activated) continue;
var rectTransform = card.rectTransform;
var cardCountOffset = 0 - ((playerCards.Count - 1) / 2) + c;
rectTransform.rotation = Quaternion.Euler(new Vector3(0, 0, cardCountOffset * cardAngleSpread));
dest = PointOnCircle(cardCircleRadius, 90f + cardCountOffset * cardAngleSpread, cardCircleCenter);
dest = dest.SetZ(dest.z + (-1.0f * c));
//drag the selected card with the cursor
if (selectedCard != null && card.id == selectedCard.card.id)
{
var mouseWorld = cardCanvasHelper.MouseToWorld(dest.z);
var dragPos = new Vector3(mouseWorld.x + selectedCard.point.x, mouseWorld.y + selectedCard.point.y, mouseWorld.z);
dragPos = dragPos.SetY(dragPos.y + cardDimensions.y * canvas.scaleFactor);
var dragDist = Vector3.Distance(dragPos, dest);
if (dragDist < maxDragDistance || !selectedNeedsArrow)
{
rectTransform.rotation = Quaternion.Euler(new Vector3(0, 0, 0));
rectTransform.anchoredPosition3D = dragPos;
continue;
}
else
{
dest = dest.SetY(dest.y + 30f);
}
}
//show the hover card on top of where the actual card is after a delay
if (hoveredCard != null && card == hoveredCard && (selectedCard == null || hoveredCard != selectedCard.card))
{
dest = dest.SetY(dest.y + 30f);
hoverAccumulator += Time.deltaTime;
if (hoverAccumulator > CardView.HOVER_DELAY)
{
card.cardView.displayWrapper.SetActive(false);
}
}
rectTransform.anchorMax = anchorPosition;
rectTransform.anchorMin = anchorPosition;
rectTransform.pivot = anchorPosition;
rectTransform.anchoredPosition3D = iTween.Vector3Update(rectTransform.anchoredPosition3D, dest, 10.0f);
if (card.playable && cardGlowMat != null)
{
card.cardView.costText.fontMaterial = cardGlowMat;
}
else if(cardOutlineMat != null)
{
card.cardView.costText.fontMaterial = cardOutlineMat;
}
}
}
public void LookAt(Vector3 vector3)
{
playerMesh.LookAt(vector3.SetY(playerMesh.position.y));
}
public IEnumerator ClimbGeometry(Vector3 target, Action action)
{
collider.enabled = false;
SoundManager.Instance.Play(SoundManager.SoundEffect.EffortNoise);
iTween.MoveTo(gameObject,
target.SetY(target.y + 2.5f),
.4f);
action();
yield return new WaitForSeconds(.4f);
collider.enabled = true;
yield break;
}
private void RotatePlayer(Transform playerTransform, Vector3 direction)
{
//Rotate the player to face direction of movement only when input keys are pressed
if (Math.Abs(_inputManger.RawHoritzontalAxis) >= .1f
|| Math.Abs(_inputManger.RawVerticalAxis) >= .1f)
{
playerTransform.rotation = Quaternion.LookRotation(direction.SetY(0), Vector3.up);
}
}
private void SpawnClicker(string type, Vector3 position = new Vector3(), int stackedClickers = 1)
{
var clickGenerator = Instantiate(AutoClickerTemplate).GetComponent<ClickGenerator>();
clickGenerator.Initialize(this, Clickers[type].CloneWithRandom());
clickGenerator.transform.position = position.SetY(Depth);
clickGenerator.StackedClickers = stackedClickers;
ActiveAutoclickers.Add(clickGenerator);
}
// Duplicated from Chaser.cs, will need to get split into own component
private void LookToward(Vector3 direction)
{
transform.rotation = Quaternion.LookRotation(direction.SetY(0), Vector3.up);
}
