示例#1
0
    public void checkNormalAi()
    {
//		Debug.Log("_nowNormalAiCheckDelay : " + _nowNormalAiCheckDelay);
        if (_nowNormalAiCheckDelay > 0)
        {
            _nowNormalAiCheckDelay -= GameManager.globalDeltaTime;
            return;
        }
        else
        {
            _nowNormalAiCheckDelay = NORMAL_MOVE_CHECK_DELAY;
        }

        isBattleWaitMode = _battleStateChecker.battleStateIsReady(this);



//			if(!isPlayerSide) Debug.LogError("isBattleWaitMode : " + isBattleWaitMode);


        //checkMovingTargetPosition();

        // 전투 대기 상태.
        if (isBattleWaitMode)
        {
            for (i = 0; i < _readyModeMoveListLen; ++i)
            {
                if (_readyModeMove[i].battleWaitMove(this))                // 걸렸으면 이걸 진행한다는 뜻이다...
                {
                    break;
                }
            }
        }
        // 전투 진행 상태.
        else
        {
            // 위험도 계산!
            checkDangerZone();


            isDefaultAttackOn = false;
            bool canCheckDefaultAttackOn = true;

            // 기본공격 off 조건.
            for (i = 0; i < _battleModeOffLen; ++i)
            {
                if (_battleModeOffChecker[i].checkDefaultAttackOnOff(this))
                {
                    canCheckDefaultAttackOn = false;
//					if(!isPlayerSide) Debug.LogError("기본공격 off : 안전한 위치로 이동");
                    break;
                }
            }

            if (canCheckDefaultAttackOn == true)
            {
                // 기본공격 on 조건.
                for (i = 0; i < _battleModeOnLen; ++i)
                {
                    if (_battleModeOnChecker[i].checkDefaultAttackOnOff(this))
                    {
                        isDefaultAttackOn = true;
//						if(!isPlayerSide) Debug.LogError("기본공격 on");
                        break;
                    }
                }
            }

            _scoreSlot = null;

            // 2-1) 기본공격 위치.
            //  기본공격 위치 = 타겟존 - 히어로 기본 공격거리
            // 그냥 얘는 기존처럼 전진하면 된다.

            // 기본공격 On인 상태.

            if (isDefaultAttackOn)
            {
                //공격거리 < 210 일때
                //(기존과 동일) 기본 공격 위치 = 타겟존 - 히어로 기본공격거리 위치로 이동
                //default 공격이 체크되면 action.doMotion으로 자동으로 움직일거다...
                if (stat.atkRange < 210)
                {
                    moveState = MoveState.Forward;
                    setMovingDirection(MoveState.Forward);
                }
                else
                {
                    float defaultAttackerTargetPostion = 0.0f;

                    //근접 아군 유닛 개수가 0마리 이하면, 기본 공격 위치 = 타겟존 - 200 위치로 이동하고
                    if (cm.checkAliveShortUnitNum(isPlayerSide, 0))
                    {
                        if (isPlayerSide)
                        {
                            defaultAttackerTargetPostion = GameManager.me.characterManager.targetZoneMonsterLine - 200.0f;
                        }
                        else
                        {
                            defaultAttackerTargetPostion = GameManager.me.characterManager.targetZonePlayerLine + 200.0f;
                        }
                    }
                    //아니면, 기본 공격 위치 = 타겟존 - 히어로 기본공격거리
                    else
                    {
                        if (isPlayerSide)
                        {
                            defaultAttackerTargetPostion = GameManager.me.characterManager.targetZoneMonsterLine - stat.atkRange;
                        }
                        else
                        {
                            defaultAttackerTargetPostion = GameManager.me.characterManager.targetZonePlayerLine + stat.atkRange;
                        }
                    }


                    if (cTransformPosition.x < defaultAttackerTargetPostion)
                    {
                        if (isPlayerSide)
                        {
                            defaultAttackPositionX = defaultAttackerTargetPostion;
                            moveState = MoveState.Forward;
                            setMovingDirection(MoveState.Forward);
                        }
                        else
                        {
                            _v   = cTransformPosition;
                            _v.x = defaultAttackerTargetPostion;
                            setStateAndDirectionByTargetPosition(_v);
                            isDefaultAttackOn = false;
                            return;
                        }
                    }
                    else
                    {
                        if (isPlayerSide)
                        {
                            _v   = cTransformPosition;
                            _v.x = defaultAttackerTargetPostion;
                            setStateAndDirectionByTargetPosition(_v);
                            isDefaultAttackOn = false;
                            return;
                        }
                        else
                        {
                            defaultAttackPositionX = defaultAttackerTargetPostion;
                            moveState = MoveState.Forward;
                            setMovingDirection(MoveState.Forward);
                        }
                    }
                }
            }



            if (isDefaultAttackOn == false)            // 기본공격 off일때!
            {
                float targetZoneLine = (isPlayerSide)?cm.targetZoneMonsterLine:cm.targetZonePlayerLine;


                // 3-1 안전한 위치.
                float lowDPoint = 1000;

                for (i = 0; i < 10; ++i)
                {
//					Debug.Log(dangerPoints[i].score + "  " + dangerPoints[i].pos);

                    if (dangerPoints[i].score > -9999)
                    {
                        if (dangerPoints[i].score < lowDPoint)
                        {
                            lowDPoint = dangerPoints[i].score;
                        }

                        if (dangerPoints[i].score <= _safeZoneChecker.value)
                        {
                            if (_scoreSlot == null)
                            {
                                _scoreSlot = dangerPoints[i];
                            }
                            else
                            {
                                if (VectorUtil.Distance(dangerPoints[i].pos.x, targetZoneLine) < VectorUtil.Distance(_scoreSlot.pos.x, targetZoneLine))
                                {
                                    _scoreSlot = dangerPoints[i];
                                }
                            }
                        }
                    }
                }

                if (_scoreSlot == null)
                {
                    for (i = 0; i < 10; ++i)
                    {
                        if (dangerPoints[i].score > -9999 && dangerPoints[i].score <= lowDPoint)
                        {
                            if (_scoreSlot == null)
                            {
                                _scoreSlot = dangerPoints[i];
                            }
                            else
                            {
                                if (VectorUtil.Distance(dangerPoints[i].pos.x, targetZoneLine) < VectorUtil.Distance(_scoreSlot.pos.x, targetZoneLine))
                                {
                                    _scoreSlot = dangerPoints[i];
                                }
                            }
                        }
                    }
                }


                if (_scoreSlot != null)
                {
//					if(!isPlayerSide) Debug.LogError("안전한 위치 : " + _scoreSlot.pos);
                    // 안전한 위치는 여기다.
                    // 그 곳으로 향하도록 셋팅한다.
                    setStateAndDirectionByTargetPosition(_scoreSlot.pos);
                }
                else
                {
                    setMovingDirection(MoveState.Stop);
                }
            }
        }
    }
示例#2
0
    // 위험도 체크.
    public void checkDangerZone()
    {
        //player는 0번이 우측이다. // 그럼 끝부터 검사한다.
        //monster는 0번이 좌측이다. // 0부터 검사한다.

        // 10개 구간으로 나눈다. 0번은 적 캐릭터가 갈 수 있는 가장 좌측이다.
        // 여기에서 부터 100cm 단위로 구간을 나누어 검사를 한다.
        _checkPosition               = cTransformPosition;
        _tempCheckPosition           = cTransformPosition;
        _tempCheckX                  = 9000.0f;
        onOffCheckNextMovingPosIndex = 0;
        int i, j;

//		checkFuck = false;

        // 위험도 계산.
        if (isPlayerSide)
        {
            for (i = 0; i < 10; ++i)
            {
                _scoreSlot       = dangerPoints[i];
                _scoreSlot.index = i;
                _scoreSlot.score = 0;

                _checkPosition.x = cm.monsterLeftLine - (i * 100.0f);                // - hitObject.lineRight;

                // 갈곳이 전방...
                if (_checkPosition.x >= cTransformPosition.x && i > onOffCheckNextMovingPosIndex)
                {
                    onOffCheckNextMovingPosIndex = i;
                }


                if (_checkPosition.x <= StageManager.mapStartPosX.Get())
                {
                    // 위치를 전방에서부터 100cm 간격으로 잡으니까 시작/끝 위치를 넘어가면 걔들은 어차피 아웃이다.
                    // 고로 -10000점을 줘서 계산대상에서 제외해버린다.
                    _scoreSlot.score = -10000.0f;
                    continue;
                }

                _scoreSlot.pos = _checkPosition;

                for (j = 0; j < _dangerPointLen; ++j)
                {
                    _scoreSlot.score += _dangerPointChecker[j].getDangerPoint(this, _checkPosition);
                }

//				Debug.Log(i + "위험 점수계산 : "  + _scoreSlot.score + "    " + _scoreSlot.pos);
            }
        }
        else
        {
            for (i = 0; i < 10; ++i)
            {
                _scoreSlot       = dangerPoints[i];
                _scoreSlot.index = i;
                _scoreSlot.score = 0;

                _checkPosition.x = cm.playerMonsterRightLine + (i * 100.0f);                // - hitObject.lineLeft;


                // 갈곳이 전방...
                if (_checkPosition.x <= cTransformPosition.x && i > onOffCheckNextMovingPosIndex)
                {
                    onOffCheckNextMovingPosIndex = i;
                }

                if (_checkPosition.x >= StageManager.mapEndPosX.Get())
                {
                    _scoreSlot.score = -10000.0f;
                    continue;
                }

                _scoreSlot.pos = _checkPosition;

                for (j = 0; j < _dangerPointLen; ++j)
                {
                    _scoreSlot.score += _dangerPointChecker[j].getDangerPoint(this, _checkPosition);
                }

//				Debug.Log(i + "위험 점수계산 : "  + _scoreSlot.score + "    " + _scoreSlot.pos);
            }
        }
//		checkFuck = true;

        // 현재 위치 위험도.
        dangerPoints[Player.CURRENT_POSITION_INDEX].pos   = cTransformPosition;
        dangerPoints[Player.CURRENT_POSITION_INDEX].score = 0;
        for (j = 0; j < _dangerPointLen; ++j)
        {
            dangerPoints[Player.CURRENT_POSITION_INDEX].score += _dangerPointChecker[j].getDangerPoint(this, cTransformPosition);
        }

#if UNITY_EDITOR
//		if(BattleSimulator.nowSimulation == false)
//		{
//			Debug.LogError("현재위치 위험 점수계산 : "  + dangerPoints[Player.CURRENT_POSITION_INDEX].score + "    " + dangerPoints[Player.CURRENT_POSITION_INDEX].pos);
//		}
#endif
    }