示例#1
0
	//TODO: allow owner of hook to destroy it if he hooks a platform, synchornize this somehow.
	void ShootHookLocal(float originX, float originY, float targetX, float targetY){
		shootOrigin = new Vector3(originX, originY, transform.position.z);
		GameObject go  = (GameObject)Instantiate(hook, shootOrigin, transform.rotation);
		currentState = HookState.GoingOut;
		currentHook = go.GetComponent<HookHit>();
		if(!OFFLINE)
			currentHook.SetColor(PlayerServerInfo.Instance.GetPlayerOptions(networkController.theOwner).style);
		else 
		{
			currentHook.SetColor(CharacterStyle.BLUE);
		}
		currentHook.networkController = networkController;
		currentHook.shooter = gameObject;
		//hooktimer = 1.5f;
		//Calculate angle from player to mouse and rotate hook that way.
		Vector3 target =  new Vector3(targetX, targetY, transform.position.z);
		Vector3 difference = target - shootOrigin;
		Vector2 direction = new Vector2(difference.x, difference.y).normalized;
		targetDistanceSqrd = difference.sqrMagnitude;
		//mousePos = transform.position + 100f * direction;
		
		targetPosition = target;
		float angle = Mathf.Atan2(direction.y, direction.x) * Mathf.Rad2Deg;
		go.transform.rotation = Quaternion.AngleAxis(angle, Vector3.forward);
		go.rigidbody2D.velocity = direction * speedRatio;
		
	}
 void PreviewObject(GameObject previewTarget)
 {
     chain.enabled        = true;
     chain.material.color = new Color(1, 1, 1, 0.25f);
     hookState            = HookState.Preview;
     previewObject        = previewTarget;
 }
示例#3
0
        public override void Deserialize(int[] data, int dataOffset)
        {
            if (!RangeCheck(data, dataOffset))
            {
                return;
            }

            Tick = data[dataOffset + 0];
            PosX = data[dataOffset + 1];
            PosY = data[dataOffset + 2];
            VelX = data[dataOffset + 3];
            VelY = data[dataOffset + 4];

            Angle        = data[dataOffset + 5];
            Direction    = data[dataOffset + 6];
            Jumped       = data[dataOffset + 7];
            HookedPlayer = data[dataOffset + 8];
            HookState    = (HookState)data[dataOffset + 9];
            HookTick     = data[dataOffset + 10];
            HookX        = data[dataOffset + 11];
            HookY        = data[dataOffset + 12];
            HookDx       = data[dataOffset + 13];
            HookDy       = data[dataOffset + 14];

            PlayerFlags = (PlayerFlags)data[dataOffset + 15];
            Health      = data[dataOffset + 16];
            Armor       = data[dataOffset + 17];
            AmmoCount   = data[dataOffset + 18];
            Weapon      = (Weapon)data[dataOffset + 19];
            Emote       = (Emote)data[dataOffset + 20];
            AttackTick  = data[dataOffset + 21];
        }
示例#4
0
        private void Update()
        {
            switch (state)
            {
            case HookState.Activate:
                transform.Translate(Vector3.forward * velocity * Time.deltaTime, Space.Self);
                MakeRope();
                if (attachingHero.photonView.IsMine)
                {
                    if (transform.localPosition.z > maxLength)
                    {
                        state    = HookState.Retrieve;
                        velocity = 0f;
                        attachingHero.photonView.RPC("HookRetrieve", Photon.Pun.RpcTarget.All);
                    }
                }

                break;

            case HookState.Retrieve:
                transform.Translate(Vector3.back * velocity * Time.deltaTime, Space.Self);
                MakeRope();

                if (attachingHero.photonView.IsMine)
                {
                    if (transform.localPosition.z < Mathf.Epsilon)
                    {
                        state = HookState.DeActivate;
                        attachingHero.photonView.RPC("HookIsDone", Photon.Pun.RpcTarget.All);
                    }
                }
                break;
            }
        }
示例#5
0
    void HookShooting()
    {
        nextHookPosition     = transform.position;
        currentFrameDistance = Vector3.Distance(nextHookPosition, hookPositionBeforeShooting);

        if (hookState == HookState.firedTowardsTarget)
        {
            nextHookPosition -= transform.up * shootingSpeed * Time.deltaTime;

            if (currentFrameDistance > maxShootingDistance)
            {
                hookState = HookState.firedGoingBack;
            }
        }

        else if (hookState == HookState.firedGoingBack)
        {
            nextHookPosition += transform.up * shootingSpeed * Time.deltaTime;
            if (currentFrameDistance < 5f && currentFrameDistance > lastFrameDistance)
            {
                // hook came back to it's starting position
                OnHookCameBack();
            }
        }

        transform.position = nextHookPosition;
        lastFrameDistance  = currentFrameDistance;
    }
示例#6
0
 public void OnHookCameBack()
 {
     nextHookPosition = hookPositionBeforeShooting;
     hookState        = HookState.rotating;
     GetComponent <Aiming>().enabled = true; // enable aiming
     if (HookedCollectable)
     {
         if (HookedCollectable.gameObject.GetComponent <ManaCollectable>() != null) // collectable is mana type
         {
             GetComponentInParent <Tower>().OnCollectableCatch(HookedCollectable.gameObject);
             HookedCollectable = null;
             FindObjectOfType <AudioManager>().Play("Hook Tower");
         }
         else // collectable is shield type
         {
             if (isHoldingShield)
             {
                 // this shield collectable already came back to base
                 Destroy(HookedCollectable.gameObject);
                 FindObjectOfType <AudioManager>().Play("Hook Tower");
                 HookedCollectable = null;
                 isHoldingShield   = false;
             }
             else
             {
                 isHoldingShield = true;
                 HookedCollectable.gameObject.GetComponent <ShieldCollectable>().switchToShield();
             }
         }
     }
     else // no collectable hooked
     {
         isHoldingShield = false;
     }
 }
示例#7
0
 void OnCollisionEnter2D(Collision2D collision)
 {
     if (collision.gameObject.CompareTag("Wall"))
     {
         hookState = HookState.firedGoingBack;
     }
 }
示例#8
0
    private void Shooting()
    {
        float sqrDist    = Vector2.SqrMagnitude((Vector2)grasp.position - hookedPos);
        float hookedDist = Mathf.Pow(Time.deltaTime * shotSpeed, 2);

        if (sqrDist > hookedDist) //훅이 날아가는 중
        {
            hookedRot = Quaternion.Euler(0, 0, Math2D.LookAt2D(player.position, hookedPos)).eulerAngles.z;

            grasp.position   += ((Vector3)hookedPos - grasp.position).normalized * Time.deltaTime * shotSpeed;
            grasp.eulerAngles = new Vector3(0, 0, hookedRot);
        }
        else
        {
            if (hookedTr != null)
            {
                state             = HookState.Hooked;
                grasp.position    = hookedPos;
                grasp.eulerAngles = new Vector3(0, 0, hookedRot);
                nowChainDistance  = Vector2.Distance(player.position, grasp.position);

                Player.instance.SwingStart(hookedPos);
                chainCtrl.ChainConnect(chainStart, chainEnd);
            }
            else
            {
                state = HookState.Returning;
            }
        }
    }
示例#9
0
 private void Sparked()
 {
     sparkParticle.transform.position    = hookedPos;
     sparkParticle.transform.eulerAngles = grasp.eulerAngles;
     sparkParticle.Play();
     state = HookState.Returning;
 }
示例#10
0
 private void SetTarget(Transform newTarget)
 {
     _target = newTarget;
     _lineRenderer.SetPosition(1, _target.position);
     _state = HookState.Hooked;
     _animator.SetTrigger("Hit");
 }
示例#11
0
    public void PullToHook()
    {
        hookState = HookState.returning;

        audioSource.clip = returnSound;
        audioSource.Play();
    }
示例#12
0
 /// <summary>
 /// What to do when the object is grabbed
 /// </summary>
 /// <param name="collision"></param>
 internal void OnObjectGrabbed(Collider2D hookable)
 {
     targetHookable = hookable.GetComponent <IHookable>();
     targetHookable.Hook(hookPos.transform);
     targetTransform = hookable.transform;
     state           = HookState.Hooked;
 }
示例#13
0
 /// <summary>
 /// Throw object
 /// </summary>
 private void ThrowHookedObject(Vector2 direction)
 {
     if (targetHookable == null)
     {
         Clear();
         return;
     }
     else if (state == HookState.Held || throwObject)
     {
         if (targetHookable != null)
         {
             targetHookable.Throw(direction * throwSpeed);
             playerController.audioSource.PlayOneShot(playerController.throwSound);
         }
         Clear();
         if (throwObject)
         {
             throwObject = false;
         }
         lockBackthrowTarget = false;
     }
     else if (state == HookState.Swinging)
     {
     }
     state = HookState.Empty;
 }
示例#14
0
 private void CheckIfMissedTarget()
 {
     if (_state == HookState.Forward && Vector3.Distance(transform.position, _target.position) < 0.1f)
     {
         _state = HookState.Reverse;
     }
 }
示例#15
0
 void StartPullPlayer()
 {
     DestroyJoints();
     PlayerGlobal.Instance.Is_Swinging = false;
     Debug.Log("Start pull player");
     UnregisterMouseDelegates();
     m_HookState = HookState.Pulling_Player;
 }
示例#16
0
 public HookShot(PhysicalUnit owner)
     : base(TimeSpan.FromSeconds(FIRE_DELAY), owner)
 {
     _hookState   = HookState.Idle;
     _hookSprite  = new Sprite("HookClaw", Sprite.SpriteType.Projectile);
     _chainSprite = new Sprite("HookChain", Sprite.SpriteType.Projectile);
     _hookHitRect = new Rectangle(0, 0, (int)_hookSprite.Width, (int)_hookSprite.Height);
 }
示例#17
0
 //Coge el estado del gancho y llama a soltar el quimico
 void Update()
 {
     if (estadoAct != null)
     {
         estadoGancho = estadoAct.daEstado();
         SoltarQuimico();
     }
 }
示例#18
0
 public HookShot(PhysicalUnit owner)
     : base(TimeSpan.FromSeconds(FIRE_DELAY), 1, 0, owner)
 {
     _hookState = HookState.Idle;
     _hookSprite = new Sprite("HookClaw");
     _chainSprite = new Sprite("HookChain");
     _hookHitRect = new Rectangle(0, 0, (int)_hookSprite.Width, (int)_hookSprite.Height);
 }
示例#19
0
 void Start()
 {
     puntoLanzamiento = Player.transform.GetChild(1);
     dir       = Vector2.right;
     currState = HookState.Quieto;
     movement  = Vector2.zero;
     shooting  = 0;
 }
示例#20
0
 //用状态机重新实现钩锁功能(没有目标就无法发射版本)
 public void Shoot(Vector2 position)
 {
     //确保每一次发射钩锁都有finaljump的一次机会
     finalJump = false;
     //设置状态
     state          = HookState.HookToTarget;
     targetPosition = position;
 }
示例#21
0
 // Use this for initialization
 void Start()
 {
     grabed          = returning = false;
     player_position = transform.position;
     joint           = GetComponent <DistanceJoint2D>();
     CalculateDirection();
     hookState = Throw;
 }
        protected override void UpdateWeapon(GameTime gameTime)
        {
            switch (_hookState)
            {
            case (HookState.Idle):
            {
                if (_firing)
                {
                    _hookState    = HookState.Fired;
                    _hookPosition = _owner.Position;
                    _hookAngle    = XnaHelper.RadiansFromVector(_fireDirection);
                    _hookVelocity = _fireDirection * HOOK_SPEED;
                }
                break;
            }

            case (HookState.Fired):
            {
                if (!(_firing) &&
                    Vector2.Distance(_hookPosition, _owner.Position) < MAX_RANGE)
                {
                    _hookPosition += _hookVelocity;
                    _hookHitRect.X = (int)_hookPosition.X;
                    _hookHitRect.Y = (int)_hookPosition.Y;
                }
                else
                {
                    _hookState = HookState.Retracting;
                }

                break;
            }

            case (HookState.Retracting):
            {
                _hookPosition -= HOOK_SPEED * Vector2.Normalize(_hookPosition - _owner.Center);
                if (XnaHelper.PointInRect(_hookPosition, _owner.HitRect))
                {
                    _hookState = HookState.Idle;
                }
                break;
            }

            case (HookState.Attached):
            {
                _hookPosition = _hookedUnit.Center;
                Vector2 pullForce = HOOK_FORCE * XnaHelper.DirectionBetween(_owner.Position, _hookedUnit.Position);
                _owner.ApplyForce(pullForce);
                _hookedUnit.ApplyForce(Vector2.Negate(pullForce));

                if (_firing)
                {
                    _hookState = HookState.Idle;
                }
                break;
            }
            }
        }
示例#23
0
    public void ShotTheHook(Vector3 mousePosition, Vector3 startPos)
    {
        if (state == HookState.Hooked)
        {
            ReturnTheHook();
            return;
        }
        else if (state != HookState.Holding)
        {
            return;
        }

        ImpulseManager.instance.GenerageImpuse(ImpulseManager.ImpulseSelect.Hook);
        Vector2      dir = mainCamera.ScreenToWorldPoint(mousePosition) - startPos;
        RaycastHit2D hit = Physics2D.Raycast(startPos, dir, maxChainDistance, hookableLayer);

        grasp.gameObject.SetActive(true);

        if (hit)
        {
            if (hit.collider.CompareTag("Hookable") || hit.collider.CompareTag("HookableAndThrough") || hit.collider.CompareTag("HookEvent")) //훅 성공
            {
                hookedTr  = hit.transform;
                targetPos = (Vector2)hookedTr.position - hit.point;

                grasp.localPosition = originPos;
                grasp.eulerAngles   = new Vector3(0, 0, Quaternion.Euler(0, 0, Math2D.LookAt2D(player.position, hit.point)).eulerAngles.z);

                state = HookState.Shooting;

                Player.instance.animator.SetBool("isShoting", true);
            }
            else //팅김
            {
                hookedTr  = hit.transform;
                targetPos = (Vector2)hookedTr.position - hit.point;

                grasp.localPosition = originPos;
                grasp.eulerAngles   = new Vector3(0, 0, Quaternion.Euler(0, 0, Math2D.LookAt2D(player.position, hit.point)).eulerAngles.z);

                state = HookState.Sparking;

                Player.instance.animator.SetBool("isShoting", true);
            }
        }
        else //닿지도 못할 예정
        {
            hookedTr  = null;
            targetPos = (Vector2)startPos + dir.normalized * maxChainDistance;

            grasp.localPosition = originPos;
            grasp.eulerAngles   = new Vector3(0, 0, Quaternion.Euler(0, 0, Math2D.LookAt2D(player.position, targetPos)).eulerAngles.z);

            state = HookState.Shooting;

            Player.instance.animator.SetBool("isShoting", true);
        }
    }
示例#24
0
 public void SetState(HookState pState)
 {
     if (_abstractState != null)
     {
         _abstractState.Refresh();
     }
     _abstractState = _stateCache[pState];
     _abstractState.Start();
 }
示例#25
0
 private void LatchOn(GameObject other)
 {
     mState         = HookState.Attached;
     mLatchedTarget = other;
     if (mLatchNoise != null)
     {
         mLatchNoise.Play();
     }
 }
示例#26
0
    public void ResetHook()
    {
        state = HookState.Holding;
        grasp.localPosition    = originPos;
        grasp.localEulerAngles = Vector3.zero;

        chainCtrl.ChainReset();
        grasp.gameObject.SetActive(false);
    }
示例#27
0
 public void DeActivate()
 {
     state                 = HookState.DeActivate;
     hookedEnemy           = null;
     hookSuccessTime       = 0f;
     hookSuccessReturnTime = 0f;
     transform.SetPositionAndRotation(originPosFromheroHook.position, originPosFromheroHook.rotation);
     gameObject.SetActive(false);
 }
示例#28
0
 internal void Clear(bool throwObj = false)
 {
     if (targetHookable != null && throwObj)
     {
         targetHookable.Throw(Vector2.zero);
     }
     targetHookable  = null;
     targetTransform = null;
     state           = HookState.Empty;
 }
示例#29
0
 public override void Unhhooked(HookController controller, HookState state)
 {
     if (triggetEndAction)
     {
         foreach (TargetAction ta in targetActions)
         {
             ta.EndAction();
         }
     }
 }
示例#30
0
 public void StartHooking()
 {
     gameObject.SetActive(true);
     mState             = HookState.Hooking;
     transform.position = Origin;
     mRendererObject.transform.rotation = Quaternion.identity;
     mRendererObject.transform.Rotate(transform.forward, RAD2DEG * Mathf.Atan2(mDirection.y, mDirection.x) - 90);
     mLineRenderer.SetPosition(0, Origin);
     mLineRenderer.SetPosition(1, Origin);
 }
示例#31
0
    private void Start()
    {
        _hookVisual = Instantiate(_hookPrefab).transform;
        _hookVisual.gameObject.SetActive(false);

        _hookEnd = Instantiate(_hookEndPrefab).transform;
        _hookEnd.gameObject.SetActive(false);

        State = HookState.Off;
    }
示例#32
0
 public override void CheckAndApplyCollision(PhysicalUnit unit, TimeSpan time)
 {
     if (_hookState == HookState.Fired || _hookState == HookState.Retracting)
     {
         if (XnaHelper.RectsCollide(_hookHitRect, unit.HitRect))
         {
             _hookedUnit = unit;
             _hookState = HookState.Attached;
         }
     }
 }
示例#33
0
    public void StartShoot(float t_Shoot_Distance, Vector3 t_shoot_Direction, Vector3 t_Start_Position, Quaternion t_Rotation)
    {
        //Set shoot position, direction, rotation and timer;
        transform.position = t_Start_Position;
        shoot_Direction    = t_shoot_Direction;
        transform.rotation = t_Rotation;
        max_Shoot_Distance = t_Shoot_Distance;

        m_HookState = HookState.Shooting;
        PlayerGlobal.Instance.Is_Shooting_Hook = true;
    }
示例#34
0
    public void ChangeState(HookStates state)
    {
        if (_state != null)
        {
            _state.Dispose();
            _state = null;
        }

        _state = _stateFactory.CreateState(state);
        _state.Start();
    }
示例#35
0
 public HookShot(PhysicalUnit owner)
     : base(new WeaponData
     {
         Name = "Hookshot",
         FireRate = c_fireRate,
     },
     owner)
 {
     _hookState = HookState.Idle;
     _hookSprite = new Sprite("HookClaw", SpaceGame.graphics.Sprite.SpriteType.Projectile);
     _chainSprite = new Sprite("HookChain", SpaceGame.graphics.Sprite.SpriteType.Projectile);
     _hookHitRect = new Rectangle(0, 0, (int)_hookSprite.Width, (int)_hookSprite.Height);
 }
示例#36
0
    public void Fire()
    {
        if (spedUp) {
            resetSpeed();
        }
        // HACK, we can return immediately if outside bounds of arena
        if (GameController.outOfBounds(transform.position)){
            Debug.Log("out of bounds");
            return;
        }

        state = HookController.HookState.Traveling;
        transform.position = playerTransform.position + grappleOffset;
        velocity = trajectory;
    }
示例#37
0
	public void ReturnHook(){
		if(currentHook == null)
			return;

		if(currentState == HookState.PullingPlayer)
		{
			currentHook.affectedPlayerC2D.UnHooked();
			controller2D.FreeFromSnare();
		}

		currentState = HookState.GoingBack;
		/* Physics.
		Vector3 difference = transform.position - currentHook.gameObject.transform.position;
		Vector2 direction = new Vector2(difference.x, difference.y).normalized;
		Vector2 velocity = direction * speedRatio;
		*/
		currentHook.collider2D.enabled = false;
		currentHook.rigidbody2D.isKinematic = true;
		currentHook.rigidbody2D.velocity = Vector2.zero;
		currentHook.returning = true;
	}
示例#38
0
	private void DestroyHookSoft()
	{
		slowedTime = 0f;
		transform.rigidbody2D.gravityScale = 1;
		currentHook.renderer.enabled = false;
		currentHook.HideLines();
		currentState = HookState.Hidden;
	}
示例#39
0
	private void DestroyHook(){
		slowedTime = 0f;
		transform.rigidbody2D.gravityScale = 1;
		currentState = HookState.None;
		controller2D.FreeFromSnare();
		if(currentHook != null){
			if(currentHook.affectedPlayerC2D != null){
				currentHook.affectedPlayerC2D.UnHooked();
			}
			Destroy(currentHook.gameObject);
			currentHook = null;
		}
	}
示例#40
0
	void HitPlayer(float playerLocationX, float playerLocationY, NetworkPlayer hitPlayer, NetworkMessageInfo info){
		
		if(currentHook == null || currentState == HookState.GoingBack){ //ignore hooking if were retracting.
			print ("too late");
			return;
		}
		if(currentState == HookState.Hidden)
		{
			currentHook.renderer.enabled = false;
			currentHook.HideLines();
		}
		
		currentState = HookState.PullingPlayer;
		this.hitPlayer = hitPlayer;
		Vector3 playerLocation = new Vector3(playerLocationX, playerLocationY, transform.position.z);
		currentHook.gameObject.transform.position = playerLocation;
		currentHook.hookedPlayer = SessionManager.Instance.psInfo.GetPlayerGameObject(hitPlayer);
		currentHook.affectedPlayerC2D = currentHook.hookedPlayer.GetComponent<Controller2D>();
		currentHook.affectedPlayerC2D.Hooked(networkController.theOwner);
		currentHook.targetPosition = playerLocation;
		currentHook.playerhooked = true;
		controller2D.Snare();
		hittimer = 2f;
		hooktimer = 1.5f;
	}
示例#41
0
	//To be called by HookHit
	public void HitPlayerLocal(NetworkPlayer hitPlayer)
	{
		this.hitPlayer = hitPlayer;
		hooktimer = 1.5f;
		hittimer = 2f;
		currentState = HookState.PullingPlayer;
		controller2D.Snare();
		if(!OFFLINE)
			networkView.RPC ("HitPlayer", RPCMode.Others, currentHook.transform.position.x, currentHook.transform.position.y, hitPlayer);
	}
示例#42
0
 void Start()
 {
     playerTransform = player.transform;
     state = HookState.Sheathed;
     transform.position = playerTransform.position + grappleOffset;
 }
示例#43
0
 public void Attach()
 {
     velocity = Vector3.zero;
     state = HookState.Attached;
 }
示例#44
0
        protected override void UpdateWeapon(GameTime gameTime)
        {
            switch (_hookState)
            {
                case (HookState.Idle):
                    {
                        if (_firing)
                        {
                            _hookState = HookState.Fired;
                            _hookPosition = _owner.Position;
                            _hookAngle = XnaHelper.RadiansFromVector(_fireDirection);
                            _hookVelocity = _fireDirection * HOOK_SPEED;
                        }
                        break;
                    }
                case (HookState.Fired):
                    {
                        if (!(_firing) &&
                            Vector2.Distance(_hookPosition, _owner.Position) < MAX_RANGE)
                        {
                            _hookPosition += _hookVelocity;
                            _hookHitRect.X = (int)_hookPosition.X;
                            _hookHitRect.Y = (int)_hookPosition.Y;
                        }
                        else
                        {
                            _hookState = HookState.Retracting;
                        }

                        break;
                    }
                case (HookState.Retracting):
                    {
                        _hookPosition -= HOOK_SPEED * Vector2.Normalize(_hookPosition - _owner.Center);
                        if (XnaHelper.PointInRect(_hookPosition, _owner.HitRect))
                            _hookState = HookState.Idle;
                        break;
                    }
                case (HookState.Attached):
                    {
                        _hookPosition = _hookedUnit.Center;
                        Vector2 pullForce = HOOK_FORCE * XnaHelper.DirectionBetween(_owner.Position, _hookedUnit.Position);
                        _owner.ApplyForce(pullForce);
                        _hookedUnit.ApplyForce(Vector2.Negate(pullForce));

                        if (_firing)
                        {
                            _hookState = HookState.Idle;
                        }
                        break;
                    }
            }
        }
示例#45
0
	public void HitPlatform(){
		hittimer = 1.5f;
		currentState = HookState.PullingSelf;
	}