// Update is called once per frame
void Update()
{
//m_MovementComponent.Move(Input.GetAxis("Horizontal")*Time.deltaTime, Input.GetAxis("Vertical")*Time.deltaTime);
m_MovementComponent.Move(m_Joystick.Horizontal * Time.deltaTime * m_EffectManager.GetSpeedMult(), m_Joystick.Vertical * Time.deltaTime * m_EffectManager.GetSpeedMult());
if (m_Joystick.Horizontal != 0.0f && m_Joystick.Vertical != 0.0f)
{
float angle = Mathf.Atan2(m_Joystick.Vertical, m_Joystick.Horizontal) * Mathf.Rad2Deg;
Quaternion rot = Quaternion.AngleAxis(angle, Vector3.forward);
m_PlayerHand.GetComponent <SpriteRenderer>().transform.rotation = rot;
}
else
{
m_MovementComponent.Move(Input.GetAxis("Horizontal") * Time.deltaTime * m_EffectManager.GetSpeedMult(), Input.GetAxis("Vertical") * Time.deltaTime * m_EffectManager.GetSpeedMult());
}
AutoAim();
//if (Input.GetKeyDown(KeyCode.Mouse0))
// m_WeaponComponent.AttemptToShoot();
if (Input.GetKeyDown(KeyCode.Alpha1))
{
m_SpellComponent.CastSpell(0);
}
if (Input.GetKeyDown(KeyCode.Alpha2))
{
m_SpellComponent.CastSpell(1);
}
}
void Update()
{
if (joy.Horizontal != 0)
{
movement.Move(joy.Horizontal);
}
}
private void HandleMovementInput()
{
if (movementComponent == null)
{
Debug.LogError("Movement component is not attached to game object.");
}
else
{
Vector3 offset;
switch (InputType)
{
case InputTypeEnum.Keyboard:
offset = DetermineKeyboardOffset();
break;
case InputTypeEnum.Joystick:
offset = DetermineJoystickOffset();
break;
default:
throw new ArgumentOutOfRangeException();
}
movementComponent.Move(offset);
orientator.UpdateDisplay(new Vector2(offset.x, offset.z));
}
}
public override void PlayAction(AbstractCharacter character)
{
MovementComponent movementComponent = character.GetComponent <MovementComponent>();
movementComponent.OnFinishedAction += OnMovementFinished;
movementComponent.Move(this.destination);
}
void Update()
{
if (_startThrow)
{
_movementComponent.Move(_direction.x * _speed * Time.deltaTime, _direction.y * _speed * Time.deltaTime);
transform.Rotate(0, 0, 10);
}
}
private void CheckForIdle()
{
if (!moveComp.IsMoving)
{
Vector2 position = Random.insideUnitCircle * 30f;
Vector3 pos = new Vector3(position.x, position.y, transform.position.z);
moveComp.Move(pos, Settings.UnitMoveSpeed * 0.2f);
}
}
protected override void OnUpdate(float dt)
{
if (IsFinish())
{
return;
}
elapsed += dt;
float progress = elapsed / info.VanishModifierConfig.translationDuration;
Vector2 targetPos = targetMovementComponent.Position;
Vector2 casterPos = casterMovementComponent.Position;
Vector2 newPos = Vector2.Lerp(targetPos, casterPos, progress);
targetMovementComponent.Move(newPos - targetPos);
}
public virtual void MoveEnemy(Vector3 dir, float speed)
{
_movementComponent.Move(dir.x * speed * Time.deltaTime, dir.y * speed * Time.deltaTime);
//transform.position += dir * speed * Time.deltaTime;
}
private void Update_(float dt)
{
if (pauseCount > 0)
{
return;
}
if (IsFinish())
{
return;
}
elapsed += dt;
if (da.ignoreObstacles || da.collision)
{
dashRequest.Update(dt);
Vector3 displacement = ((FixedUpdateDashRequest)dashRequest).Displacement_(movementComponent, dt);
if (da.ignoreObstacles)
{
movementComponent.ForceSetPosition(movementComponent.PositionV3 + displacement);
}
else
{
movementComponent.Move(displacement);
}
}
if (da.collision)
{
Vector2 centerOfHitbox = GetCenterOfHitbox();
Vector2 bridgeHitBoxSize = new Vector2(
Mathf.Abs(centerOfHitbox.x - centerOfHitBoxAtPreviousFrame.x),
casterBoxCollider.size.y
);
Vector2 centerOfBridgeHitBox = (centerOfHitbox + centerOfHitBoxAtPreviousFrame) / 2;
/*CubeShape cc = new CubeShape(centerOfBridgeHitBox, bridgeHitBoxSize, new List<SsarTuple<Color, float>>(new []{new SsarTuple<Color, float>(Color.yellow, .1f), }));
* GizmosDrawer.Instance.AddRequest(new DrawRequest(cc, .1f));*/
cubeShape.SetPos(centerOfHitbox);
cubeShape.size = casterBoxCollider.size;
bool collision = false;
Transform collidedTransform = null;
Collider targetCollider = null;
Collider[] c = Physics.OverlapBox(centerOfBridgeHitBox, bridgeHitBoxSize / 2, Quaternion.identity, obstacleMask);
foreach (Collider collider in c)
{
//DLog.Log("Collide with obstacle " + collider.name);
if (collider.gameObject == mapGround)
{
continue;
}
if (collider.gameObject == mapCeil)
{
continue;
}
collision = true;
collidedTransform = collider.transform;
targetCollider = collider;
break;
}
if (!collision)
{
c = Physics.OverlapBox(centerOfBridgeHitBox, bridgeHitBoxSize / 2, Quaternion.identity, creatureMask);
foreach (Collider collider in c)
{
//DLog.Log("Collide with creature " + collider.GetComponentInParent<EntityReference>().gameObject.name);
EntityReference collidedEntityRef = collider.GetComponentInParent <EntityReference>();
if (collidedEntityRef.transform == casterTransform)
{
continue;
}
if (collidedEntityRef.Entity.Group.Equals(casterEntity.Group))
{
continue;
}
collision = true;
if (collidedTransform == null)
{
collidedTransform = collider.transform;
targetCollider = collider;
}
else
{
float distanceBetweenCasterAndTransform = Vector2.Distance(positionAtPreviousFrame, collider.transform.position);
float distanceBetweenCasterAndPreviousTransform = Vector2.Distance(positionAtPreviousFrame, collidedTransform.position);
if (distanceBetweenCasterAndTransform < distanceBetweenCasterAndPreviousTransform)
{
collidedTransform = collider.transform;
targetCollider = collider;
}
}
}
}
if (collision && !dispatched)
{
Vector2 pos;
if (elapsed > dt) //second loop or above
//DLog.Log("Second and above loop");
{
Vector2 offset = da.offset.FlipFollowDirection(movementComponent.FacingDirection);
pos = (Vector2)targetCollider.bounds.center - offset;
pos.y = movementComponent.Position.y;
float minX = centerOfHitBoxAtPreviousFrame.x - offset.x;
float maxX = centerOfHitbox.x - offset.x;
if (movementComponent.FacingDirection == Direction.Left)
{
minX = centerOfHitbox.x - offset.x;
maxX = centerOfHitBoxAtPreviousFrame.x - offset.x;
}
/*if (pos.x < minX || pos.x > maxX) {
* DLog.Log("x " + pos.x + " minX " + minX + " maxX " + maxX);
* }*/
pos.x = Mathf.Clamp(pos.x, minX, maxX);
}
else //first loop
//DLog.Log("First loop");
{
bool alreadyCollided = false;
Collider[] collidedCreatures = Physics.OverlapBox(centerOfHitBoxAtPreviousFrame, casterBoxCollider.size / 2, Quaternion.identity, creatureMask);
if (collidedCreatures.Contains(targetCollider))
{
alreadyCollided = true;
}
if (alreadyCollided)
{
pos = positionAtPreviousFrame;
}
else
{
Vector2 offset = da.offset.FlipFollowDirection(movementComponent.FacingDirection);
pos = (Vector2)targetCollider.bounds.center - offset;
if (movementComponent.FacingDirection == Direction.Right)
{
pos -= new Vector2(targetCollider.bounds.size.x / 2, 0);
}
else
{
pos += new Vector2(targetCollider.bounds.size.x / 2, 0);
}
pos.y = movementComponent.Position.y;
}
}
movementComponent.ForceSetPosition(pos);
cubeShape.SetPos(GetCenterOfHitbox());
dispatched = false;
skill.TriggerEventWithId(da.eventId);
dashRequest.Abort();
}
centerOfHitBoxAtPreviousFrame = centerOfHitbox;
}
positionAtPreviousFrame = movementComponent.Position;
if (IsFinish())
{
ResetColliderToOriginalValues();
}
}
public void MoveUnit(Vector3 direction)
{
_movementComponent.Move(direction);
}
private IEnumerator <float> _LateUpdate()
{
MovementComponent casterMovementComponent = casterEntity.GetComponent <MovementComponent>();
Direction casterFacingDirection = casterMovementComponent.FacingDirection;
Vector2 flippedOffset = info.RagdollModifierConfig.grabOffset.FlipFollowDirection(casterFacingDirection);
Vector3 originalPos = targetRenderer.localPosition;
targetRenderer.localPosition = Vector3.zero;
Vector2 dragTarget = (Vector2)casterWristTransform.position + flippedOffset;
float initialRadius = (dragTarget - (Vector2)targetChest.position).magnitude;
float radiusReductionElapsed = 0;
targetRenderer.localPosition = originalPos;
Vector2 previousPosOfHierarchyRootOfTargetTransform = targetGo.transform.position;
while (true)
{
if (lifetime.IsEnd())
{
break;
}
yield return(Timing.WaitForOneFrame);
originalPos = targetRenderer.localPosition;
targetRenderer.localPosition = Vector3.zero;
if (elapsed < timeUntilFall)
{
casterFacingDirection = casterMovementComponent.FacingDirection;
flippedOffset = info.RagdollModifierConfig.grabOffset.FlipFollowDirection(casterFacingDirection);
dragTarget = (Vector2)casterWristTransform.position + flippedOffset;
if (shouldGraduallyTranslateToDragTarget)
{
radiusReductionElapsed += Time.deltaTime;
float progress = radiusReductionElapsed / info.RagdollModifierConfig.timeToReachDragTargetIfBehind;
progress = Math.Min(1, progress);
float radius = initialRadius * (1 - progress);
Vector2 currentPosOfHierarchyRootOfTargetTransform = targetGo.transform.position;
Vector2 diff = currentPosOfHierarchyRootOfTargetTransform -
previousPosOfHierarchyRootOfTargetTransform;
previousPosOfHierarchyRootOfTargetTransform = currentPosOfHierarchyRootOfTargetTransform;
if (info.RagdollModifierConfig.rootCheck)
{
if (diff == Vector2.zero)
{
continue;
}
}
Vector2 direction = ((Vector2)targetChest.position - dragTarget).normalized;
Vector2 currentDragPos = dragTarget + direction * radius;
Vector2 translation = currentDragPos - (Vector2)targetChest.position;
targetMovementComponent.Move(translation);
}
else
{
Vector2 offset = dragTarget - (Vector2)targetChest.position;
targetMovementComponent.Move(offset);
}
}
targetRenderer.localPosition = originalPos;
}
}
