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); }