Beispiel #1
0
    IEnumerator Start()
    {
        instance   = this;
        startPoint = GameObject.Find(THROWING_POINT_NAME).transform;

        currentPoint = -1;
        nextPoint    = -1;

        while (true)
        {
            yield return(new WaitForSeconds(waitTime));

            if (GameManager.Instance.isGameRunning())
            {
                if (!RunningGameModule.Instance.isTutorialRunning())
                {
                    if (shootPoints == null)
                    {
                        shootPoints = generateShootPoints();
                    }

                    fireBullet();
                }
            }
        }
    }
Beispiel #2
0
 private void Start()
 {
     mProjectileThrower = GetComponentInChildren <ProjectileThrower>();
     mSimpleMovement    = GetComponent <SimpleMovement>();
     mCollisionMap      = GameObject.FindObjectOfType <CollisionMap>();
     mTeleport          = GetComponent <EnemyTeleport>();
 }
Beispiel #3
0
 private void Start()
 {
     projectilesManager = FindObjectOfType <ProjectilesManager>();
     projectileThrower  = FindObjectOfType <ProjectileThrower>();
     rig          = GetComponent <Rigidbody>();
     meshRenderer = GetComponent <MeshRenderer>();
 }
Beispiel #4
0
    protected override void onStart()
    {
        _instance = this;
        _gameData = (CalorieDefenceGameData)CurrentGameData;

        time         = 0.0f;
        feverTime    = 0.0f;
        _isFeverTime = false;

        NumberOfCollision = new int[projectiles.Length];
        for (int i = 0; i < projectiles.Length; i++)
        {
            NumberOfCollision[i] = 0;
        }

        if (ProjectileThrower.getInstance() != null)
        {
            ProjectileThrower.getInstance().reset();
        }

        timer.color = Color.white;
        resetCombo();

        foodIdArrayCreate();
        loadFoodImages();

        showTutorialMenu();
    }
Beispiel #5
0
 protected override void onActionFinished()
 {
     //(!) 임시로 인덱스 고정해서 사용
     if (_currentIndex == 14)
     {
         if (_defenceCount < 3)
         {
             ProjectileThrower.getInstance().fireBulletForTutorial();
             return;
         }
     }
     base.onActionFinished();
 }
 // Use this for initializationF
 void Start()
 {
     velocity          = Vector2.zero;
     currentState      = PlayerState.STAND;
     onGround          = false;
     pushingWallLeft   = false;
     pushingWallRight  = false;
     againstCeiling    = false;
     isWalkingLeft     = false;
     touchingCeiling   = false;
     isHolding         = false;
     anim              = gameObject.GetComponent <Animator> ();
     audioMngr         = GetComponent <PlayerAudio> ();
     projectileThrower = GetComponentInChildren <ProjectileThrower>();
 }
Beispiel #7
0
    protected override void Start()
    {
        base.Start();

        mEnemy             = GetComponent <Enemy>();
        mTeleport          = GetComponent <EnemyTeleport>();
        mSimpleMovement    = GetComponent <SimpleMovement>();
        mSimpleAttack      = GetComponent <SimpleAttack>();
        mProjectileThrower = GetComponent <ProjectileThrower>();

        mEnemy.SetEnemyAI(this);
        mKillable.onHit += OnHit;

        Game.instance.hud.bossHealth.gameObject.SetActive(true);
        Game.instance.hud.bossHealth.SetWithValues(0, mKillable.health, mKillable.health);

        Game.instance.hud.bossHealth.transform.localScale = Vector3.zero;
        Game.instance.hud.bossHealth.transform.DOScale(1f, 0.5f);

        mMaxTeleports = Random.Range(4, 6);
    }
Beispiel #8
0
 void Start()
 {
     projectileThrower = GetComponentInChildren <ProjectileThrower> ();
     playerMovement    = GetComponent <PlayerMovement> ();
 }
Beispiel #9
0
    // Update is called once per frame
    void Update()
    {
        if (finale)
        {
            return;
        }
        if (Game.instance.cinematicDirector.IsCinematicPlaying())
        {
            return;
        }
        if (Game.instance.transitionManager.isTransitioning)
        {
            return;
        }
        if (!isAlive)
        {
            return;
        }
        if (transitioning)
        {
            return;
        }

        MinimapCamera minimapCamera = Game.instance.minimapCamera;

        if (minimapCamera.showingWholeMap)
        {
            return;
        }

        if (Game.instance.dialogManager != null && Game.instance.dialogManager.AnyDialogsOpen())
        {
            return;
        }

        // Queue spells while moving / attack to be executed once those actions end.
        if (Game.instance.actionSet.Spell.WasPressed)
        {
            mSpellQueued = true;
        }

        if (Game.instance.actionSet.Dance.WasPressed && Game.instance.playerData.IsFlagSet("dance_purchased"))
        {
            mDanceQueued = true;
        }

        if (commonComponents.simpleMovement.isMoving || commonComponents.simpleAttack.isAttacking)
        {
            return;
        }

        SpellCaster caster = GetComponentInChildren <SpellCaster>();

        if (caster != null && caster.isCasting)
        {
            return;
        }

        ProjectileThrower thrower = GetComponentInChildren <ProjectileThrower>();

        if (thrower != null && thrower.isThrowing)
        {
            return;
        }

        if (mSpellQueued)
        {
            mSpellQueued = false;
            CastSpellIfPossible();
            return;
        }

        if (mTeleportQueued)
        {
            mTeleportQueued = false;
            TeleportIfPossible();
            return;
        }

        if (mDanceQueued)
        {
            mDanceQueued = false;
            PlayRandomDance();
            return;
        }

        if (!Game.instance.realTime && Game.instance.whoseTurn != 0)
        {
            return;
        }

        Vector3 followerDirection = transform.position - follower.transform.position;

        followerDirection.y = 0f;
        followerDirection.Normalize();

        Vector3 intendedDirection = Vector3.zero;

        float moveThreshold = 0.5f;

        if (Game.instance.actionSet.Move.Y > moveThreshold)
        {
            intendedDirection = new Vector3(0f, 0f, 1f);
        }
        else if (Game.instance.actionSet.Move.Y < -moveThreshold)
        {
            intendedDirection = new Vector3(0f, 0f, -1f);
        }
        else if (Game.instance.actionSet.Move.X < -moveThreshold)
        {
            intendedDirection = new Vector3(-1f, 0f, 0f);
        }
        else if (Game.instance.actionSet.Move.X > moveThreshold)
        {
            intendedDirection = new Vector3(1f, 0f, 0f);
        }

        intendedDirection = SpaceCadetQuirk.ApplyQuirkIfPresent(intendedDirection);

        if (intendedDirection.magnitude > 0.8f)
        {
            direction = intendedDirection;

            if (Game.instance.actionSet.HoldPosition.IsPressed)
            {
                SimpleMovement.OrientToDirection(commonComponents.animator.gameObject, intendedDirection);
            }
            else
            {
                if (commonComponents.simpleAttack.CanAttack(intendedDirection))
                {
                    commonComponents.simpleAttack.Attack(intendedDirection);
                    AttackFollower(intendedDirection);
                }
                else if (commonComponents.simpleMovement.CanMove(intendedDirection))
                {
                    commonComponents.simpleMovement.Move(intendedDirection);
                    commonComponents.animator.Play("Idle");
                    MoveFollower(intendedDirection, transform.position + intendedDirection);
                }
                else
                {
                    SimpleMovement.OrientToDirection(commonComponents.animator.gameObject, intendedDirection);

                    if (HasFollower())
                    {
                        SimpleMovement.OrientToDirection(follower.commonComponents.animator.gameObject, intendedDirection);
                    }
                }
            }
        }
    }
Beispiel #10
0
 public override void AIStructureChanged()
 {
     mProjectileThrower = GetComponentInChildren <ProjectileThrower>();
 }
Beispiel #11
0
    protected override void onUpdate()
    {
        if (isTutorialRunning())
        {
            return;
        }

        timerUI();
        updateScoreText();
        if (time >= 50.0f && time <= 50.3f)
        {
            timer.color = Color.red;
            //RenderSettings.skybox=skyBox;
            //feverParticle[0].renderer.enabled = true;
        }

        if (time >= playTime)
        {
            finish();
        }

        ///////////////////////

        if (IsFeverTime == true && isFirst == true)
        {
            /////////////

            //////////////////

            RenderSettings.skybox = feverSkyBox;

            spotLight1.intensity = 5;
            spotLight3.intensity = 5;
            spotLight5.intensity = 5;
            spotLight2.intensity = 5;
            spotLight4.intensity = 5;
            spotLight6.intensity = 5;
            spotLight1.color     = Color.magenta;
            spotLight4.color     = Color.green;
            spotLight5.color     = Color.magenta;
            spotLight2.color     = Color.yellow;
            spotLight3.color     = Color.red;
            spotLight6.color     = Color.cyan;

            ProjectileThrower.getInstance().setWaitTime(0.2f);


            for (int i = 0; i < 13; i++)
            {
                feverParticle[i].renderer.enabled = true;
                feverParticle[i].particleSystem.Play();
            }

            isFirst = false;
        }

        if (IsFeverTime == true)
        {
            feverTime += Time.deltaTime;

            /*
             * if(feverTime <= 1.0f)
             * {
             *      feverTimeText.enabled = true;
             *
             *      Vector3 startPoint = new Vector3 (startFeverTextScale.x*0.0f,startFeverTextScale.y*0.0f);
             *      Vector3 firstPoint = new Vector3 (startFeverTextScale.x*2.5f, startFeverTextScale.y*2.5f);
             *      float fracComplete = (Time.time - startTime) / 1.0f;
             *
             *      feverTimeText.transform.localScale = Vector3.Slerp (startPoint,firstPoint,fracComplete);
             * }
             * else
             *      feverTimeText.enabled=false;
             */

            /////
            sLightTime += Time.deltaTime;

            if (sLightTime <= 0.2f)
            {
                /*if(spotLight1.intensity==0)
                 * {
                 *      spotLight1.intensity=8;
                 *      spotLight3.intensity=8;
                 *      spotLight5.intensity=8;
                 *      spotLight2.intensity=0;
                 *      spotLight4.intensity=0;
                 *      spotLight6.intensity=0;
                 * }
                 * else if(spotLight2.intensity==0)
                 * {
                 *      spotLight1.intensity=0;
                 *      spotLight3.intensity=0;
                 *      spotLight5.intensity=0;
                 *      spotLight2.intensity=8;
                 *      spotLight4.intensity=8;
                 *      spotLight6.intensity=8;
                 * }*/
                if (spotLight1.color == Color.magenta)
                {
                    spotLight1.color = Color.yellow;
                    spotLight4.color = Color.red;
                    spotLight5.color = Color.cyan;
                    spotLight2.color = Color.magenta;
                    spotLight3.color = Color.green;
                    spotLight6.color = Color.magenta;
                }
                else if (spotLight1.color == Color.yellow)
                {
                    spotLight1.color = Color.magenta;
                    spotLight4.color = Color.green;
                    spotLight5.color = Color.magenta;
                    spotLight2.color = Color.yellow;
                    spotLight3.color = Color.red;
                    spotLight6.color = Color.cyan;
                }
            }
            else if (sLightTime > 0.2f)
            {
                sLightTime = 0;
            }
            /////
        }

        if (feverTime >= 5.0f && feverTime <= 5.3f)
        {
            stopFeverTime();
            //backGround.renderer.enabled=true;
            RenderSettings.skybox = basicSkyBox;

            feverTime = 0.0f;
            isFirst   = true;
            ProjectileThrower.getInstance().setWaitTime(0.4f);


            for (int i = 0; i < 13; i++)
            {
                feverParticle[i].renderer.enabled = false;
            }

            spotLight1.intensity = 0;
            spotLight3.intensity = 0;
            spotLight5.intensity = 0;
            spotLight2.intensity = 0;
            spotLight4.intensity = 0;
            spotLight6.intensity = 0;
        }

        ////////////

        backGroundTranslate();

        //////////////
    }