protected void CorFleetAnchorDifPosition()
        {
            BattleField battleField = BattleTaskManager.GetBattleField();
            Vector3     to          = (!_listBattleShips[0].shipModel.IsFriend()) ? _listBattleShips[1].transform.position : _listBattleShips[0].transform.position;
            Vector3     to2         = _listBattleShips[0].shipModel.IsFriend() ? _listBattleShips[1].transform.position : _listBattleShips[0].transform.position;
            Vector3     vector      = Mathe.Direction(Vector3.zero, to);
            Vector3     vector2     = Mathe.Direction(Vector3.zero, to2);

            battleField.dicFleetAnchor[FleetType.Friend].transform.AddPosX(0f - vector.x);
            battleField.dicFleetAnchor[FleetType.Enemy].transform.AddPosX(0f - vector2.x);
        }
Beispiel #2
0
        protected void CorFleetAnchorDifPosition()
        {
            BattleField battleField = BattleTaskManager.GetBattleField();
            Vector3     to          = (!this._listBattleShips.get_Item(0).shipModel.IsFriend()) ? this._listBattleShips.get_Item(1).get_transform().get_position() : this._listBattleShips.get_Item(0).get_transform().get_position();
            Vector3     to2         = this._listBattleShips.get_Item(0).shipModel.IsFriend() ? this._listBattleShips.get_Item(1).get_transform().get_position() : this._listBattleShips.get_Item(0).get_transform().get_position();
            Vector3     vector      = Mathe.Direction(Vector3.get_zero(), to);
            Vector3     vector2     = Mathe.Direction(Vector3.get_zero(), to2);

            battleField.dicFleetAnchor.get_Item(FleetType.Friend).get_transform().AddPosX(-vector.x);
            battleField.dicFleetAnchor.get_Item(FleetType.Enemy).get_transform().AddPosX(-vector2.x);
        }
        private void CalcDirection(Vector3 from, Vector3 to)
        {
            int num = Math.Sign(Mathe.Direction(from, to).x);

            if (num == -1)
            {
                this._iStartDirection = UISortieShip.Direction.Left;
                this._uiAircraft.get_transform().localEulerAnglesY(180f);
            }
            else if (num == 1)
            {
                this._iStartDirection = UISortieShip.Direction.Right;
                this._uiAircraft.get_transform().localEulerAnglesY(0f);
            }
        }
        private void CalcDirection(Vector3 from, Vector3 to)
        {
            Vector3 vector = Mathe.Direction(from, to);

            switch (Math.Sign(vector.x))
            {
            case -1:
                _iStartDirection = UISortieShip.Direction.Left;
                _uiAircraft.transform.localEulerAnglesY(180f);
                break;

            case 1:
                _iStartDirection = UISortieShip.Direction.Right;
                _uiAircraft.transform.localEulerAnglesY(0f);
                break;
            }
        }
Beispiel #5
0
        public void Extend(bool isVec, Action callback)
        {
            _actCallback = callback;
            base.transform.LookAt(_vecTorpedoTarget);
            Vector3   vector    = Mathe.Direction(base.transform.position, _vecTorpedoTarget);
            Hashtable hashtable = new Hashtable();

            if (isVec)
            {
                hashtable.Add("z", vector.z);
            }
            else
            {
                hashtable.Add("z", vector.z * -1f);
            }
            hashtable.Add("isLocal", false);
            hashtable.Add("time", _moveTime);
            hashtable.Add("delay", _delayTime);
            hashtable.Add("easeType", iTween.EaseType.linear);
            base.gameObject.ScaleTo(hashtable);
        }
        protected virtual void _initCameraState()
        {
            this._fYAxisLimit        = 0f;
            this._fSmoothCorrectionY = 0f;
            this._isThroughMaxY      = false;
            CameraActor.ViewMode iViewMode = this._iViewMode;
            switch (iViewMode + 1)
            {
            case CameraActor.ViewMode.FixChasing:
                base.get_transform().set_position(this._vSrcPos);
                base.get_transform().set_rotation(this._quaSrcRot);
                this._vSmoothVelocity = Vector3.get_zero();
                break;

            case CameraActor.ViewMode.FixChasingRot:
                base.get_transform().set_position(this._vDestPos);
                base.get_transform().LookAt(this._vPointOfGaze);
                break;

            case CameraActor.ViewMode.ZoomChasing:
                base.get_transform().set_position(this._vSrcPos);
                this._quaTempRot = base.get_transform().get_rotation();
                break;

            case CameraActor.ViewMode.ZoomChasingUp:
            {
                float num = this._fSmoothDistance / Vector3.Distance(this._vPointOfGaze, base.get_transform().get_position());
                this._vDestPos        = this._vPointOfGaze + (base.get_transform().get_position() - this._vPointOfGaze) * num;
                this._vSmoothVelocity = Vector3.get_zero();
                this._fSmoothTime     = 0.2f;
                this._isAdjust        = false;
                base.get_transform().LookAt(this._vPointOfGaze);
                break;
            }

            case CameraActor.ViewMode.SmoothMove:
            {
                float num2 = this._fSmoothDistance / Vector3.Distance(this._vPointOfGaze, base.get_transform().get_position());
                this._vDestPos        = this._vPointOfGaze + (base.get_transform().get_position() - this._vPointOfGaze) * num2;
                this._vSmoothVelocity = Vector3.get_zero();
                this._fSmoothTime     = 0.2f;
                this._isAdjust        = false;
                this._fAdjustY        = base.get_transform().get_position().y + 10f;
                base.get_transform().LookAt(this._vPointOfGaze);
                break;
            }

            case CameraActor.ViewMode.SmoothMoveKI2ndEdition:
            case CameraActor.ViewMode.FixedPositionChasing:
                base.get_transform().set_position(this._vSrcPos);
                base.get_transform().set_rotation(this._quaSrcRot);
                break;

            case CameraActor.ViewMode.RotateAroundObject:
                base.get_transform().set_position(this._vPointOfGaze + base.get_transform().TransformDirection(Vector3.get_back() * this._fSmoothDistance));
                base.get_transform().set_rotation(this._quaDestRot);
                this._vSmoothVelocity    = Vector3.get_zero();
                this._fSmoothTime        = 0.1f;
                this._fSmoothCorrectionY = 6f;
                break;

            case CameraActor.ViewMode.Rotation:
            {
                Vector3 vector  = Mathe.Direction(this._vPointOfGaze, this._vDestPos);
                Vector3 vector2 = this._quaDestRot * vector;
                base.get_transform().set_position(this._vPointOfGaze + vector2);
                base.get_transform().LookAt(this._vPointOfGaze);
                this._vSmoothVelocity = Vector3.get_zero();
                break;
            }

            case CameraActor.ViewMode.Bezier:
                base.get_transform().set_position(this._vSrcPos);
                base.get_transform().set_rotation(this._quaSrcRot);
                break;

            case (CameraActor.ViewMode) 11:
                this.eyePosition  = this._vSrcPos;
                this.eyeRotation  = this._quaSrcRot;
                this._fBezierTime = 0f;
                break;
            }
        }
 public static Vector2 NormalizeDirection(Vector2 from, Vector2 to)
 {
     return(Mathe.Direction(from, to).get_normalized());
 }
Beispiel #8
0
        protected virtual void _initCameraState()
        {
            _fYAxisLimit        = 0f;
            _fSmoothCorrectionY = 0f;
            _isThroughMaxY      = false;
            switch (_iViewMode)
            {
            case ViewMode.NotViewModeCtrl:
                break;

            case ViewMode.Fix:
                base.transform.position = _vSrcPos;
                base.transform.rotation = _quaSrcRot;
                _vSmoothVelocity        = Vector3.zero;
                break;

            case ViewMode.FixChasing:
                base.transform.position = _vDestPos;
                base.transform.LookAt(_vPointOfGaze);
                break;

            case ViewMode.FixChasingRot:
                base.transform.position = _vSrcPos;
                _quaTempRot             = base.transform.rotation;
                break;

            case ViewMode.ZoomChasing:
            {
                float d2 = _fSmoothDistance / Vector3.Distance(_vPointOfGaze, base.transform.position);
                _vDestPos        = _vPointOfGaze + (base.transform.position - _vPointOfGaze) * d2;
                _vSmoothVelocity = Vector3.zero;
                _fSmoothTime     = 0.2f;
                _isAdjust        = false;
                base.transform.LookAt(_vPointOfGaze);
                break;
            }

            case ViewMode.ZoomChasingUp:
            {
                float d = _fSmoothDistance / Vector3.Distance(_vPointOfGaze, base.transform.position);
                _vDestPos        = _vPointOfGaze + (base.transform.position - _vPointOfGaze) * d;
                _vSmoothVelocity = Vector3.zero;
                _fSmoothTime     = 0.2f;
                _isAdjust        = false;
                Vector3 position = base.transform.position;
                _fAdjustY = position.y + 10f;
                base.transform.LookAt(_vPointOfGaze);
                break;
            }

            case ViewMode.SmoothMove:
            case ViewMode.SmoothMoveKI2ndEdition:
                base.transform.position = _vSrcPos;
                base.transform.rotation = _quaSrcRot;
                break;

            case ViewMode.FixedPositionChasing:
                base.transform.position = _vPointOfGaze + base.transform.TransformDirection(Vector3.back * _fSmoothDistance);
                base.transform.rotation = _quaDestRot;
                _vSmoothVelocity        = Vector3.zero;
                _fSmoothTime            = 0.1f;
                _fSmoothCorrectionY     = 6f;
                break;

            case ViewMode.RotateAroundObject:
            {
                Vector3 point = Mathe.Direction(_vPointOfGaze, _vDestPos);
                Vector3 b     = _quaDestRot * point;
                base.transform.position = _vPointOfGaze + b;
                base.transform.LookAt(_vPointOfGaze);
                _vSmoothVelocity = Vector3.zero;
                break;
            }

            case ViewMode.Rotation:
                base.transform.position = _vSrcPos;
                base.transform.rotation = _quaSrcRot;
                break;

            case ViewMode.Bezier:
                eyePosition  = _vSrcPos;
                eyeRotation  = _quaSrcRot;
                _fBezierTime = 0f;
                break;
            }
        }