Exemplo n.º 1
0
 public void RemoveTrapComponent(TrapComponent trapComponent)
 {
     if (trapDictionaryByOrigin.ContainsKey(trapComponent.origin.x))
     {
         trapDictionaryByOrigin[trapComponent.origin.x].Remove(trapComponent.origin.y);
     }
 }
Exemplo n.º 2
0
        public void PushpadAction(ChampionComponent champion, Node currentNode, Node beforeNode)
        {
            animator.SetTrigger("invoke");
            Node targetNode = currentNode;

            if (direction == Direction.up)
            {
                targetNode += new Node(0, 1);
            }
            else if (direction == Direction.right)
            {
                targetNode += new Node(1, 0);
            }
            else if (direction == Direction.down)
            {
                targetNode += new Node(0, -1);
            }
            else if (direction == Direction.left)
            {
                targetNode += new Node(-1, 0);
            }
            TrapComponent trapComponent = pm.pathManager.GetTrapComponent(targetNode);

            if (trapComponent == null || !trapComponent.isObstacle)
            {
                champion.MoveChampion(currentNode, targetNode, GameManager.championMoveDuration, MoveType.walk, false);
            }
            else
            {
                champion.MoveChampion(currentNode, beforeNode, GameManager.championMoveDuration, MoveType.walk, false);
            }
        }
Exemplo n.º 3
0
 public void PutTrapComponent(TrapComponent trapComponent)
 {
     if (!trapDictionaryByOrigin.ContainsKey(trapComponent.origin.x))
     {
         trapDictionaryByOrigin.Add(trapComponent.origin.x, new Dictionary <int, TrapComponent>());
     }
     trapDictionaryByOrigin[trapComponent.origin.x].Add(trapComponent.origin.y, trapComponent);
 }
Exemplo n.º 4
0
        public void PunchmachineAttack()
        {
            // Debug.Log("PunchmachineAttack()");
            Node targetNode    = origin;
            Node knockBackNode = origin;

            // TODO: knockBackNode에 설 수 있는지 확인해야 함.
            //그 자리에 obstacle이 있다면 걍 제자리에서 데미지만 받아야 함.
            if (this.direction == Direction.up)
            {
                targetNode    += new Node(0, 1);
                knockBackNode += new Node(0, 2);
            }
            else if (this.direction == Direction.right)
            {
                targetNode    += new Node(1, 0);
                knockBackNode += new Node(2, 0);
            }
            else if (this.direction == Direction.down)
            {
                targetNode    += new Node(0, -1);
                knockBackNode += new Node(0, -2);
            }
            else if (this.direction == Direction.left)
            {
                targetNode    += new Node(-1, 0);
                knockBackNode += new Node(-2, 0);
            }
            // Debug.Log("pm.player.origin: " + pm.player.origin.ToString());
            // Debug.Log("targetNode: " + targetNode.ToString());
            if (pm.champion.origin == targetNode)
            {
                // Debug.Log("punch!!!");
                // Debug.Log(gameObject.name);
                TrapComponent trapComponent = pm.pathManager.GetTrapComponent(knockBackNode);
                if (trapComponent == null || !trapComponent.isObstacle)
                {
                    pm.champion.TakeDamage(attack, DamageType.trap);
                    pm.champion.MoveChampion(targetNode, knockBackNode, GameManager.championMoveDuration, MoveType.knockback, false);
                    //밀쳐내기
                    //기존에 이동중이라면 이동과 관련된 코루틴을 정지시키고
                    //목적지만 파라미터로 받는(출발지는 현재 플레이어의 위치)
                    //이동 함수를 사용하여 밀어낸다
                }
            }
        }
Exemplo n.º 5
0
        //TODO:특수스킬이나 아이템 사용과 같은 입력이 들어올 수 있으
        public void PlayerAction(PlayerInput input)
        {
            // if (!isHpDecreasing)
            // {
            //     isHpDecreasing = true;
            //     hpDecreasingCoroutine = StartCoroutine(DecreasingPlayerHp());
            // }
            if (isClear)
            {
                return;
            }

            if (playSceneState == PlaySceneState.main ||
                playSceneState == PlaySceneState.gameover ||
                playSceneState == PlaySceneState.pause)
            {
                return;
            }
            if (playSceneState == PlaySceneState.ready)
            {
                playSceneState = PlaySceneState.play;
            }
            if (!isSpIncreasing)
            {
                isSpIncreasing        = true;
                spIncreasingCoroutine = StartCoroutine(IncreasingPlayerSp());
            }

            //플레이어의 방향과 서있는 블럭의 타잎에 따라 다음에 가야할 노드와 회전유무가 정해진다.
            if (input == PlayerInput.left || input == PlayerInput.right || input == PlayerInput.forward)
            {
                if (champion.isDead)
                {
                    // Debug.Log("player is dead");
                    return;
                }
                if (champion.isMoving)
                {
                    Debug.Log("champion is moving. so skip action");
                    return;
                }
                if (champion.isAttacking)
                {
                    return;
                }

                Node           targetNode         = champion.origin;
                Node           nextNode           = GetNextNode(champion, input);
                BlockComponent blockComponent     = pathManager.GetBlockComponentByOrigin(champion.origin);
                BlockComponent nextBlockComponent = pathManager.GetBlockComponentByOrigin(nextNode); //null 일 수도있다
                Direction      targetDirection    = champion.direction;

                if (champion.isWatered)
                {
                    champion.isWatered = false;
                    champion.MoveChampion(champion.origin, champion.origin, GameManager.championMoveDuration, MoveType.walk, false);
                    return;
                }
                else if (champion.isBitten)
                {
                    champion.isBitten = false;
                    champion.MoveChampion(champion.origin, champion.origin, GameManager.championMoveDuration, MoveType.walk, false);
                    return;
                }


                //스트레이트 블럭 위에 있고 입력받은곳에 적이 있는지 확인해야한다
                //공격후 적이 죽는다면 적이 있던 자리로 이동하고 적이 죽지 않으면 원래 있던 자리로 돌아와야 한다
                // Debug.Log("player.origin: " + player.origin.ToString());
                TrapComponent trapComponent = pathManager.GetTrapComponent(nextNode);
                if (trapComponent != null && trapComponent.isObstacle)
                {
                    champion.MoveChampion(champion.origin, champion.origin, GameManager.championMoveDuration, MoveType.walk, false);
                    return;
                }

                if (IsEnemyInDirection(nextNode))
                {
                    champion.Attack(champion.origin, nextNode, GameManager.championMoveDuration);
                    return;
                }
                else
                {
                    targetDirection = champion.direction;
                    if (champion.direction == Direction.right)
                    {
                        if (input == PlayerInput.left)
                        {
                            targetNode += new Node(1, 1);
                        }
                        else if (input == PlayerInput.right)
                        {
                            targetNode += new Node(1, -1);
                        }
                        else if (input == PlayerInput.forward)
                        {
                            targetNode += new Node(1, 0);
                        }
                    }
                    else if (champion.direction == Direction.up)
                    {
                        if (input == PlayerInput.left)
                        {
                            targetNode += new Node(-1, 1);
                        }
                        else if (input == PlayerInput.right)
                        {
                            targetNode += new Node(1, 1);
                        }
                        else if (input == PlayerInput.forward)
                        {
                            targetNode += new Node(0, 1);
                        }
                    }
                    else if (champion.direction == Direction.down)
                    {
                        if (input == PlayerInput.left)
                        {
                            targetNode += new Node(1, -1);
                        }
                        else if (input == PlayerInput.right)
                        {
                            targetNode += new Node(-1, -1);
                        }
                        else if (input == PlayerInput.forward)
                        {
                            targetNode += new Node(0, -1);
                        }
                    }
                    if (nextBlockComponent != null && (nextBlockComponent.blockData.blockCategory == BlockCategory.turn || nextBlockComponent.blockData.blockCategory == BlockCategory.shortcut_end))
                    {
                        targetDirection = nextBlockComponent.blockData.direction;
                    }
                }

                bool isRotate = champion.direction != targetDirection;
                champion.MoveChampion(champion.origin, targetNode, GameManager.championMoveDuration, MoveType.walk
                                      , isRotate);
                if (isRotate)
                {
                    champion.RotateChampion(champion.direction, targetDirection, GameManager.championMoveDuration);
                }
            }
            else
            {
                //이동이외의 입력이 들어온다면 여기서 구현해야 한다
            }
        }
Exemplo n.º 6
0
        public void InitSectionComponent(SectionModel sectionData, SectionModel nextSectionData, SectionComponent lastSectionComponent, bool isLastSection = false)
        {
            // Debug.Log("SectionComponent.InitSectionComponent(" + sectionData.sectionId.ToString() + ")");
            isCollapsing = false;
            blockComponents.Clear();
            this.sectionData = sectionData;
            SetSectionPosition(this.sectionData.origin);

            // Debug.Log("pm.pathManager.sectionList.Count: " + pm.pathManager.sectionList.Count.ToString());
            // if (lastSectionComponent != null) { Debug.Log("lastSectionComponent: " + lastSectionComponent); }
            // else { Debug.Log("lastSectionComponent is null"); }

            int baseProgress = lastSectionComponent != null ? lastSectionComponent.maxProgress : 0;

            minProgress = baseProgress;
            int _maxProgress = -1;

            // Debug.Log("sectionData.height: " + sectionData.height.ToString());
            // Debug.Log("sectionData.width: " + sectionData.width.ToString());
            for (int i = 0; i < this.sectionData.height; i++)
            {
                for (int j = 0; j < this.sectionData.width; j++)
                {
                    TerrainGid terrainGid = TerrainGid.empty;
                    if (sectionData.terrains != null)
                    {
                        terrainGid = (TerrainGid)sectionData.terrains[i, j];
                    }
                    else
                    {
                        //terrain정보가 들어오지 않는 경우는 코너섹션일 때
                        terrainGid = TerrainGid.basic_dirt;
                    }
                    if (terrainGid == TerrainGid.empty)
                    {
                        continue;
                    }

                    GameObject blockPrefab     = PrefabManager.Instance.GetBlockPrefab(terrainGid);
                    GameObject blockGameObject = Instantiate(blockPrefab) as GameObject;
                    // GameObject blockGameObject = ObjectPool.Spawn(blockPrefab);

                    blockGameObject.name = "block#" + pm.pathManager.lastBlockComponentId.ToString();
                    blockGameObject.transform.SetParent(blockContainer);
                    BlockComponent blockComponent = blockGameObject.GetComponent <BlockComponent>();
                    BlockCategory  blockCategory  = this.sectionData.sectionType == SectionType.corner ? BlockCategory.corner : BlockCategory.straight;
                    if (this.sectionData.sectionType == SectionType.corner)
                    {
                        SectionComponent _beforeSectionComponent = pm.pathManager.GetSectionComponent(this.sectionData.sectionId - 1);
                        // SectionComponent _beforeBeforeSectionComponent = pm.pathManager.GetSectionComponent(this.sectionData.sectionId - 2);
                        if (_beforeSectionComponent == null) //first corner section
                        {
                            blockCategory = BlockCategory.corner;
                        }
                        else if (this.sectionData.direction == Direction.up || (this.sectionData.direction == Direction.right && (_beforeSectionComponent.sectionData.direction == Direction.up)))
                        {
                            if (i + j >= 2 && !(i == 2 && j == 2))
                            {
                                blockCategory = BlockCategory.turn;
                            }
                            else
                            {
                                blockCategory = BlockCategory.corner;
                            }
                        }
                        else if (this.sectionData.direction == Direction.down || (this.sectionData.direction == Direction.right && (_beforeSectionComponent.sectionData.direction == Direction.down)))
                        {
                            if (j >= i && !(i == 0 && j == 2))
                            {
                                blockCategory = BlockCategory.turn;
                            }
                            else
                            {
                                blockCategory = BlockCategory.corner;
                            }
                        }

                        if (isLastSection)
                        {
                            blockCategory = BlockCategory.straight;
                        }
                    }
                    else if (this.sectionData.sectionType == SectionType.straight)
                    {
                        if (this.sectionData.direction == Direction.up)
                        {
                            if (j == this.sectionData.width - 1 && i == this.sectionData.height - 1)
                            {
                                blockCategory = BlockCategory.shortcut_start;
                            }
                            else if (j == 0 && i == 0)
                            {
                                blockCategory = BlockCategory.shortcut_end;
                            }
                            else
                            {
                                blockCategory = BlockCategory.straight;
                            }
                        }
                        else if (this.sectionData.direction == Direction.down)
                        {
                            if (j == this.sectionData.width - 1 && i == 0)
                            {
                                blockCategory = BlockCategory.shortcut_start;
                            }
                            else if (j == 0 && i == this.sectionData.height - 1)
                            {
                                blockCategory = BlockCategory.shortcut_end;
                            }
                            else
                            {
                                blockCategory = BlockCategory.straight;
                            }
                        }
                        else if (this.sectionData.direction == Direction.right)
                        {
                            SectionComponent _beforeSectionComponent       = pm.pathManager.GetSectionComponent(this.sectionData.sectionId - 1);
                            SectionComponent _beforeBeforeSectionComponent = pm.pathManager.GetSectionComponent(this.sectionData.sectionId - 2);
                            if ((nextSectionData.direction == Direction.up) && (j == this.sectionData.width - 1 && i == this.sectionData.height - 1))
                            {
                                blockCategory = BlockCategory.shortcut_start;
                            }
                            else if ((nextSectionData.direction == Direction.down) && (j == this.sectionData.width - 1 && i == 0))
                            {
                                blockCategory = BlockCategory.shortcut_start;
                            }
                            else if (_beforeBeforeSectionComponent != null)
                            {
                                if (_beforeBeforeSectionComponent.sectionData.direction == Direction.up && (j == 0 && i == 0))
                                {
                                    blockCategory = BlockCategory.shortcut_end;
                                }
                                else if (_beforeBeforeSectionComponent.sectionData.direction == Direction.down && (j == 0 && i == this.sectionData.height - 1))
                                {
                                    blockCategory = BlockCategory.shortcut_end;
                                }
                                else
                                {
                                    blockCategory = BlockCategory.straight;
                                }
                            }
                            else
                            {
                                blockCategory = BlockCategory.straight;
                            }
                        }
                        //다음 코너에서 방향이 어떨게 되냐에따라 현재 스트레이트 섹션의 숏컷이 결정된다

                        /*
                         *
                         * if ((this.sectionData.direction == Direction.right && nextSectionData.direction == Direction.up) ||
                         * (this.sectionData.direction == Direction.up && nextSectionData.direction == Direction.right))
                         * {
                         *  if (j == this.sectionData.width - 1 && i == this.sectionData.height - 1)
                         *  {
                         *      blockCategory = BlockCategory.shortcut_start;
                         *  }
                         *  else if (this.sectionData.direction == Direction.right && j == this.sectionData.width - 1)
                         *  {
                         *      blockCategory = BlockCategory.straight_edge;
                         *  }
                         *  else if (this.sectionData.direction == Direction.up && i == this.sectionData.height - 1)
                         *  {
                         *      blockCategory = BlockCategory.straight_edge;
                         *  }
                         *  else if (j == 0 && i == 0)
                         *  {
                         *      Debug.Log("???");
                         *      blockCategory = BlockCategory.shortcut_end;
                         *  }
                         *  else
                         *  {
                         *      blockCategory = BlockCategory.straight;
                         *  }
                         * }
                         * else
                         * {
                         *  if (j == this.sectionData.width - 1 && i == 0)
                         *  {
                         *      blockCategory = BlockCategory.shortcut_start;
                         *  }
                         *  else if (this.sectionData.direction == Direction.right && j == this.sectionData.width - 1)
                         *  {
                         *      blockCategory = BlockCategory.straight_edge;
                         *  }
                         *  else if (this.sectionData.direction == Direction.down && i == 0)
                         *  {
                         *      blockCategory = BlockCategory.straight_edge;
                         *  }
                         *  else if (j == 0 && i == this.sectionData.height - 1)
                         *  {
                         *      Debug.Log("!!!");
                         *      blockCategory = BlockCategory.shortcut_end;
                         *  }
                         *  else
                         *  {
                         *      blockCategory = BlockCategory.straight;
                         *  }
                         * }
                         */
                    }
                    int progress = 0;

                    if (sectionData.sectionType == SectionType.straight)
                    {
                        if (sectionData.direction == Direction.right)
                        {
                            progress = baseProgress + j + 1;
                        }
                        else if (sectionData.direction == Direction.up)
                        {
                            progress = baseProgress + i + 1;
                        }
                        else if (sectionData.direction == Direction.down)
                        {
                            progress = baseProgress + (this.sectionData.height - i);
                        }
                    }
                    else if (sectionData.sectionType == SectionType.corner)
                    {
                        progress = baseProgress + 1;
                    }

                    if (progress > _maxProgress)
                    {
                        _maxProgress = progress;
                    }

                    BlockModel blockData = new BlockModel(
                        pm.pathManager.lastBlockComponentId++,
                        blockCategory,
                        this.sectionData.direction,
                        this.sectionData.origin + new Node(j, i),
                        progress);

                    blockComponent.InitBlockComponent(this, blockData);
                    blockComponents.Add(blockComponent);
                    pm.pathManager.PutBlockComponent(blockComponent);
                }
            }

            if (sectionData.objects != null)
            {
                // Debug.Log("---------");
                // Debug.Log(sectionData.objects.Count);
                // Debug.Log("sectionData.direction: " + sectionData.direction);
                // Debug.Log("sectionData.width: " + sectionData.width.ToString());
                // Debug.Log("sectionData.height: " + sectionData.height.ToString());
                foreach (KeyValuePair <Node, TiledObject> kv in sectionData.objects)
                {
                    Node node = kv.Key;
                    // Debug.Log("node: " + node.ToString());
                    TiledObject tiledObject = kv.Value;
                    int         objectGid   = tiledObject.gid;

                    BlockComponent blockComponent = pm.pathManager.GetBlockComponentByOrigin(this.sectionData.origin + node);
                    if (blockComponent == null)
                    {
                        Debug.Log("blockComponent is null");
                        continue;
                    }

                    if (17 <= objectGid && objectGid < 33) //item
                    {
                        Node       itemOrigin = this.sectionData.origin + node;
                        GameObject itemPrefab = PrefabManager.Instance.GetItemPrefab((ItemGid)objectGid);
                        // GameObject itemInstance = Instantiate(itemPrefab) as GameObject;
                        GameObject itemInstance = ObjectPool.Spawn(itemPrefab);
                        itemInstance.transform.SetParent(blockComponent.objectContainer);
                        ItemComponent itemComponent = itemInstance.GetComponent <ItemComponent>();
                        itemComponent.InitItemComponent(this, itemOrigin, blockComponent.blockData.direction);
                        itemComponents.Add(itemComponent);
                        pm.pathManager.PutItemComponent(itemComponent);
                        if (itemComponent.itemType == ItemType.food)
                        {
                            FoodItemComponent foodItemComponent = itemComponent.GetComponent <FoodItemComponent>();
                            foodItemComponent.InitFoodRender();
                        }
                    }
                    else if (33 <= objectGid && objectGid < 49) //trap
                    {
                        Node       trapOrigin = this.sectionData.origin + node;
                        GameObject trapPrefab = PrefabManager.Instance.GetTrapPrefab((TrapGid)objectGid);
                        // GameObject trapInstance = Instantiate(trapPrefab) as GameObject;
                        GameObject trapInstance = ObjectPool.Spawn(trapPrefab);
                        trapInstance.transform.SetParent(blockComponent.objectContainer);
                        TrapComponent trapComponent = trapInstance.GetComponent <TrapComponent>();
                        trapComponent.name = trapComponent.GetInstanceID().ToString();
                        Direction trapDirection = blockComponent.blockData.direction;
                        if (tiledObject.properties != null)
                        {
                            //TODO TileProperty의 direction을 그대로 사용하는것이 아니라
                            //섹션의 방향에 따라 수정된 direction을 사용해야 한다
                            if (sectionData.direction == Direction.right)
                            {
                                trapDirection = tiledObject.properties.direction;
                            }
                            else if (sectionData.direction == Direction.up)
                            {
                                if (tiledObject.properties.direction == Direction.up)
                                {
                                    trapDirection = Direction.left;
                                }
                                else if (tiledObject.properties.direction == Direction.right)
                                {
                                    trapDirection = Direction.up;
                                }
                                else if (tiledObject.properties.direction == Direction.down)
                                {
                                    trapDirection = Direction.right;
                                }
                                else if (tiledObject.properties.direction == Direction.left)
                                {
                                    trapDirection = Direction.down;
                                }
                            }
                            else if (sectionData.direction == Direction.down)
                            {
                                if (tiledObject.properties.direction == Direction.up)
                                {
                                    trapDirection = Direction.right;
                                }
                                else if (tiledObject.properties.direction == Direction.right)
                                {
                                    trapDirection = Direction.down;
                                }
                                else if (tiledObject.properties.direction == Direction.down)
                                {
                                    trapDirection = Direction.left;
                                }
                                else if (tiledObject.properties.direction == Direction.left)
                                {
                                    trapDirection = Direction.up;
                                }
                            }
                        }
                        trapComponent.InitTrapComponent(this, trapOrigin, trapDirection, tiledObject);
                        trapComponents.Add(trapComponent);
                        pm.pathManager.PutTrapComponent(trapComponent);
                    }
                    else if (49 <= objectGid && objectGid < 65) //enemy
                    {
                        Node       itemOrigin  = this.sectionData.origin + node;
                        GameObject enemyPrefab = PrefabManager.Instance.GetEnemyPrefab((EnemyGid)objectGid);
                        // GameObject enemyInstance = Instantiate(enemyPrefab) as GameObject;
                        GameObject enemyInstance = ObjectPool.Spawn(enemyPrefab);
                        enemyInstance.transform.SetParent(blockComponent.objectContainer);
                        EnemyComponent enemyComponent = enemyInstance.GetComponent <EnemyComponent>();
                        enemyComponent.InitEnemyComponent(itemOrigin, blockComponent.blockData.direction);
                        enemyComponents.Add(enemyComponent);
                        pm.pathManager.PutEnemyComponent(enemyComponent);
                    }
                }
            }

            this.maxProgress = _maxProgress;
        }
Exemplo n.º 7
0
        void OnMoveComplete(Node beforeNode, bool isRotate)
        {
            // Debug.Log("ChampionComponent.OnMoveComplete()");
            isSliping = false;
            animator.SetBool("isCrouch", false);
            int            addScore              = 0;
            BlockComponent beforeBlockComponent  = pm.pathManager.GetBlockComponentByOrigin(beforeNode);
            BlockComponent currentBlockComponent = pm.pathManager.GetBlockComponentByOrigin(this.origin);

            if (currentBlockComponent == null)
            {
                //there is no block blow player
                TakeDamage(currentHp, DamageType.drop);
            }
            else
            {
                if ((beforeBlockComponent.sectionComponent != currentBlockComponent.sectionComponent))
                {
                    pm.pathManager.currentSectionComponent = currentBlockComponent.sectionComponent;
                }


                if ((beforeBlockComponent.sectionComponent != currentBlockComponent.sectionComponent) &&
                    (currentBlockComponent.sectionComponent.sectionData.sectionType == SectionType.straight) &&
                    (currentBlockComponent.blockData.progress > progress))
                {
                    //time to generate more section
                    pm.pathManager.AddSection(pm.playMode);
                }

                ItemComponent itemComponent = pm.pathManager.GetItemComponent(this.origin);
                if (itemComponent != null)
                {
                    if (!gotItem)
                    {
                        gotItem = true;
                    }
                    pm.AddCombo();

                    if (!string.IsNullOrEmpty(itemComponent.sfx))
                    {
                        SoundManager.Instance.Play(itemComponent.sfx);
                    }
                    //eat item and destroy
                    if (itemComponent.itemType == ItemType.hp)
                    {
                        AddHp((int)itemComponent.value);
                        pm.uiManager.UpdateHpUI(true);
                        addScore += 2;
                        pm.score += 2;
                    }
                    else if (itemComponent.itemType == ItemType.sp)
                    {
                        AddSp(itemComponent.value);
                        pm.uiManager.UpdateSp();
                        addScore += 2;
                        pm.score += 2;
                    }
                    else if (itemComponent.itemType == ItemType.coin)
                    {
                        pm.totalCoin += (int)itemComponent.value;
                        pm.addCoin   += (int)itemComponent.value;
                        GameManager.Instance.SetPlayerCoinToPref(pm.totalCoin);
                        pm.uiManager.UpdateCoin(true);
                        addScore += 1;
                        pm.score += 1;
                    }
                    else if (itemComponent.itemType == ItemType.heart)
                    {
                        int addHp = (int)itemComponent.value;
                        pm.champion.maxHp     += addHp;
                        pm.champion.maxHp      = Mathf.Clamp(pm.champion.maxHp, 1, 14);
                        pm.champion.currentHp += addHp;
                        pm.champion.currentHp  = Mathf.Clamp(pm.champion.currentHp, 1, 14);
                        pm.uiManager.InitHpUI(pm.champion.maxHp, pm.champion.currentHp, true);
                        addScore += 5;
                        pm.score += 5;
                    }

                    pm.pathManager.RemoveItemComponent(itemComponent);
                    currentBlockComponent.sectionComponent.itemComponents.Remove(itemComponent);
                    // Destroy(itemComponent.gameObject);

                    ObjectPool.Recycle(itemComponent);
                }
                else
                {
                    pm.ResetCombo();
                    gotItem = false;
                }

                if (beforeBlockComponent != currentBlockComponent && currentBlockComponent.terrainGid == TerrainGid.water)
                {
                    isWatered = true;
                }

                if (currentBlockComponent.hasStepEffect)
                {
                    currentBlockComponent.MakeStepEffect();
                }

                if (currentBlockComponent.terrainGid == TerrainGid.cracked)
                {
                    currentBlockComponent.StartCollapse(1.5f, 1.5f, true);
                }
                else if (currentBlockComponent.terrainGid == TerrainGid.magma)
                {
                    MagmaComponent magmaComponent = currentBlockComponent.GetComponentInChildren <MagmaComponent>();
                    if (magmaComponent.isHot)
                    {
                        TakeDamage(magmaComponent.attack, DamageType.magma);
                    }
                }
                else if (currentBlockComponent.terrainGid == TerrainGid.ice)
                {
                    //한칸 앞으로 미끄러져 이동해야한다
                    Node targetNode = origin;
                    if (currentBlockComponent.blockData.direction == Direction.right)
                    {
                        targetNode += new Node(1, 0);
                    }
                    else if (currentBlockComponent.blockData.direction == Direction.up)
                    {
                        targetNode += new Node(0, 1);
                    }
                    else if (currentBlockComponent.blockData.direction == Direction.down)
                    {
                        targetNode += new Node(0, -1);
                    }
                    TrapComponent _trapComponent = pm.pathManager.GetTrapComponent(targetNode);
                    if (_trapComponent == null || !_trapComponent.isObstacle)
                    {
                        MoveChampion(origin, targetNode, GameManager.championMoveDuration, MoveType.slip, true);
                    }
                }
                else if (currentBlockComponent.terrainGid == TerrainGid.finish)
                {
                    //finish!
                    pm.pathManager.currentSectionComponent.StopCollapse();
                    pm.isClear = true;
                    gameObject.transform.SetParent(currentBlockComponent.objectContainer);
                    animator.SetTrigger("finish");
                    currentBlockComponent.Finish();
                    Vector3 targetRotation = pm.cameraController.pivot.rotation.eulerAngles + new Vector3(0, 180, 0);
                    pm.cameraController.AnimatePivotAngle(Quaternion.Euler(targetRotation), 0.5f);
                    pm.GameOver("Clear", "", true);
                }


                // 새로운 섹션에 도착했고 해당 섹션은 스트레이트 세션이다
                // 도착한 섹션에다가 자동파괴명령을 내리자
                if (beforeBlockComponent.sectionComponent != currentBlockComponent.sectionComponent)
                {
                    if (currentBlockComponent.sectionComponent.sectionData.sectionType == SectionType.straight)
                    {
                        currentBlockComponent.sectionComponent.StartCollapse(1.5f, 1.5f);
                    }
                    else if (currentBlockComponent.sectionComponent.sectionData.sectionType == SectionType.corner)
                    {
                        currentBlockComponent.sectionComponent.StartCollapse(1.5f, 3.0f);
                    }
                }

                // Debug.Log("currentBlockComponent.blockData.progress: " + currentBlockComponent.blockData.progress.ToString());
                // Debug.Log("progress: " + progress.ToString());
                if (currentBlockComponent.blockData.progress > progress)
                {
                    // Debug.Log("Here");
                    pm.AddDistance(currentBlockComponent.blockData.progress - progress, !gotItem);
                    progress = currentBlockComponent.blockData.progress;
                }

                // if (currentBlockComponent.sectionComponent.sectionData.sectionType == SectionType.straight)
                // {
                //     currentBlockComponent.sectionComponent.StartCollapse(progress);
                // }



                TrapComponent trapComponent = pm.pathManager.GetTrapComponent(this.origin);
                if (trapComponent != null)
                {
                    if (trapComponent.trapType == TrapType.thornfloor && trapComponent.isThornUp)
                    {
                        trapComponent.ThornfloorAttack();
                    }
                    else if (trapComponent.trapType == TrapType.jawmachine && !trapComponent.isInvoked)
                    {
                        trapComponent.JawmachineAttack();
                    }
                    else if (trapComponent.trapType == TrapType.pushpad)
                    {
                        trapComponent.PushpadAction(this, origin, beforeNode);
                    }
                }
            }

            if (!isDead &&
                // !isRotate &&
                currentBlockComponent != null &&
                currentBlockComponent.sectionComponent.sectionData.sectionType == SectionType.straight &&
                currentBlockComponent.blockData.progress >= progress &&
                beforeBlockComponent != currentBlockComponent)
            {
                // CameraWork(currentBlockComponent);
            }
            if (isRotate)
            {
                // Debug.Log("champion rotate");
                Quaternion targetRotation = Quaternion.identity;
                if (currentBlockComponent.sectionComponent.sectionData.direction == Direction.right)
                {
                    if (currentBlockComponent.sectionComponent.beforeSectionComponent == null)
                    {
                        if (currentBlockComponent.sectionComponent.nextSectionComponent.nextSectionComponent.sectionData.direction == Direction.up)
                        {
                            targetRotation = Quaternion.Euler(pm.cameraController.championRightUpAngle);
                        }
                        else if (currentBlockComponent.sectionComponent.nextSectionComponent.nextSectionComponent.sectionData.direction == Direction.down)
                        {
                            targetRotation = Quaternion.Euler(pm.cameraController.championRightDownAngle);
                        }
                    }
                    else if (currentBlockComponent.sectionComponent.beforeSectionComponent.beforeSectionComponent == null)
                    {
                        if (currentBlockComponent.sectionComponent.nextSectionComponent.nextSectionComponent.sectionData.direction == Direction.up)
                        {
                            targetRotation = Quaternion.Euler(pm.cameraController.championRightUpAngle);
                        }
                        else if (currentBlockComponent.sectionComponent.nextSectionComponent.nextSectionComponent.sectionData.direction == Direction.down)
                        {
                            targetRotation = Quaternion.Euler(pm.cameraController.championRightDownAngle);
                        }
                    }
                    else if (currentBlockComponent.sectionComponent.beforeSectionComponent.beforeSectionComponent.sectionData.direction == Direction.down)
                    {
                        targetRotation = Quaternion.Euler(pm.cameraController.championRightDownAngle);
                    }
                    else if (currentBlockComponent.sectionComponent.beforeSectionComponent.beforeSectionComponent.sectionData.direction == Direction.up)
                    {
                        targetRotation = Quaternion.Euler(pm.cameraController.championRightUpAngle);
                    }
                }
                else if (currentBlockComponent.sectionComponent.sectionData.direction == Direction.up)
                {
                    targetRotation = Quaternion.Euler(pm.cameraController.championUpAngle);
                }
                else if (currentBlockComponent.sectionComponent.sectionData.direction == Direction.down)
                {
                    targetRotation = Quaternion.Euler(pm.cameraController.championDownAngle);
                }
                pm.cameraController.AnimatePivotAngle(targetRotation, 0.3f);
            }
            if (addScore > 0)
            {
                pm.uiManager.UpdateScoreUI(pm.score, addScore);
            }
        }