private ParticlePopulation(JumpPhase jumpPhase, double spawnsPerSecond, double zSpeedPerSecond, Color color)
 {
     JumpPhase       = jumpPhase;
     SpawnsPerSecond = spawnsPerSecond;
     ZSpeedPerSecond = zSpeedPerSecond;
     Color           = color;
 }
Esempio n. 2
0
    void FixedUpdate()
    {
        float gravity = (-2 * maxJumpHeight) / (maxJumpTimeToApex * maxJumpTimeToApex);

        if (inverted)
        {
            gravity *= -1;
        }

        if (jumpPhase == JumpPhase.TerminatedRising)
        {
            gravity *= 3;
        }

        float jumpVelocity = (2 * maxJumpHeight) / maxJumpTimeToApex;

        rigidBody.AddForce(new Vector2(0, gravity) - Physics2D.gravity);

        if (jumpPhase == JumpPhase.Grounded)
        {
            airTime = 0.0f;
        }
        else
        {
            airTime += Time.fixedDeltaTime;
        }

        if (jumpPhase == JumpPhase.PreJump)
        {
            rigidBody.velocity = new Vector2(rigidBody.velocity.x, inverted ? -jumpVelocity : jumpVelocity);
            jumpPhase          = JumpPhase.Rising;
        }

        if (jumpPhase == JumpPhase.Rising)
        {
            bool letgo = Input.touchSupported ? Input.touchCount == 0 : !Input.GetButton("Jump");
            if (airTime >= minJumpTime && letgo)
            {
                jumpPhase = JumpPhase.TerminatedRising;
            }
        }

        if (inverted ? rigidBody.velocity.y > 0 : rigidBody.velocity.y < 0)
        {
            jumpPhase = JumpPhase.Falling;
        }

        if (jumpPhase == JumpPhase.Falling)
        {
            if (groundCheck.GetComponent <Collider2D>().IsTouchingLayers(groundMask))
            {
                SpawnPoof();
                jumpPhase = JumpPhase.Grounded;
            }
        }
    }
Esempio n. 3
0
    // Update is called once per frame
    void Update()
    {
        if (jumpPhase == JumpPhase.Grounded && (Input.GetButtonDown("Jump") || rebound))
        {
            rebound   = false;
            jumpPhase = JumpPhase.PreJump;
        }

        if (jumpPhase == JumpPhase.Falling && Input.GetButtonDown("Jump"))
        {
            rebound = true;
        }
    }
Esempio n. 4
0
    void FixedUpdate()
    {
        float gravity = (-2 * maxJumpHeight) / (maxJumpTimeToApex * maxJumpTimeToApex);

        if (jumpPhase == JumpPhase.TerminatedRising)
        {
            gravity *= 3;
        }

        float jumpVelocity = (2 * maxJumpHeight) / maxJumpTimeToApex;

        rigidBody.AddForce(new Vector2(0, gravity));

        if (jumpPhase == JumpPhase.Grounded)
        {
            airTime = 0.0f;
        }
        else
        {
            airTime += Time.fixedDeltaTime;
        }

        if (jumpPhase == JumpPhase.PreJump)
        {
            rigidBody.velocity = new Vector2(rigidBody.velocity.x, jumpVelocity);
            jumpPhase          = JumpPhase.Rising;
        }

        if (jumpPhase == JumpPhase.Rising)
        {
            if (airTime >= minJumpTime && !Input.GetButton("Jump"))
            {
                jumpPhase = JumpPhase.TerminatedRising;
            }
        }

        if (rigidBody.velocity.y < 0)
        {
            jumpPhase = JumpPhase.Falling;
        }

        if (jumpPhase == JumpPhase.Falling)
        {
            if (Physics2D.OverlapArea(groundCheckTopLeft.position, groundCheckBottomRight.position, groundMask))
            {
                jumpPhase = JumpPhase.Grounded;
            }
        }
    }
Esempio n. 5
0
    // Update is called once per frame
    void Update()
    {
        bool jump = Input.GetButtonDown("Jump");

        if (Input.touchCount > 0 && Input.touches[0].phase == TouchPhase.Began)
        {
            jump = true;
        }


        if (jumpPhase == JumpPhase.Grounded && (jump || rebound))
        {
            rebound    = false;
            secondJump = false;
            jumpPhase  = JumpPhase.PreJump;
            AudioSource.PlayClipAtPoint(jumpSound, this.rigidBody.transform.position);
        }
        else if (canDoubleJump && !secondJump && jumpPhase != JumpPhase.Grounded && jump)
        {
            airTime = 0.0f;             // Reset air-time.

            rebound    = false;
            secondJump = true;
            jumpPhase  = JumpPhase.PreJump;
        }

        if (jumpPhase == JumpPhase.Falling && jump)
        {
            rebound = true;
        }


        // Detects if player ever falls off screen. If so, kill him!
        if (transform.position.y < cam.transform.position.y - cameraHeight / 2)
        {
            this.GetComponent <HealthManager> ().Kill();
        }
    }
Esempio n. 6
0
        protected override void OnRender(ChromaCanvas canvas)
        {
            if (Game.FsdJumpType == FsdJumpType.None)
            {
                StopAnimation();
                _particleField.Clear();
                _lastTick = null;
                return;
            }

            StartAnimation();

            var deltaT = Now - (_lastTick ?? Now);

            _lastTick = Now;

            JumpPhase phase = GetJumpPhase();

            foreach (var p in _population)
            {
                if (p.JumpPhase != phase)
                {
                    continue;
                }

                _particleField.Add(p.SpawnsPerSecond * deltaT.TotalSeconds, p.Color, p.ZSpeedPerSecond);
            }

            _particleField.MoveAndDraw(deltaT, canvas);

            if (!Game.InWitchSpace)
            {
                return;
            }

            RenderHazardLevel(canvas);
        }
Esempio n. 7
0
    public void Refresh(Vector2 velocity, Vector2 input, Vector2 groundNormal, Vector2 groundPos, bool grounded, bool wallSliding, bool jumped, bool wallJumped, bool bounced, bool dead)
    {
        // change state if needed:

        bool wasIdle        = this.state == State.Idle;
        bool wasRunning     = this.state == State.Run;
        bool wasJumping     = this.state == State.Jump || this.state == State.WallJump;
        bool wasWallJumping = false;

        if (this.state == State.Dead && !dead)
        {
            this.state = State.Idle;
        }

        string runAnimName = "Run";

        switch (this.state)
        {
        case State.Idle:
        {
            if (jumped || (!grounded && Mathf.Abs(velocity.y) > this.fallSpeedThreshold))
            {
                this.state = State.Jump;
            }
            else
            {
                if (Mathf.Abs(input.x) > 0.4f)
                {
                    this.state = State.Run;
                }
            }
        }
        break;

        case State.Jump:
        {
            if (grounded)
            {
                if (Mathf.Abs(input.x) > 0.4f)
                {
                    this.state = State.Run;
                }
                else
                {
                    this.state = State.Idle;
                }
            }
            else if (wallSliding && velocity.y < 0)
            {
                this.state = State.WallSlide;
            }
        }
        break;

        case State.Run:
        {
            if (jumped || (!grounded && Mathf.Abs(velocity.y) > this.fallSpeedThreshold))
            {
                this.state = State.Jump;
            }
            else if (wallSliding && velocity.y < 0)
            {
                this.state = State.WallSlide;
            }
            else if (Mathf.Abs(input.x) <= 0.4f)
            {
                this.state = State.Idle;
            }
        }
        break;

        case State.WallSlide:
        {
            if (wallJumped)
            {
                this.state = State.WallJump;
            }
            else
            {
                if (!wallSliding)
                {
                    this.state = State.Jump;         // falling down
                }
            }
        }
        break;

        case State.WallJump:
        {
            wasWallJumping = true;
            this.state     = State.Jump;
        }
        break;
        }


        if (dead && this.state != State.Dead)
        {
            this.state = State.Dead;

            this.bounceParticles.Stop();
        }


        // state logic:

        switch (this.state)
        {
        case State.Idle:
        {
            if (!wasIdle)
            {
                if (wasRunning)
                {
                    this.idleAnimName = "IdleSlowdown";
                    PlayDust(groundPos, groundNormal, this.dustStopPrefab);
                }
                else if (wasJumping)
                {
                    this.idleAnimName = "JumpLand";
                    Landed(groundPos, groundNormal);
                }
                else
                {
                    this.idleAnimName = "Idle";
                }
            }
            else
            {
                if (this.idleAnimName == "IdleCapeWave")
                {
                    if (this.frame == 0)
                    {
                        this.idleAnimName = "Idle";
                    }
                }
                else if (this.idleAnimName != "Idle")
                {
                    if (this.finishedSingleShot)
                    {
                        this.idleAnimName = "Idle";
                    }
                }
                else
                {
                    if (this.frame == 0 && Random.value < 0.02f)
                    {
                        this.idleAnimName = "IdleCapeWave";
                    }
                }
            }
        }
        break;

        case State.Jump:
        {
            if ((!wasJumping && jumped) || wallJumped)
            {
                SoundManager.instance.PlayPlayerJumpSfx();
            }

            if (Mathf.Abs(velocity.y) < this.jumpMidPointSpeedThreshold)
            {
                this.jumpPhase = JumpPhase.MidPoint;
            }
            else if (velocity.y > 0)
            {
                this.jumpPhase = JumpPhase.Up;
            }
            else if (velocity.y > -this.jumpDownSlowSpeedThreshold)
            {
                this.jumpPhase = JumpPhase.DownSlow;
            }
            else
            {
                this.jumpPhase = JumpPhase.DownFast;
            }
        }
        break;

        case State.Run:
        {
            if (!wasRunning)
            {
                if (wasJumping)
                {
                    Landed(groundPos, groundNormal);
                }
            }

            if (Time.time - this.lastStepSfxTime > this.stepPeriod)
            {
                SoundManager.instance.PlayPlayerStepSfx();
                this.lastStepSfxTime = Time.time + Random.value * this.stepPeriodRand;
            }

            if (Time.time - this.lastStepDustTime > this.dustStepPeriod)
            {
                PlayDust(groundPos, groundNormal, this.dustRunPrefab);
                this.lastStepDustTime = Time.time + Random.value * this.dustStepPeriodRand;
            }
        }
        break;

        case State.WallSlide:
        {
        }
        break;

        case State.WallJump:
        {
            if (wallJumped)
            {
                SoundManager.instance.PlayPlayerJumpSfx();
            }
        }
        break;
        }


        // set active animation according to state:

        switch (this.state)
        {
        case State.Idle:
            SetActive(this.idleAnimName);
            break;

        case State.Run:
            SetActive(runAnimName);
            break;

        case State.WallSlide:
            SetActive("Wallslide1");
            break;

        case State.WallJump:
            SetActive("Walljump");
            break;

        case State.Jump:
            switch (this.jumpPhase)
            {
            case JumpPhase.Up:
                SetActive("JumpUp", true, !wasWallJumping);         // don't reset timer in case we're coming from wall jump
                break;

            case JumpPhase.MidPoint:
                SetActive("JumpMidPoint");
                break;

            case JumpPhase.DownSlow:
                SetActive("JumpDownSlow");
                break;

            case JumpPhase.DownFast:
                SetActive("JumpDownFast");
                break;
            }
            break;

        case State.Dead:
            SetActive("Death");
            break;
        }

        // misc:
        if (bounced)
        {
            this.bounceParticles.Play();
        }
    }
    public void Refresh(Vector2 velocity, bool grounded, bool jumped, bool prepareForJump, bool landed, bool dead)
    {
        // change state:

        switch (this.state)
        {
        case State.Ground:
        {
            if (jumped || (!grounded && Mathf.Abs(velocity.y) > this.fallSpeedThreshold))
            {
                if (jumped)
                {
                    SoundManager.instance.PlayAtPosition(SoundId.BouncyEnemyJump, this.transform.position);
                }
                this.state = State.Jump;
            }
            else if (dead)
            {
                SoundManager.instance.PlayAtPosition(SoundId.BouncyEnemyDeath, this.transform.position);
                this.state = State.Dead;
            }
            else if (prepareForJump)
            {
                this.state = State.JumpPrepare;
            }
        }
        break;

        case State.JumpPrepare:
        {
            if (jumped || (!grounded && Mathf.Abs(velocity.y) > this.fallSpeedThreshold))
            {
                if (jumped)
                {
                    SoundManager.instance.PlayAtPosition(SoundId.BouncyEnemyJump, this.transform.position);
                }
                this.state = State.Jump;
            }
            else if (dead)
            {
                SoundManager.instance.PlayAtPosition(SoundId.BouncyEnemyDeath, this.transform.position);
                this.state = State.Dead;
            }
            else if (!prepareForJump)
            {
                this.state = State.Ground;
            }
        }
        break;

        case State.Jump:
        {
            if (landed || grounded)
            {
                SoundManager.instance.PlayAtPosition(SoundId.BouncyEnemyLand, this.transform.position);
                this.state = State.JumpLand;
            }
        }
        break;

        case State.JumpLand:
        {
            if (jumped || (!grounded && Mathf.Abs(velocity.y) > this.fallSpeedThreshold))
            {
                if (jumped)
                {
                    SoundManager.instance.PlayAtPosition(SoundId.BouncyEnemyJump, this.transform.position);
                }
                this.state = State.Jump;
            }
            else if (!landed)
            {
                this.state = State.Ground;
            }
        }
        break;
        }

        // state logic:

        if (this.state == State.JumpPrepare)
        {
            this.transform.localPosition = this.airLocalPos;
        }
        else
        {
            this.transform.localPosition = this.normalLocalPos;
        }

        switch (this.state)
        {
        case State.Jump:
        {
            if (Mathf.Abs(velocity.y) < this.jumpMidPointSpeedThreshold)
            {
                this.jumpPhase = JumpPhase.MidPoint;
            }
            else if (velocity.y > 0)
            {
                this.jumpPhase = JumpPhase.Up;
            }
            else
            {
                this.jumpPhase = JumpPhase.Down;
            }
        }
        break;

        case State.Dead:
        {
            if (this.finishedSingleShot)
            {
                this.enemy.FullDeath();
            }
        }
        break;
        }

        // set animation according to state:
        switch (this.state)
        {
        case State.Ground:
        {
            SetActive("Ground");
        }
        break;

        case State.JumpPrepare:
        {
            SetActive("JumpKick");
        }
        break;

        case State.Jump:
        {
            switch (this.jumpPhase)
            {
            case JumpPhase.Up:
                SetActive("JumpUp");
                break;

            case JumpPhase.MidPoint:
                SetActive("JumpMid");
                break;

            case JumpPhase.Down:
                SetActive("JumpDown");
                break;
            }
        }
        break;

        case State.JumpLand:
        {
            SetActive("JumpLand");
        }
        break;

        case State.Dead:
        {
            SetActive("Death");
        }
        break;
        }
    }