NeoAxis Engine version:3.x.x

��

mybb@mybb.ru (��) — Sat, 04 Mar 2023 09:39:38 +0300

� �� , �� ? �� ...�� -��, �� -��, �� , �� .

�� Actor

mybb@mybb.ru (��) — Sat, 04 Mar 2023 09:29:15 +0300

�� ? :)

�� ?

mybb@mybb.ru (��) — Sat, 04 Mar 2023 09:25:45 +0300

�� , � �� . �� .ogg � �� , � �� , �� .
��!!!!!!!!
�� , �� ...�� . � �� - �� , �� (� � �� , �� - ��, �� )...
�� , �� (�� ) � �� (��, � �� )?

��

mybb@mybb.ru (��) — Sat, 04 Mar 2023 09:10:49 +0300

�� .
�� , �� , �� .
https://www.youtube.com/watch?v=j_PASnp7KRY - Game

�� Unity

mybb@mybb.ru (Wowka70) — Thu, 27 May 2021 19:29:33 +0300

�� ! �� !!!

mybb@mybb.ru (Wowka70) — Wed, 19 May 2021 17:10:16 +0300

� �� .

�� + �� GameCharacterAI

mybb@mybb.ru (Gedifilyte) — Sun, 30 Aug 2020 18:05:42 +0300

�� .
�� , �� . �� , �� . �� , � �� , �� RTSFactionManager. �� , �� . �� 0, �� .

�� , �� UnitPoint. � �� 1000 �� UnitPoint � �� . �� (�� ), � �� , �� . �� , �� , � �� (�� , �� , �� ). �� , �� -�� . �� , �� , �� . �� , �� .

�� . �� .

��, �� PathfindingDemoGameWindow, �� .

�� , ��, �� GameEngineApp ��, �� PathfindingDemoGameWindow

�� .

� �� : Spawner � UnitPoint. �� .
��, �� , �� -��

��

mybb@mybb.ru (Gedifilyte) — Tue, 12 May 2020 15:01:35 +0300

�� , �� , �� .
�� :
�� : helicopter (�� ), stabilizator (�� , �� , �� , � �� "��"), mainPropeller (�� ), backPropeller (�� ). �� : �� HingeJoint � �� suspensionJoint, �� helicopter � �� mainPropeller � rotationJoint, �� backPropeller � �� helicopter. �� - UniversalJoint � �� stabilizeJoint �� stabilizator � �� helicopter. � �� . �� - X, �� - Y. � �� 0. �� GearedMotor. �� suspensionMotor �� suspensionJoint, �� rotationMotor �� rotationJoint.

��

� �� . �� Helicopter. �� Helicopter.cs �� ProjectEntities

��:

using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel;
using System.Drawing.Design;
using Engine;
using Engine.EntitySystem;
using Engine.MapSystem;
using Engine.MathEx;
using Engine.PhysicsSystem;
using Engine.Renderer;
using Engine.SoundSystem;
using Engine.Utils;
using ProjectCommon;
using System.IO;
using Engine.FileSystem;

namespace ProjectEntities
{
    public class HelicopterType : UnitType
    {
        [FieldSerialize]
        private float maxSpeedUp = 40f;

        [FieldSerialize]
        private float speedRotations = 1f;

        [FieldSerialize]
        private float maxSpeedMove = 80f;

        [FieldSerialize]
        private float maxForce = 85000f;

        [FieldSerialize]
        private float force = 50000f;

        [FieldSerialize]
        Range optimalAttackDistanceRange;

        [FieldSerialize]
        Degree towerTurnSpeed = 90;

        [FieldSerialize]
        string soundOn;

        [FieldSerialize]
        string soundOff;

        [FieldSerialize]
        string soundGearUp;

        [FieldSerialize]
        string soundGearDown;

        [FieldSerialize]
        Range gunRotationAngleRange = new Range(-80, 20);

        [FieldSerialize]
        List<Gear> gears = new List<Gear>();

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

        public class Gear
        {
            [FieldSerialize]
            int number;

            [FieldSerialize]
            Range speedRange;

            [FieldSerialize]
            string soundMotor;

            [FieldSerialize]
            [DefaultValue(typeof(Range), "1 1.2")]
            Range soundMotorPitchRange = new Range(1, 1.2f);

            //

            [DefaultValue(0)]
            public int Number
            {
                get { return number; }
                set { number = value; }
            }

            [DefaultValue(typeof(Range), "0 0")]
            public Range SpeedRange
            {
                get { return speedRange; }
                set { speedRange = value; }
            }

            [Editor(typeof(EditorSoundUITypeEditor), typeof(UITypeEditor))]
            public string SoundMotor
            {
                get { return soundMotor; }
                set { soundMotor = value; }
            }

            [DefaultValue(typeof(Range), "1 1.2")]
            public Range SoundMotorPitchRange
            {
                get { return soundMotorPitchRange; }
                set { soundMotorPitchRange = value; }
            }

            public override string ToString()
            {
                return string.Format("Gear {0}", number);
            }
        }

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

        public float MaxSpeedUp
        {
            get { return maxSpeedUp; }
            set { maxSpeedUp = value; }
        }

        public float SpeedRotations
        {
            get { return speedRotations; }
            set { speedRotations = value; }
        }

        public float MaxSpeedMove
        {
            get { return maxSpeedMove; }
            set { maxSpeedMove = value; }
        }

        public float MaxForce
        {
            get { return maxForce; }
            set { maxForce = value; }
        }

        public float Force
        {
            get { return force; }
            set { force = value; }
        }

        [Description("In degrees.")]
        [DefaultValue(typeof(Range), "-80 20")]
        public Range GunRotationAngleRange
        {
            get { return gunRotationAngleRange; }
            set { gunRotationAngleRange = value; }
        }

        [DefaultValue(typeof(Range), "0 0")]
        public Range OptimalAttackDistanceRange
        {
            get { return optimalAttackDistanceRange; }
            set { optimalAttackDistanceRange = value; }
        }

        [Description("Degrees per second.")]
        [DefaultValue(typeof(Degree), "90")]
        public Degree TowerTurnSpeed
        {
            get { return towerTurnSpeed; }
            set { towerTurnSpeed = value; }
        }

        [Editor(typeof(EditorSoundUITypeEditor), typeof(UITypeEditor))]
        public string SoundOn
        {
            get { return soundOn; }
            set { soundOn = value; }
        }

        [Editor(typeof(EditorSoundUITypeEditor), typeof(UITypeEditor))]
        public string SoundOff
        {
            get { return soundOff; }
            set { soundOff = value; }
        }

        public List<Gear> Gears
        {
            get { return gears; }
        }

        [Editor(typeof(EditorSoundUITypeEditor), typeof(UITypeEditor))]
        public string SoundGearUp
        {
            get { return soundGearUp; }
            set { soundGearUp = value; }
        }

        [Editor(typeof(EditorSoundUITypeEditor), typeof(UITypeEditor))]
        public string SoundGearDown
        {
            get { return soundGearDown; }
            set { soundGearDown = value; }
        }
    }

    public class Helicopter : Unit
    {
        private HelicopterType _type = null;
        public new HelicopterType Type
        {
            get { return _type; }
        }

        ///////////////////////////////////////////
        class Track
        {
            public float speed;
            public float server_sentSpeed;
        }
        ///////////////////////////////////////////

        Body helicopterBody; //��� ���� ������ ���������
        Body stabilizatorBody; //��� ���� �������������. ��������� ���, ������� ���� ����������� � ��������� ������ ���        
        //����������, ����� ��������� ��� � ����� ��������� ��� ������ ���������� UniversalJoint. ������������ ����� �����������
        //���� ���������, ����� ��� ����� �����������. ���� ������������� ������ ���� ��� ������� ���������, ����� ���� ���������
        //������ ����� � �� ����������� ����.
        float Mass, suspensionForce;
        GearedMotor suspensionMotor, rotationMotor;
        HingeJoint suspensionJoint, rotationJoint;
        UniversalJoint stabilizeJoint;
        bool isWorking = false;
        bool firstTick = true;

        float RL = 0;
        float FB1 = 0;
        float FB2 = 0;
        float RwLw1 = 0;
        float RwLw2 = 0;

        Body towerBody;
        Vec3 towerBodyLocalPosition;

        MapObjectAttachedMapObject mainGunAttachedObject;
        Gun mainGun;
        Vec3 mainGunOffsetPosition;

        SphereDir towerLocalDirection;
        SphereDir needTowerLocalDirection;
        SphereDir server_sentTowerLocalDirection;

        bool motorOn;
        string currentMotorSoundName;
        VirtualChannel motorSoundChannel;

        HelicopterType.Gear currentGear;
        Track leftTrack = new Track();
        Track rightTrack = new Track();

        protected override void OnPostCreate(bool loaded)
        {
            base.OnPostCreate(loaded);
            if (EngineApp.Instance.ApplicationType == EngineApp.ApplicationTypes.Simulation)
                GetPhysics();
            {

                if (EngineApp.Instance.ApplicationType != EngineApp.ApplicationTypes.ResourceEditor)
                {
                    if (PhysicsModel == null)
                    {
                        Log.Error("�� ��������� ������ ���������. ����� Helicopter, ���������: " + Name);
                        return;
                    }

                    helicopterBody = PhysicsModel.GetBody("helicopter");
                    if (helicopterBody == null)
                    {
                        Log.Error("���� 'helicopter' �� �������. ���� ��� �����������, ���� ������ ������������ ���. ����� Helicopter, ���������: " + Name);
                        return;
                    }
                    towerBody = PhysicsModel.GetBody("tower");
                    stabilizatorBody = PhysicsModel.GetBody("stabilizator");
                    if (stabilizatorBody == null)
                    {
                        Log.Error("���� 'stabilizator' �� �������. ���� ��� �����������, ���� ������ ������������ ���. ����� Helicopter, ���������: " + Name);
                        return;
                    }
                    stabilizeJoint = PhysicsModel.GetJoint("stabilizeJoint") as UniversalJoint;
                    if (stabilizeJoint == null)
                    {
                        Log.Error("���������� 'stabilizeJoint' �� �������. ���� ��� �����������, ���� ������ ������������ ���, ���� ���������� �� �������� UniversalJoint. ����� Helicopter, ���������: " + Name);
                        return;
                    }
                }
                //mainGun
                foreach (MapObjectAttachedObject attachedObject in AttachedObjects)
                {
                    MapObjectAttachedMapObject attachedMapObject = attachedObject as MapObjectAttachedMapObject;
                    if (attachedMapObject == null)
                        continue;

                    mainGun = attachedMapObject.MapObject as Gun;
                    if (mainGun != null)
                    {
                        mainGunAttachedObject = attachedMapObject;
                        mainGunOffsetPosition = attachedMapObject.PositionOffset;
                        break;
                    }
                }
                //towerBodyLocalPosition
                if (towerBody != null)
                    towerBodyLocalPosition = PhysicsModel.ModelDeclaration.GetBody(towerBody.Name).Position;

                //initialize currentGear
                currentGear = Type.Gears.Find(delegate(HelicopterType.Gear gear)
                {
                    return gear.Number == 0;
                });

                //disable contacts between chassisBody and towerBody
                if (helicopterBody != null && towerBody != null)
                {
                    foreach (Shape shape1 in helicopterBody.Shapes)
                    {
                        foreach (Shape shape2 in towerBody.Shapes)
                        {
                            PhysicsWorld.Instance.SetShapePairFlags(shape1, shape2,
                                ShapePairFlags.DisableContacts);
                        }
                    }
                }
            }
        }

        protected override void OnDestroy()
        {
            if (motorSoundChannel != null)
            {
                motorSoundChannel.Stop();
                motorSoundChannel = null;
            }
            base.OnDestroy();
        }

        protected override void OnRender(Camera camera)
        {
            //not very true update in the OnRender.
            //it is here because need update after all Ticks and before update attached objects.
            UpdateTowerTransform();
            base.OnRender(camera);
        }

        void TickTowerTurn()
        {
            //update direction
            if (towerLocalDirection != needTowerLocalDirection)
            {
                Radian turnSpeed = Type.TowerTurnSpeed;

                SphereDir needDirection = needTowerLocalDirection;
                SphereDir direction = towerLocalDirection;

                //update horizontal direction
                float diffHorizontalAngle = needDirection.Horizontal - direction.Horizontal;
                while (diffHorizontalAngle < -MathFunctions.PI)
                    diffHorizontalAngle += MathFunctions.PI * 2;
                while (diffHorizontalAngle > MathFunctions.PI)
                    diffHorizontalAngle -= MathFunctions.PI * 2;

                if (diffHorizontalAngle > 0)
                {
                    if (direction.Horizontal > needDirection.Horizontal)
                        direction.Horizontal -= MathFunctions.PI * 2;
                    direction.Horizontal += turnSpeed * TickDelta;
                    if (direction.Horizontal > needDirection.Horizontal)
                        direction.Horizontal = needDirection.Horizontal;
                }
                else
                {
                    if (direction.Horizontal < needDirection.Horizontal)
                        direction.Horizontal += MathFunctions.PI * 2;
                    direction.Horizontal -= turnSpeed * TickDelta;
                    if (direction.Horizontal < needDirection.Horizontal)
                        direction.Horizontal = needDirection.Horizontal;
                }

                //update vertical direction
                if (direction.Vertical < needDirection.Vertical)
                {
                    direction.Vertical += turnSpeed * TickDelta;
                    if (direction.Vertical > needDirection.Vertical)
                        direction.Vertical = needDirection.Vertical;
                }
                else
                {
                    direction.Vertical -= turnSpeed * TickDelta;
                    if (direction.Vertical < needDirection.Vertical)
                        direction.Vertical = needDirection.Vertical;
                }

                if (direction.Equals(needTowerLocalDirection, .001f))
                    towerLocalDirection = direction;

                towerLocalDirection = direction;
            }
        }

        private void GetPhysics()
        {
            //������ ����������� ��� ����� ���� ���, ���������� � ������� � ��������� �������� ��� �������� ������.
            //����������� ���������� �������. �� ��������� ����� ������� ������ � ��������� �����
            helicopterBody = PhysicsModel.GetBody("helicopter");
            if (helicopterBody == null) Log.Error("{0} - ���� 'helicopter' �� �������. ���� ��� �����������, ���� ������ ������������ ���. ����� Helicopter, ���������: " + Name, this);
            stabilizatorBody = PhysicsModel.GetBody("stabilizator");
            if (stabilizatorBody == null) Log.Error("{0} - ���� 'stabilizator' �� �������. ���� ��� �����������, ���� ������ ������������ ���. ����� Helicopter, ���������: " + Name, this);

            rotationJoint = PhysicsModel.GetJoint("rotationJoint") as HingeJoint;
            rotationMotor = PhysicsModel.GetMotor("rotationMotor") as GearedMotor;
            suspensionJoint = PhysicsModel.GetJoint("suspensionJoint") as HingeJoint;
            suspensionMotor = PhysicsModel.GetMotor("suspensionMotor") as GearedMotor;

            if (suspensionMotor == null) Log.Error("{0} - ����� 'stabilizationMotor' �� ������. ���� �� �����������, ���� ������ ������������ ���, ���� ����� �� �������� GearedMotor. ����� Helicopter, ���������: " + Name, this);
            if (suspensionJoint == null) Log.Error("{0} - ���������� 'suspensionJoint' �� �������. ���� ��� �����������, ���� ������ ������������ ���, ���� ���������� �� �������� HingeJoint. ����� Helicopter, ���������: " + Name, this);
            if (rotationJoint == null) Log.Error("{0} - ���������� 'rotationJoint' �� �������. ���� ��� �����������, ���� ������ ������������ ���, ���� ���������� �� �������� HingeJoint. ����� Helicopter, ���������: " + Name, this);
            if (rotationMotor == null) Log.Error("{0} - ����� 'rotationMotor' �� ������. ���� �� �����������, ���� ������ ������������ ���, ���� ����� �� �������� GearedMotor. ����� Helicopter, ���������: " + Name, this);

            foreach (Body b in PhysicsModel.Bodies) Mass += b.Mass;
            suspensionForce = (-PhysicsWorld.Instance.MainScene.Gravity.Z * Mass) + Type.Force;
        }

        private void Starting()
        {
            if (suspensionJoint.Broken) return;
            if (Intellect == null)
            {
                isWorking = false;
                suspensionMotor.Throttle = 0;
                rotationMotor.Throttle = 0;
            }
            else if (!isWorking && suspensionMotor.Throttle < 1)
            {
                suspensionMotor.Throttle += (TickDelta / 7);
                rotationMotor.Throttle += (TickDelta / 7);
            }
            else
                isWorking = true;
        }

        private void MoveUpDown()
        {
            Vec3 ForceVec = new Vec3(0, 0, suspensionForce);

            if (Intellect.IsControlKeyPressed(GameControlKeys.Jump) && GetSpeed().Z < Type.MaxSpeedUp)
                stabilizatorBody.AddForce(ForceType.GlobalAtLocalPos, TickDelta, ForceVec, Vec3.Zero);
            else if (Intellect.IsControlKeyPressed(GameControlKeys.Run) && GetSpeed().Z > -Type.MaxSpeedUp)
                stabilizatorBody.AddForce(ForceType.GlobalAtLocalPos, TickDelta, -ForceVec, Vec3.Zero);
        }

        private void MoveForwardBackward()
        {
            if (Intellect.IsControlKeyPressed(GameControlKeys.Forward))
            {
                if (GetSpeed().X < Type.MaxSpeedMove)
                    stabilizatorBody.AddForce(ForceType.LocalAtLocalPos, TickDelta, new Vec3(Type.Force, 0, 0), Vec3.Zero);
            }
            else if (Intellect.IsControlKeyPressed(GameControlKeys.Backward))
            {
                if (GetSpeed().X < Type.MaxSpeedMove)
                    stabilizatorBody.AddForce(ForceType.LocalAtLocalPos, TickDelta, new Vec3(-Type.Force, 0, 0), Vec3.Zero);
            }
        }

        private void MoveLeftRight()
        {
            if (Intellect.IsControlKeyPressed(GameControlKeys.Rightward))
            {
                if (GetSpeed().X < Type.MaxSpeedMove)
                    stabilizatorBody.AddForce(ForceType.LocalAtLocalPos, TickDelta, new Vec3(0, -Type.Force, 0), Vec3.Zero);
            }
            else if (Intellect.IsControlKeyPressed(GameControlKeys.Leftward))
                if (GetSpeed().X < Type.MaxSpeedMove)
                    stabilizatorBody.AddForce(ForceType.LocalAtLocalPos, TickDelta, new Vec3(0, Type.Force, 0), Vec3.Zero);
        }

        private void Rotate()
        {
            //������� ���� �������� �� ������ � �� ������ ���������, ��������� � ���������
            //���� ����������� ����������� ��������� �������� ������������ � UniversalJoint, ������� �� ��������� 0
            //� �� ���� ��������� �����������
            if (rotationJoint.Broken) return;

            if (RL < 20)
                RL += Intellect.GetControlKeyStrength(GameControlKeys.Left); //����, � ������� ���� ��������� ���������������
            if (RL > -20)
                RL -= Intellect.GetControlKeyStrength(GameControlKeys.Right);

            if (FB1 < 30)
                FB1 += Intellect.GetControlKeyStrength(GameControlKeys.Backward) * 2;
            if (FB1 > 0 && FB1 < 30)
                stabilizeJoint.Axis2.LimitHigh = FB1; //��������� ���� ����� �� 30 ��������
            if (FB2 > -30)
                FB2 -= Intellect.GetControlKeyStrength(GameControlKeys.Forward) * 2;
            if (FB2 < 0 && FB2 > -30)
                stabilizeJoint.Axis2.LimitLow = FB2; //��������� ���� ������ �� 30 ��������

            if (RwLw1 < 30)
                RwLw1 += Intellect.GetControlKeyStrength(GameControlKeys.Leftward) * 2;
            if (RwLw1 > 0 && RwLw1 < 30)
                stabilizeJoint.Axis1.LimitHigh = RwLw1; //��������� ���� ����� �� 30 ��������
            if (RwLw2 > -30)
                RwLw2 -= Intellect.GetControlKeyStrength(GameControlKeys.Rightward) * 2;
            if (RwLw2 < 0 && RwLw2 > -30)
                stabilizeJoint.Axis1.LimitLow = RwLw2; //��������� ���� ������ �� 30 ��������

            stabilizatorBody.AngularVelocity = new Vec3(0, 0, RL * Type.SpeedRotations); //���������� ���� � ���� ��� ��������
            //�� ��� Z. �������� ��������, ��� �������������� �� ��� Z ������ �� ���� ���������, � ���� �������������, �������
            //������ ����� �� ����� ���� ���������
        }

        private void Stabilization()
        {
            if (rotationJoint.Broken)
            {
                if (!suspensionJoint.Broken && suspensionMotor.Throttle != 0)
                    stabilizatorBody.AngularVelocity = new Vec3(0, 0, 3);
            }
            else stabilizatorBody.AddForce(ForceType.GlobalAtLocalPos, TickDelta,
                                         -PhysicsWorld.Instance.MainScene.Gravity * Mass, Vec3.Zero);
            //�������������� ������������ ���������
            if (RL > 0) RL -= 0.1f;
            if (RL < 0) RL += 0.1f;
            if (FB1 > 0) FB1 -= 1f;
            if (FB2 < 0) FB2 += 1f;
            if (RwLw1 > 0) RwLw1 -= 1f;
            if (RwLw2 < 0) RwLw2 += 1f;
        }

        //not ideal true
        private Vec3 GetSpeed()
        {
            Vec3 v = Vec3.Zero;
            Vec3 linearVelocity = stabilizatorBody.LinearVelocity;
            Vec3 angularVelocity = stabilizatorBody.AngularVelocity;
            //optimization
            if (linearVelocity.Equals(Vec3.Zero, .2f) && angularVelocity.Equals(Vec3.Zero, .2f)) return v;
            Vec3 localLinearVelocity = linearVelocity * stabilizatorBody.Rotation.GetInverse();

            v.X = localLinearVelocity.X + Math.Abs(angularVelocity.X) * 2;
            v.Y = localLinearVelocity.Y + Math.Abs(angularVelocity.Y) * 2;
            v.Z = localLinearVelocity.Z + Math.Abs(angularVelocity.Z) * 2;

            return v;
        }

        protected override void OnTick()
        {
            base.OnTick();

            bool lastMotorOn = motorOn;
            motorOn = Intellect != null && Intellect.IsActive();

            if (motorOn != lastMotorOn)
            {
                if (motorOn)
                    SoundPlay3D(Type.SoundOn, .7f, true);
            }
            if (motorSoundChannel != null && !motorOn)
            {
                motorSoundChannel.Pause = true;
                if (motorOn != lastMotorOn)
                {
                    if (!motorOn)
                        SoundPlay3D(Type.SoundOff, .7f, true);
                }
            }
            else if (motorSoundChannel != null && Intellect != null && isWorking == true)
                motorSoundChannel.Pause = false;

            TickTowerTurn();
            firstTick = false;
            Starting();

            if (!isWorking)
                return;

            Stabilization();

            if (!suspensionJoint.Broken)
            {
                MoveUpDown();
                MoveForwardBackward();
                MoveLeftRight();
                Rotate();
            }
            else
                isWorking = false;

            TickMotorSound();
            TickCurrentGear();

            if (Intellect != null)
            {
                if (Intellect.IsControlKeyPressed(GameControlKeys.Fire1))
                    if (GunsTryFire(false))
                        if (Intellect.IsControlKeyPressed(GameControlKeys.Fire2))
                            GunsTryFire(true);
            }
            {
                //send tower local direction to clients
                if (EntitySystemWorld.Instance.IsServer())
                    Server_TickSendTowerLocalDirection();

                //!!!!!should use for disabled renderer
                if (EntitySystemWorld.Instance.IsDedicatedServer())
                    UpdateTowerTransform();
            }
        }

        void Print(string Text)
        {
            //����� ��� �������� ������ ����.
            //����� ��� �������������, ������� � ������ ��� �����: Print("�����-�� �����" + ����������, �������� Health);
            //� ���� � ��������� ��������� ������ ��� ������ ������ "~" ����� ������������ ��� �����
            if (EngineConsole.Instance == null) return;
            EngineConsole.Instance.Print(Text);
        }

        void TickMotorSound()
        {
            string needSoundName = null;
            if (currentGear != null)
                needSoundName = currentGear.SoundMotor;

            if (needSoundName != currentMotorSoundName)
            {
                //change motor sound

                currentMotorSoundName = needSoundName;

                if (!string.IsNullOrEmpty(needSoundName))
                {
                    Sound sound = SoundWorld.Instance.SoundCreate(
                        RelativePathUtils.ConvertToFullPath(Path.GetDirectoryName(Type.FilePath), needSoundName),
                        SoundMode.Mode3D | SoundMode.Loop);

                    if (sound != null)
                    {
                        motorSoundChannel = SoundWorld.Instance.SoundPlay(
                            sound, EngineApp.Instance.DefaultSoundChannelGroup, .3f, true);
                        motorSoundChannel.Position = Position;
                        switch (Type.SoundRolloffMode)
                        {
                            case DynamicType.SoundRolloffModes.Logarithmic:
                                motorSoundChannel.SetLogarithmicRolloff(Type.SoundMinDistance, Type.SoundMaxDistance,
                                    Type.SoundRolloffLogarithmicFactor);
                                break;
                            case DynamicType.SoundRolloffModes.Linear:
                                motorSoundChannel.SetLinearRolloff(Type.SoundMinDistance, Type.SoundMaxDistance);
                                break;
                        }
                        motorSoundChannel.Pause = false;
                    }
                }
            }

            //update motor channel position and pitch
            if (motorSoundChannel != null)
            {
                Range speedRangeAbs = currentGear.SpeedRange;
                if (speedRangeAbs.Minimum < 0 && speedRangeAbs.Maximum < 0)
                    speedRangeAbs = new Range(-speedRangeAbs.Maximum, -speedRangeAbs.Minimum);
                Range pitchRange = currentGear.SoundMotorPitchRange;

                float speedCoef = 0;
                MathFunctions.Clamp(ref speedCoef, 0, 1);

                //update channel
                motorSoundChannel.Pitch = pitchRange.Minimum + speedCoef * pitchRange.Size();
                motorSoundChannel.Position = Position;
            }
        }

        protected override void Client_OnTick()
        {
            base.Client_OnTick();

            TickCurrentGear();
            TickMotorSound();
            firstTick = false;
        }

        void TickCurrentGear()
        {
            //currently gears used only for sounds

            if (currentGear == null)
                return;

            if (motorOn)
            {
                float speed = Math.Max(leftTrack.speed, rightTrack.speed);

                HelicopterType.Gear newGear = null;

                if (speed < currentGear.SpeedRange.Minimum || speed > currentGear.SpeedRange.Maximum)
                {
                    //find new gear
                    newGear = Type.Gears.Find(delegate(HelicopterType.Gear gear)
                    {
                        return speed >= gear.SpeedRange.Minimum && speed <= gear.SpeedRange.Maximum;
                    });
                }

                if (newGear != null && currentGear != newGear)
                {
                    //change gear
                    HelicopterType.Gear oldGear = currentGear;
                    OnGearChange(oldGear, newGear);
                    currentGear = newGear;
                }
            }
            else
            {
                if (currentGear.Number != 0)
                {
                    currentGear = Type.Gears.Find(delegate(HelicopterType.Gear gear)
                    {
                        return gear.Number == 0;
                    });
                }
            }
        }

        void OnGearChange(HelicopterType.Gear oldGear, HelicopterType.Gear newGear)
        {
            if (!firstTick && Health != 0)
            {
                bool up = Math.Abs(newGear.Number) > Math.Abs(oldGear.Number);
                string soundName = up ? Type.SoundGearUp : Type.SoundGearDown;
                SoundPlay3D(soundName, .7f, true);
            }
        }

        [Browsable(false)]
        public Gun MainGun
        {
            get { return mainGun; }
        }

        void UpdateTowerTransform()
        {
            if (towerBody == null || helicopterBody == null || mainGunAttachedObject == null)
                return;

            Radian horizontalAngle = towerLocalDirection.Horizontal;
            Radian verticalAngle = towerLocalDirection.Vertical;

            Range gunRotationRange = Type.GunRotationAngleRange * MathFunctions.PI / 180.0f;
            if (verticalAngle < gunRotationRange.Minimum)
                verticalAngle = gunRotationRange.Minimum;
            if (verticalAngle > gunRotationRange.Maximum)
                verticalAngle = gunRotationRange.Maximum;

            //update tower body
            towerBody.Position = GetInterpolatedPosition() +
                GetInterpolatedRotation() * towerBodyLocalPosition;
            towerBody.Rotation = GetInterpolatedRotation() *
                new Angles(0, 0, -horizontalAngle.InDegrees()).ToQuat();
            towerBody.Sleeping = true;

            //update gun vertical rotation
            Quat verticalRotation = new Angles(0, verticalAngle.InDegrees(), 0).ToQuat();
            mainGunAttachedObject.RotationOffset = verticalRotation;
        }

        bool GunsTryFire(bool alternative)
        {
            bool fire = false;

            foreach (MapObjectAttachedObject attachedObject in AttachedObjects)
            {
                MapObjectAttachedMapObject attachedMapObject = attachedObject as MapObjectAttachedMapObject;
                if (attachedMapObject == null)
                    continue;

                Gun gun = attachedMapObject.MapObject as Gun;

                if (gun != null)
                {
                    if (gun.TryFire(alternative))
                        fire = true;
                }
            }

            return fire;
        }

        public void SetMomentaryTurnToPosition(Vec3 pos)
        {
            if (towerBody == null)
                return;

            Vec3 direction = pos - towerBody.Position;
            towerLocalDirection = SphereDir.FromVector(Rotation.GetInverse() * direction);
            needTowerLocalDirection = towerLocalDirection;
        }

        public void SetNeedTurnToPosition(Vec3 pos)
        {
            if (towerBody == null)
                return;

            if (Type.TowerTurnSpeed != 0)
            {
                Vec3 direction = pos - towerBody.Position;
                needTowerLocalDirection = SphereDir.FromVector(Rotation.GetInverse() * direction);
            }
            else
                SetMomentaryTurnToPosition(pos);
        }

        protected override void Server_OnClientConnectedAfterPostCreate(
            RemoteEntityWorld remoteEntityWorld)
        {
            base.Server_OnClientConnectedAfterPostCreate(remoteEntityWorld);

            RemoteEntityWorld[] worlds = new RemoteEntityWorld[] { remoteEntityWorld };
            Server_SendTowerLocalDirectionToClients(worlds);
        }

        void Server_TickSendTowerLocalDirection()
        {
            float epsilon = new Degree(.5f).InRadians();
            if (!towerLocalDirection.Equals(server_sentTowerLocalDirection, epsilon))
            {
                Server_SendTowerLocalDirectionToClients(EntitySystemWorld.Instance.RemoteEntityWorlds);
                server_sentTowerLocalDirection = towerLocalDirection;
            }
        }

        void Server_SendTowerLocalDirectionToClients(IList<RemoteEntityWorld> remoteEntityWorlds)
        {
            SendDataWriter writer = BeginNetworkMessage(remoteEntityWorlds, typeof(Helicopter),
                (ushort)NetworkMessages.TowerLocalDirectionToClient);
            writer.Write(towerLocalDirection);
            EndNetworkMessage();
        }

        [NetworkReceive(NetworkDirections.ToClient, (ushort)NetworkMessages.TowerLocalDirectionToClient)]
        void Client_ReceiveTowerLocalDirection(RemoteEntityWorld sender, ReceiveDataReader reader)
        {
            SphereDir value = reader.ReadSphereDir();
            if (!reader.Complete())
                return;
            towerLocalDirection = value;
        }

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

        enum NetworkMessages
        {
            TowerLocalDirectionToClient,
            TracksSpeedToClient,
        }

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

    }
}

��
�� GameControlKeys. �� . �� . �� Use ��

��:

[DefaultKeyboardMouseValue( EKeys.F )]
 Use,

[DefaultKeyboardMouseValue(EKeys.E)]
 Rightward,

[DefaultKeyboardMouseValue(EKeys.Q)]
 Leftward,

�� PlayerIntellect. �� void ServerOrSingle_RestoreMainControlledUnit() � � �� Tank specific

��:

if( ControlledObject != null )
{
       //Tank specific
       if( ControlledObject is Tank || ControlledObject is Car )

�� ControlledObject is Helicopter

��:

if( ControlledObject != null )
{
 //Tank specific
 if( ControlledObject is Tank || ControlledObject is Car || ControlledObject is Helicopter )

� �� ActionGameWindow, �� void UpdateHUD(). � �� Tank specific �� Helicopter

��:

//Tank specific
Tank tank = playerUnit as Tank;
if( tank != null )
    weapon = tank.MainGun;

//Helicopter specific
Helicopter heli = playerUnit as Helicopter;
if (heli != null)
    weapon = heli.MainGun;

�� , � �� void DrawTarget( GuiRenderer renderer )

� �� , �� Tank specific DrawTankGunTarget(renderer) �� Helicopter

��:

//Tank specific
DrawTankGunTarget( renderer );

//Helicopter specific
DrawHeliGunTarget(renderer);

�� . ��, �� -��

��

mybb@mybb.ru (Gedifilyte) — Tue, 12 May 2020 14:55:01 +0300

��

� �� . �� Helicopter. �� Helicopter.cs �� ProjectEntities

��:

using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel;
using System.Drawing.Design;
using Engine;
using Engine.EntitySystem;
using Engine.MapSystem;
using Engine.MathEx;
using Engine.PhysicsSystem;
using Engine.Renderer;
using Engine.SoundSystem;
using Engine.Utils;
using ProjectCommon;
using System.IO;
using Engine.FileSystem;

namespace ProjectEntities
{
    public class HelicopterType : UnitType
    {
        [FieldSerialize]
        private float maxSpeedUp = 40f;

        [FieldSerialize]
        private float speedRotations = 1f;

        [FieldSerialize]
        private float maxSpeedMove = 80f;

        [FieldSerialize]
        private float maxForce = 85000f;

        [FieldSerialize]
        private float force = 50000f;

        [FieldSerialize]
        Range optimalAttackDistanceRange;

        [FieldSerialize]
        Degree towerTurnSpeed = 90;

        [FieldSerialize]
        string soundOn;

        [FieldSerialize]
        string soundOff;

        [FieldSerialize]
        string soundGearUp;

        [FieldSerialize]
        string soundGearDown;

        [FieldSerialize]
        Range gunRotationAngleRange = new Range(-80, 20);

        [FieldSerialize]
        List<Gear> gears = new List<Gear>();

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

        public class Gear
        {
            [FieldSerialize]
            int number;

            [FieldSerialize]
            Range speedRange;

            [FieldSerialize]
            string soundMotor;

            [FieldSerialize]
            [DefaultValue(typeof(Range), "1 1.2")]
            Range soundMotorPitchRange = new Range(1, 1.2f);

            //

            [DefaultValue(0)]
            public int Number
            {
                get { return number; }
                set { number = value; }
            }

            [DefaultValue(typeof(Range), "0 0")]
            public Range SpeedRange
            {
                get { return speedRange; }
                set { speedRange = value; }
            }

            [Editor(typeof(EditorSoundUITypeEditor), typeof(UITypeEditor))]
            public string SoundMotor
            {
                get { return soundMotor; }
                set { soundMotor = value; }
            }

            [DefaultValue(typeof(Range), "1 1.2")]
            public Range SoundMotorPitchRange
            {
                get { return soundMotorPitchRange; }
                set { soundMotorPitchRange = value; }
            }

            public override string ToString()
            {
                return string.Format("Gear {0}", number);
            }
        }

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

        public float MaxSpeedUp
        {
            get { return maxSpeedUp; }
            set { maxSpeedUp = value; }
        }

        public float SpeedRotations
        {
            get { return speedRotations; }
            set { speedRotations = value; }
        }

        public float MaxSpeedMove
        {
            get { return maxSpeedMove; }
            set { maxSpeedMove = value; }
        }

        public float MaxForce
        {
            get { return maxForce; }
            set { maxForce = value; }
        }

        public float Force
        {
            get { return force; }
            set { force = value; }
        }

        [Description("In degrees.")]
        [DefaultValue(typeof(Range), "-80 20")]
        public Range GunRotationAngleRange
        {
            get { return gunRotationAngleRange; }
            set { gunRotationAngleRange = value; }
        }

        [DefaultValue(typeof(Range), "0 0")]
        public Range OptimalAttackDistanceRange
        {
            get { return optimalAttackDistanceRange; }
            set { optimalAttackDistanceRange = value; }
        }

        [Description("Degrees per second.")]
        [DefaultValue(typeof(Degree), "90")]
        public Degree TowerTurnSpeed
        {
            get { return towerTurnSpeed; }
            set { towerTurnSpeed = value; }
        }

        [Editor(typeof(EditorSoundUITypeEditor), typeof(UITypeEditor))]
        public string SoundOn
        {
            get { return soundOn; }
            set { soundOn = value; }
        }

        [Editor(typeof(EditorSoundUITypeEditor), typeof(UITypeEditor))]
        public string SoundOff
        {
            get { return soundOff; }
            set { soundOff = value; }
        }

        public List<Gear> Gears
        {
            get { return gears; }
        }

        [Editor(typeof(EditorSoundUITypeEditor), typeof(UITypeEditor))]
        public string SoundGearUp
        {
            get { return soundGearUp; }
            set { soundGearUp = value; }
        }

        [Editor(typeof(EditorSoundUITypeEditor), typeof(UITypeEditor))]
        public string SoundGearDown
        {
            get { return soundGearDown; }
            set { soundGearDown = value; }
        }
    }

    public class Helicopter : Unit
    {
        private HelicopterType _type = null;
        public new HelicopterType Type
        {
            get { return _type; }
        }

        ///////////////////////////////////////////
        class Track
        {
            public float speed;
            public float server_sentSpeed;
        }
        ///////////////////////////////////////////

        Body helicopterBody; //��� ���� ������ ���������
        Body stabilizatorBody; //��� ���� �������������. ��������� ���, ������� ���� ����������� � ��������� ������ ���        
        //����������, ����� ��������� ��� � ����� ��������� ��� ������ ���������� UniversalJoint. ������������ ����� �����������
        //���� ���������, ����� ��� ����� �����������. ���� ������������� ������ ���� ��� ������� ���������, ����� ���� ���������
        //������ ����� � �� ����������� ����.
        float Mass, suspensionForce;
        GearedMotor suspensionMotor, rotationMotor;
        HingeJoint suspensionJoint, rotationJoint;
        UniversalJoint stabilizeJoint;
        bool isWorking = false;
        bool firstTick = true;

        float RL = 0;
        float FB1 = 0;
        float FB2 = 0;
        float RwLw1 = 0;
        float RwLw2 = 0;

        Body towerBody;
        Vec3 towerBodyLocalPosition;

        MapObjectAttachedMapObject mainGunAttachedObject;
        Gun mainGun;
        Vec3 mainGunOffsetPosition;

        SphereDir towerLocalDirection;
        SphereDir needTowerLocalDirection;
        SphereDir server_sentTowerLocalDirection;

        bool motorOn;
        string currentMotorSoundName;
        VirtualChannel motorSoundChannel;

        HelicopterType.Gear currentGear;
        Track leftTrack = new Track();
        Track rightTrack = new Track();

        protected override void OnPostCreate(bool loaded)
        {
            base.OnPostCreate(loaded);
            if (EngineApp.Instance.ApplicationType == EngineApp.ApplicationTypes.Simulation)
                GetPhysics();
            {

                if (EngineApp.Instance.ApplicationType != EngineApp.ApplicationTypes.ResourceEditor)
                {
                    if (PhysicsModel == null)
                    {
                        Log.Error("�� ��������� ������ ���������. ����� Helicopter, ���������: " + Name);
                        return;
                    }

                    helicopterBody = PhysicsModel.GetBody("helicopter");
                    if (helicopterBody == null)
                    {
                        Log.Error("���� 'helicopter' �� �������. ���� ��� �����������, ���� ������ ������������ ���. ����� Helicopter, ���������: " + Name);
                        return;
                    }
                    towerBody = PhysicsModel.GetBody("tower");
                    stabilizatorBody = PhysicsModel.GetBody("stabilizator");
                    if (stabilizatorBody == null)
                    {
                        Log.Error("���� 'stabilizator' �� �������. ���� ��� �����������, ���� ������ ������������ ���. ����� Helicopter, ���������: " + Name);
                        return;
                    }
                    stabilizeJoint = PhysicsModel.GetJoint("stabilizeJoint") as UniversalJoint;
                    if (stabilizeJoint == null)
                    {
                        Log.Error("���������� 'stabilizeJoint' �� �������. ���� ��� �����������, ���� ������ ������������ ���, ���� ���������� �� �������� UniversalJoint. ����� Helicopter, ���������: " + Name);
                        return;
                    }
                }
                //mainGun
                foreach (MapObjectAttachedObject attachedObject in AttachedObjects)
                {
                    MapObjectAttachedMapObject attachedMapObject = attachedObject as MapObjectAttachedMapObject;
                    if (attachedMapObject == null)
                        continue;

                    mainGun = attachedMapObject.MapObject as Gun;
                    if (mainGun != null)
                    {
                        mainGunAttachedObject = attachedMapObject;
                        mainGunOffsetPosition = attachedMapObject.PositionOffset;
                        break;
                    }
                }
                //towerBodyLocalPosition
                if (towerBody != null)
                    towerBodyLocalPosition = PhysicsModel.ModelDeclaration.GetBody(towerBody.Name).Position;

                //initialize currentGear
                currentGear = Type.Gears.Find(delegate(HelicopterType.Gear gear)
                {
                    return gear.Number == 0;
                });

                //disable contacts between chassisBody and towerBody
                if (helicopterBody != null && towerBody != null)
                {
                    foreach (Shape shape1 in helicopterBody.Shapes)
                    {
                        foreach (Shape shape2 in towerBody.Shapes)
                        {
                            PhysicsWorld.Instance.SetShapePairFlags(shape1, shape2,
                                ShapePairFlags.DisableContacts);
                        }
                    }
                }
            }
        }

        protected override void OnDestroy()
        {
            if (motorSoundChannel != null)
            {
                motorSoundChannel.Stop();
                motorSoundChannel = null;
            }
            base.OnDestroy();
        }

        protected override void OnRender(Camera camera)
        {
            //not very true update in the OnRender.
            //it is here because need update after all Ticks and before update attached objects.
            UpdateTowerTransform();
            base.OnRender(camera);
        }

        void TickTowerTurn()
        {
            //update direction
            if (towerLocalDirection != needTowerLocalDirection)
            {
                Radian turnSpeed = Type.TowerTurnSpeed;

                SphereDir needDirection = needTowerLocalDirection;
                SphereDir direction = towerLocalDirection;

                //update horizontal direction
                float diffHorizontalAngle = needDirection.Horizontal - direction.Horizontal;
                while (diffHorizontalAngle < -MathFunctions.PI)
                    diffHorizontalAngle += MathFunctions.PI * 2;
                while (diffHorizontalAngle > MathFunctions.PI)
                    diffHorizontalAngle -= MathFunctions.PI * 2;

                if (diffHorizontalAngle > 0)
                {
                    if (direction.Horizontal > needDirection.Horizontal)
                        direction.Horizontal -= MathFunctions.PI * 2;
                    direction.Horizontal += turnSpeed * TickDelta;
                    if (direction.Horizontal > needDirection.Horizontal)
                        direction.Horizontal = needDirection.Horizontal;
                }
                else
                {
                    if (direction.Horizontal < needDirection.Horizontal)
                        direction.Horizontal += MathFunctions.PI * 2;
                    direction.Horizontal -= turnSpeed * TickDelta;
                    if (direction.Horizontal < needDirection.Horizontal)
                        direction.Horizontal = needDirection.Horizontal;
                }

                //update vertical direction
                if (direction.Vertical < needDirection.Vertical)
                {
                    direction.Vertical += turnSpeed * TickDelta;
                    if (direction.Vertical > needDirection.Vertical)
                        direction.Vertical = needDirection.Vertical;
                }
                else
                {
                    direction.Vertical -= turnSpeed * TickDelta;
                    if (direction.Vertical < needDirection.Vertical)
                        direction.Vertical = needDirection.Vertical;
                }

                if (direction.Equals(needTowerLocalDirection, .001f))
                    towerLocalDirection = direction;

                towerLocalDirection = direction;
            }
        }

        private void GetPhysics()
        {
            //������ ����������� ��� ����� ���� ���, ���������� � ������� � ��������� �������� ��� �������� ������.
            //����������� ���������� �������. �� ��������� ����� ������� ������ � ��������� �����
            helicopterBody = PhysicsModel.GetBody("helicopter");
            if (helicopterBody == null) Log.Error("{0} - ���� 'helicopter' �� �������. ���� ��� �����������, ���� ������ ������������ ���. ����� Helicopter, ���������: " + Name, this);
            stabilizatorBody = PhysicsModel.GetBody("stabilizator");
            if (stabilizatorBody == null) Log.Error("{0} - ���� 'stabilizator' �� �������. ���� ��� �����������, ���� ������ ������������ ���. ����� Helicopter, ���������: " + Name, this);

            rotationJoint = PhysicsModel.GetJoint("rotationJoint") as HingeJoint;
            rotationMotor = PhysicsModel.GetMotor("rotationMotor") as GearedMotor;
            suspensionJoint = PhysicsModel.GetJoint("suspensionJoint") as HingeJoint;
            suspensionMotor = PhysicsModel.GetMotor("suspensionMotor") as GearedMotor;

            if (suspensionMotor == null) Log.Error("{0} - ����� 'stabilizationMotor' �� ������. ���� �� �����������, ���� ������ ������������ ���, ���� ����� �� �������� GearedMotor. ����� Helicopter, ���������: " + Name, this);
            if (suspensionJoint == null) Log.Error("{0} - ���������� 'suspensionJoint' �� �������. ���� ��� �����������, ���� ������ ������������ ���, ���� ���������� �� �������� HingeJoint. ����� Helicopter, ���������: " + Name, this);
            if (rotationJoint == null) Log.Error("{0} - ���������� 'rotationJoint' �� �������. ���� ��� �����������, ���� ������ ������������ ���, ���� ���������� �� �������� HingeJoint. ����� Helicopter, ���������: " + Name, this);
            if (rotationMotor == null) Log.Error("{0} - ����� 'rotationMotor' �� ������. ���� �� �����������, ���� ������ ������������ ���, ���� ����� �� �������� GearedMotor. ����� Helicopter, ���������: " + Name, this);

            foreach (Body b in PhysicsModel.Bodies) Mass += b.Mass;
            suspensionForce = (-PhysicsWorld.Instance.MainScene.Gravity.Z * Mass) + Type.Force;
        }

        private void Starting()
        {
            if (suspensionJoint.Broken) return;
            if (Intellect == null)
            {
                isWorking = false;
                suspensionMotor.Throttle = 0;
                rotationMotor.Throttle = 0;
            }
            else if (!isWorking && suspensionMotor.Throttle < 1)
            {
                suspensionMotor.Throttle += (TickDelta / 7);
                rotationMotor.Throttle += (TickDelta / 7);
            }
            else
                isWorking = true;
        }

        private void MoveUpDown()
        {
            Vec3 ForceVec = new Vec3(0, 0, suspensionForce);

            if (Intellect.IsControlKeyPressed(GameControlKeys.Jump) && GetSpeed().Z < Type.MaxSpeedUp)
                stabilizatorBody.AddForce(ForceType.GlobalAtLocalPos, TickDelta, ForceVec, Vec3.Zero);
            else if (Intellect.IsControlKeyPressed(GameControlKeys.Run) && GetSpeed().Z > -Type.MaxSpeedUp)
                stabilizatorBody.AddForce(ForceType.GlobalAtLocalPos, TickDelta, -ForceVec, Vec3.Zero);
        }

        private void MoveForwardBackward()
        {
            if (Intellect.IsControlKeyPressed(GameControlKeys.Forward))
            {
                if (GetSpeed().X < Type.MaxSpeedMove)
                    stabilizatorBody.AddForce(ForceType.LocalAtLocalPos, TickDelta, new Vec3(Type.Force, 0, 0), Vec3.Zero);
            }
            else if (Intellect.IsControlKeyPressed(GameControlKeys.Backward))
            {
                if (GetSpeed().X < Type.MaxSpeedMove)
                    stabilizatorBody.AddForce(ForceType.LocalAtLocalPos, TickDelta, new Vec3(-Type.Force, 0, 0), Vec3.Zero);
            }
        }

        private void MoveLeftRight()
        {
            if (Intellect.IsControlKeyPressed(GameControlKeys.Rightward))
            {
                if (GetSpeed().X < Type.MaxSpeedMove)
                    stabilizatorBody.AddForce(ForceType.LocalAtLocalPos, TickDelta, new Vec3(0, -Type.Force, 0), Vec3.Zero);
            }
            else if (Intellect.IsControlKeyPressed(GameControlKeys.Leftward))
                if (GetSpeed().X < Type.MaxSpeedMove)
                    stabilizatorBody.AddForce(ForceType.LocalAtLocalPos, TickDelta, new Vec3(0, Type.Force, 0), Vec3.Zero);
        }

        private void Rotate()
        {
            //������� ���� �������� �� ������ � �� ������ ���������, ��������� � ���������
            //���� ����������� ����������� ��������� �������� ������������ � UniversalJoint, ������� �� ��������� 0
            //� �� ���� ��������� �����������
            if (rotationJoint.Broken) return;

            if (RL < 20)
                RL += Intellect.GetControlKeyStrength(GameControlKeys.Left); //����, � ������� ���� ��������� ���������������
            if (RL > -20)
                RL -= Intellect.GetControlKeyStrength(GameControlKeys.Right);

            if (FB1 < 30)
                FB1 += Intellect.GetControlKeyStrength(GameControlKeys.Backward) * 2;
            if (FB1 > 0 && FB1 < 30)
                stabilizeJoint.Axis2.LimitHigh = FB1; //��������� ���� ����� �� 30 ��������
            if (FB2 > -30)
                FB2 -= Intellect.GetControlKeyStrength(GameControlKeys.Forward) * 2;
            if (FB2 < 0 && FB2 > -30)
                stabilizeJoint.Axis2.LimitLow = FB2; //��������� ���� ������ �� 30 ��������

            if (RwLw1 < 30)
                RwLw1 += Intellect.GetControlKeyStrength(GameControlKeys.Leftward) * 2;
            if (RwLw1 > 0 && RwLw1 < 30)
                stabilizeJoint.Axis1.LimitHigh = RwLw1; //��������� ���� ����� �� 30 ��������
            if (RwLw2 > -30)
                RwLw2 -= Intellect.GetControlKeyStrength(GameControlKeys.Rightward) * 2;
            if (RwLw2 < 0 && RwLw2 > -30)
                stabilizeJoint.Axis1.LimitLow = RwLw2; //��������� ���� ������ �� 30 ��������

            stabilizatorBody.AngularVelocity = new Vec3(0, 0, RL * Type.SpeedRotations); //���������� ���� � ���� ��� ��������
            //�� ��� Z. �������� ��������, ��� �������������� �� ��� Z ������ �� ���� ���������, � ���� �������������, �������
            //������ ����� �� ����� ���� ���������
        }

        private void Stabilization()
        {
            if (rotationJoint.Broken)
            {
                if (!suspensionJoint.Broken && suspensionMotor.Throttle != 0)
                    stabilizatorBody.AngularVelocity = new Vec3(0, 0, 3);
            }
            else stabilizatorBody.AddForce(ForceType.GlobalAtLocalPos, TickDelta,
                                         -PhysicsWorld.Instance.MainScene.Gravity * Mass, Vec3.Zero);
            //�������������� ������������ ���������
            if (RL > 0) RL -= 0.1f;
            if (RL < 0) RL += 0.1f;
            if (FB1 > 0) FB1 -= 1f;
            if (FB2 < 0) FB2 += 1f;
            if (RwLw1 > 0) RwLw1 -= 1f;
            if (RwLw2 < 0) RwLw2 += 1f;
        }

        //not ideal true
        private Vec3 GetSpeed()
        {
            Vec3 v = Vec3.Zero;
            Vec3 linearVelocity = stabilizatorBody.LinearVelocity;
            Vec3 angularVelocity = stabilizatorBody.AngularVelocity;
            //optimization
            if (linearVelocity.Equals(Vec3.Zero, .2f) && angularVelocity.Equals(Vec3.Zero, .2f)) return v;
            Vec3 localLinearVelocity = linearVelocity * stabilizatorBody.Rotation.GetInverse();

            v.X = localLinearVelocity.X + Math.Abs(angularVelocity.X) * 2;
            v.Y = localLinearVelocity.Y + Math.Abs(angularVelocity.Y) * 2;
            v.Z = localLinearVelocity.Z + Math.Abs(angularVelocity.Z) * 2;

            return v;
        }

        protected override void OnTick()
        {
            base.OnTick();

            bool lastMotorOn = motorOn;
            motorOn = Intellect != null && Intellect.IsActive();

            if (motorOn != lastMotorOn)
            {
                if (motorOn)
                    SoundPlay3D(Type.SoundOn, .7f, true);
            }
            if (motorSoundChannel != null && !motorOn)
            {
                motorSoundChannel.Pause = true;
                if (motorOn != lastMotorOn)
                {
                    if (!motorOn)
                        SoundPlay3D(Type.SoundOff, .7f, true);
                }
            }
            else if (motorSoundChannel != null && Intellect != null && isWorking == true)
                motorSoundChannel.Pause = false;

            TickTowerTurn();
            firstTick = false;
            Starting();

            if (!isWorking)
                return;

            Stabilization();

            if (!suspensionJoint.Broken)
            {
                MoveUpDown();
                MoveForwardBackward();
                MoveLeftRight();
                Rotate();
            }
            else
                isWorking = false;

            TickMotorSound();
            TickCurrentGear();

            if (Intellect != null)
            {
                if (Intellect.IsControlKeyPressed(GameControlKeys.Fire1))
                    if (GunsTryFire(false))
                        if (Intellect.IsControlKeyPressed(GameControlKeys.Fire2))
                            GunsTryFire(true);
            }
            {
                //send tower local direction to clients
                if (EntitySystemWorld.Instance.IsServer())
                    Server_TickSendTowerLocalDirection();

                //!!!!!should use for disabled renderer
                if (EntitySystemWorld.Instance.IsDedicatedServer())
                    UpdateTowerTransform();
            }
        }

        void Print(string Text)
        {
            //����� ��� �������� ������ ����.
            //����� ��� �������������, ������� � ������ ��� �����: Print("�����-�� �����" + ����������, �������� Health);
            //� ���� � ��������� ��������� ������ ��� ������ ������ "~" ����� ������������ ��� �����
            if (EngineConsole.Instance == null) return;
            EngineConsole.Instance.Print(Text);
        }

        void TickMotorSound()
        {
            string needSoundName = null;
            if (currentGear != null)
                needSoundName = currentGear.SoundMotor;

            if (needSoundName != currentMotorSoundName)
            {
                //change motor sound

                currentMotorSoundName = needSoundName;

                if (!string.IsNullOrEmpty(needSoundName))
                {
                    Sound sound = SoundWorld.Instance.SoundCreate(
                        RelativePathUtils.ConvertToFullPath(Path.GetDirectoryName(Type.FilePath), needSoundName),
                        SoundMode.Mode3D | SoundMode.Loop);

                    if (sound != null)
                    {
                        motorSoundChannel = SoundWorld.Instance.SoundPlay(
                            sound, EngineApp.Instance.DefaultSoundChannelGroup, .3f, true);
                        motorSoundChannel.Position = Position;
                        switch (Type.SoundRolloffMode)
                        {
                            case DynamicType.SoundRolloffModes.Logarithmic:
                                motorSoundChannel.SetLogarithmicRolloff(Type.SoundMinDistance, Type.SoundMaxDistance,
                                    Type.SoundRolloffLogarithmicFactor);
                                break;
                            case DynamicType.SoundRolloffModes.Linear:
                                motorSoundChannel.SetLinearRolloff(Type.SoundMinDistance, Type.SoundMaxDistance);
                                break;
                        }
                        motorSoundChannel.Pause = false;
                    }
                }
            }

            //update motor channel position and pitch
            if (motorSoundChannel != null)
            {
                Range speedRangeAbs = currentGear.SpeedRange;
                if (speedRangeAbs.Minimum < 0 && speedRangeAbs.Maximum < 0)
                    speedRangeAbs = new Range(-speedRangeAbs.Maximum, -speedRangeAbs.Minimum);
                Range pitchRange = currentGear.SoundMotorPitchRange;

                float speedCoef = 0;
                MathFunctions.Clamp(ref speedCoef, 0, 1);

                //update channel
                motorSoundChannel.Pitch = pitchRange.Minimum + speedCoef * pitchRange.Size();
                motorSoundChannel.Position = Position;
            }
        }

        protected override void Client_OnTick()
        {
            base.Client_OnTick();

            TickCurrentGear();
            TickMotorSound();
            firstTick = false;
        }

        void TickCurrentGear()
        {
            //currently gears used only for sounds

            if (currentGear == null)
                return;

            if (motorOn)
            {
                float speed = Math.Max(leftTrack.speed, rightTrack.speed);

                HelicopterType.Gear newGear = null;

                if (speed < currentGear.SpeedRange.Minimum || speed > currentGear.SpeedRange.Maximum)
                {
                    //find new gear
                    newGear = Type.Gears.Find(delegate(HelicopterType.Gear gear)
                    {
                        return speed >= gear.SpeedRange.Minimum && speed <= gear.SpeedRange.Maximum;
                    });
                }

                if (newGear != null && currentGear != newGear)
                {
                    //change gear
                    HelicopterType.Gear oldGear = currentGear;
                    OnGearChange(oldGear, newGear);
                    currentGear = newGear;
                }
            }
            else
            {
                if (currentGear.Number != 0)
                {
                    currentGear = Type.Gears.Find(delegate(HelicopterType.Gear gear)
                    {
                        return gear.Number == 0;
                    });
                }
            }
        }

        void OnGearChange(HelicopterType.Gear oldGear, HelicopterType.Gear newGear)
        {
            if (!firstTick && Health != 0)
            {
                bool up = Math.Abs(newGear.Number) > Math.Abs(oldGear.Number);
                string soundName = up ? Type.SoundGearUp : Type.SoundGearDown;
                SoundPlay3D(soundName, .7f, true);
            }
        }

        [Browsable(false)]
        public Gun MainGun
        {
            get { return mainGun; }
        }

        void UpdateTowerTransform()
        {
            if (towerBody == null || helicopterBody == null || mainGunAttachedObject == null)
                return;

            Radian horizontalAngle = towerLocalDirection.Horizontal;
            Radian verticalAngle = towerLocalDirection.Vertical;

            Range gunRotationRange = Type.GunRotationAngleRange * MathFunctions.PI / 180.0f;
            if (verticalAngle < gunRotationRange.Minimum)
                verticalAngle = gunRotationRange.Minimum;
            if (verticalAngle > gunRotationRange.Maximum)
                verticalAngle = gunRotationRange.Maximum;

            //update tower body
            towerBody.Position = GetInterpolatedPosition() +
                GetInterpolatedRotation() * towerBodyLocalPosition;
            towerBody.Rotation = GetInterpolatedRotation() *
                new Angles(0, 0, -horizontalAngle.InDegrees()).ToQuat();
            towerBody.Sleeping = true;

            //update gun vertical rotation
            Quat verticalRotation = new Angles(0, verticalAngle.InDegrees(), 0).ToQuat();
            mainGunAttachedObject.RotationOffset = verticalRotation;
        }

        bool GunsTryFire(bool alternative)
        {
            bool fire = false;

            foreach (MapObjectAttachedObject attachedObject in AttachedObjects)
            {
                MapObjectAttachedMapObject attachedMapObject = attachedObject as MapObjectAttachedMapObject;
                if (attachedMapObject == null)
                    continue;

                Gun gun = attachedMapObject.MapObject as Gun;

                if (gun != null)
                {
                    if (gun.TryFire(alternative))
                        fire = true;
                }
            }

            return fire;
        }

        public void SetMomentaryTurnToPosition(Vec3 pos)
        {
            if (towerBody == null)
                return;

            Vec3 direction = pos - towerBody.Position;
            towerLocalDirection = SphereDir.FromVector(Rotation.GetInverse() * direction);
            needTowerLocalDirection = towerLocalDirection;
        }

        public void SetNeedTurnToPosition(Vec3 pos)
        {
            if (towerBody == null)
                return;

            if (Type.TowerTurnSpeed != 0)
            {
                Vec3 direction = pos - towerBody.Position;
                needTowerLocalDirection = SphereDir.FromVector(Rotation.GetInverse() * direction);
            }
            else
                SetMomentaryTurnToPosition(pos);
        }

        protected override void Server_OnClientConnectedAfterPostCreate(
            RemoteEntityWorld remoteEntityWorld)
        {
            base.Server_OnClientConnectedAfterPostCreate(remoteEntityWorld);

            RemoteEntityWorld[] worlds = new RemoteEntityWorld[] { remoteEntityWorld };
            Server_SendTowerLocalDirectionToClients(worlds);
        }

        void Server_TickSendTowerLocalDirection()
        {
            float epsilon = new Degree(.5f).InRadians();
            if (!towerLocalDirection.Equals(server_sentTowerLocalDirection, epsilon))
            {
                Server_SendTowerLocalDirectionToClients(EntitySystemWorld.Instance.RemoteEntityWorlds);
                server_sentTowerLocalDirection = towerLocalDirection;
            }
        }

        void Server_SendTowerLocalDirectionToClients(IList<RemoteEntityWorld> remoteEntityWorlds)
        {
            SendDataWriter writer = BeginNetworkMessage(remoteEntityWorlds, typeof(Helicopter),
                (ushort)NetworkMessages.TowerLocalDirectionToClient);
            writer.Write(towerLocalDirection);
            EndNetworkMessage();
        }

        [NetworkReceive(NetworkDirections.ToClient, (ushort)NetworkMessages.TowerLocalDirectionToClient)]
        void Client_ReceiveTowerLocalDirection(RemoteEntityWorld sender, ReceiveDataReader reader)
        {
            SphereDir value = reader.ReadSphereDir();
            if (!reader.Complete())
                return;
            towerLocalDirection = value;
        }

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

        enum NetworkMessages
        {
            TowerLocalDirectionToClient,
            TracksSpeedToClient,
        }

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

    }
}

��
�� GameControlKeys. �� . �� . �� Use ��

��:

[DefaultKeyboardMouseValue( EKeys.F )]
 Use,

        [DefaultKeyboardMouseValue(EKeys.E)]
        Rightward,

        [DefaultKeyboardMouseValue(EKeys.Q)]
        Leftward,

�� PlayerIntellect. �� void ServerOrSingle_RestoreMainControlledUnit() � � �� Tank specific

��:

if( ControlledObject != null )
{
       //Tank specific
       if( ControlledObject is Tank || ControlledObject is Car )

�� ControlledObject is Helicopter

��:

if( ControlledObject != null )
{
 //Tank specific
 if( ControlledObject is Tank || ControlledObject is Car || ControlledObject is Helicopter )

� �� ActionGameWindow, �� void UpdateHUD(). � �� Tank specific �� Helicopter

��:

//Tank specific
Tank tank = playerUnit as Tank;
if( tank != null )
    weapon = tank.MainGun;

//Helicopter specific
Helicopter heli = playerUnit as Helicopter;
if (heli != null)
    weapon = heli.MainGun;

�� , � �� void DrawTarget( GuiRenderer renderer )

� �� , �� Tank specific DrawTankGunTarget(renderer) �� Helicopter

��:

//Tank specific
DrawTankGunTarget( renderer );

//Helicopter specific
DrawHeliGunTarget(renderer);

�� . ��, �� -��

�� 3d �� (3ds max)

mybb@mybb.ru (Wowka70) — Fri, 10 Apr 2020 16:40:53 +0300

��. � �� .

3 ��

mybb@mybb.ru (Wowka70) — Sat, 14 Mar 2020 15:21:18 +0300

1. � ��
2. � �� .
3. �� 3.2 �� .

�� ?

mybb@mybb.ru (Mobilemedved) — Wed, 26 Feb 2020 12:36:29 +0300

� �� .. �� NeoAxis Engine 2019.4.. �� 3.5 ��. ��, ��

�� NPC

mybb@mybb.ru (Wowka70) — Tue, 18 Feb 2020 09:05:06 +0300

�� NPC
�� .
�� Character �� .

MapObjectResNPC.cs

��:

using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel;
using Engine;
using Engine.EntitySystem;
using Engine.MapSystem;
using Engine.MathEx;
using Engine.Renderer;
using Engine.PhysicsSystem;
using Engine.Utils;
using ProjectCommon;
using Engine.SoundSystem;

namespace ProjectEntities
{
	/// <summary>
	/// Defines the <see cref="InfluenceRegion"/> entity type.
	/// </summary>
	public class MapObjectResNPCType : DynamicType
	{
	[FieldSerialize]
    CharacterType characterType;
    
    [FieldSerialize]
    float respTimeType;
    
    [Description( "Character ������� ����� ������������" )]
    public CharacterType CharacterType
    {
    	get { return characterType; }
    	set { characterType = value; }
    }
    
	[Description( "����� ����� ������������" )]
    public float RespTimeType
    {
    	get { return respTimeType; }
    	set { respTimeType = value; }
    }
    
	}

	public class MapObjectResNPC : Dynamic
	{
    
    
    float spawntime;

    MapObjectResNPCType _type = null; public new MapObjectResNPCType Type { get { return _type; } }
    
    
        
        
        protected override void OnPostCreate(bool loaded)
        {
            base.OnPostCreate(loaded);//��� ������ ������
            spawntime = 0.0f;//���������� ���� ��������������� ����
            SubscribeToTickEvent();//������� �� ������� �������.
        }
        
        
        protected override void OnTick()
        {
            base.OnTick();
            
        
            if (Type.Name != "Box") {
 
                spawntime += TickDelta;//�� ���������� �������������� ����
 
                if(spawntime >= Type.RespTimeType) {
                    CreateNPC();//��������� ������
                        spawntime = 0.0f;//���������� ���������� ��� ����� 
                }   
            }
            return;
        }
            

    
    void CreateNPC()
    {
    	//������� ����� ������� ������
        MapObject RES = (MapObject)Entities.Instance.Create(Type.CharacterType, Map.Instance);
 
        //������ �������
        RES.Position = GetInterpolatedPosition() + new Vec3( 0, 0, .1f );
 
        //��������� �������������
        RES.PostCreate();
    }
    
	}
}

�� GUI

mybb@mybb.ru (Wowka70) — Wed, 12 Feb 2020 16:20:55 +0300

�� GUI
�� : 3.0 � ��

��:

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using Engine;
using Engine.FileSystem;
using Engine.UISystem;
using Engine.EntitySystem;
using Engine.MapSystem;
using Engine.MathEx;
using Engine.Renderer;
using Engine.SoundSystem;
using ProjectCommon;
using ProjectEntities;

namespace Game
{
    public class StartWindows : Control
    {
    	
    Control window;
   
    	enum DrawAreaModes
        {
            Triangles,
            Quads,
            Lines,
            Text,
        }

	    protected override void OnAttach()
	    {
	        //����� ������������� ������
	        base.OnAttach();
	        window = ControlDeclarationManager.Instance.CreateControl("GUI\\StartWindows.gui");
	        //������� ������
	        GameMusic.MusicPlay( "GUI\\StartWindows.ogg", true );
	        //���������� GUI � ����
	        Controls.Add(window);
	    }

    }               
}

�� RecastNavigationSystem.cs

mybb@mybb.ru (Wowka70) — Fri, 31 Jan 2020 06:14:56 +0300

�� .

RecastNavigationSystem.cs

��:

// Copyright (C) NeoAxis Group Ltd. This is part of NeoAxis 3D Engine SDK.
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Runtime.InteropServices;
using System.IO;
using System.Drawing.Design;
using Engine.FileSystem;
using Engine.Utils;
using Engine.EntitySystem;
using Engine.MapSystem;
using Engine.MathEx;
using Engine.Renderer;

namespace Engine
{
	public class RecastNavigationSystemType : MapGeneralObjectType
	{
    public RecastNavigationSystemType()
    {
    	AllowEmptyName = true;
    }
	}

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

	struct Wrapper
	{
    public const string library = "Recast";
    public const CallingConvention convention = CallingConvention.Cdecl;

    [DllImport( Wrapper.library, EntryPoint = "Recast_Initialize", CallingConvention = Wrapper.convention )]
    public unsafe static extern IntPtr Initialize(
    	 ref Vec3 bmin, ref Vec3 bmax,
    	 float tileSize, float cellSize, float cellHeight,
    	 int minRegionSize, int mergeRegionSize, [MarshalAs( UnmanagedType.U1 )] bool monotonePartitioning,
    	 float maxEgdeLength, float maxEdgeError,
    	 int vertsPerPoly, float detailSampleDistance, float detailMaxSampleError,
    	 float agentHeight, float agentRadius, float agentMaxClimb, float agentMaxSlope );

    [DllImport( Wrapper.library, EntryPoint = "Recast_NavQueryInit", CallingConvention = Wrapper.convention )]
    [return: MarshalAs( UnmanagedType.U1 )]
    public unsafe static extern bool NavQueryInit( IntPtr world, int maxNodes );

    [DllImport( Wrapper.library, EntryPoint = "Recast_GetSizes", CallingConvention = Wrapper.convention )]
    public unsafe static extern void GetSizes( IntPtr world, out int maxTiles, out int maxPolysPerTile );

    [DllImport( Wrapper.library, EntryPoint = "Recast_BuildAllTiles", CallingConvention = Wrapper.convention )]
    public unsafe static extern void BuildAllTiles( IntPtr world );

    [DllImport( Wrapper.library, EntryPoint = "Recast_DestroyAllTiles", CallingConvention = Wrapper.convention )]
    public unsafe static extern void DestroyAllTiles( IntPtr world );

    [DllImport( Wrapper.library, EntryPoint = "Recast_SetGeometry", CallingConvention = Wrapper.convention )]
    public unsafe static extern void SetGeometry( IntPtr world, IntPtr vertices, int vertexCount,
    	IntPtr indices, int indexCount, int trianglesPerChunk );

    [DllImport( Wrapper.library, EntryPoint = "Recast_Destroy", CallingConvention = Wrapper.convention )]
    public unsafe static extern void Destroy( IntPtr world );

    [DllImport( Wrapper.library, EntryPoint = "Recast_GetNavigationMesh", CallingConvention = Wrapper.convention )]
    [return: MarshalAs( UnmanagedType.U1 )]
    public unsafe static extern bool GetNavigationMesh( IntPtr world, out Vec3* vertices,
    	out int vertexCount );

    [DllImport( Wrapper.library, EntryPoint = "Recast_FindPath", CallingConvention = Wrapper.convention )]
    [return: MarshalAs( UnmanagedType.U1 )]
    public unsafe static extern bool FindPath( IntPtr world, ref Vec3 start, ref Vec3 end, float stepSize,
    	ref Vec3 polygonPickExtents, int maxPolygonPath, int maxSmoothPath, int maxSteerPoints,
    	out Vec3* outPath, out int outPathCount );

    [DllImport( Wrapper.library, EntryPoint = "Recast_FreeMemory", CallingConvention = Wrapper.convention )]
    public unsafe static extern void FreeMemory( IntPtr pointer );

    [DllImport( Wrapper.library, EntryPoint = "Recast_LoadNavMesh", CallingConvention = Wrapper.convention )]
    [return: MarshalAs( UnmanagedType.U1 )]
    public unsafe static extern bool LoadNavMesh( IntPtr world, IntPtr data, int dataSize );

    [DllImport( Wrapper.library, EntryPoint = "Recast_SaveNavMesh", CallingConvention = Wrapper.convention )]
    public unsafe static extern void SaveNavMesh( IntPtr world, out IntPtr data, out int dataSize );

    [DllImport( Wrapper.library, EntryPoint = "Recast_BuildTile", CallingConvention = Wrapper.convention )]
    public unsafe static extern void BuildTile( IntPtr world, ref Vec3 position );

    [DllImport( Wrapper.library, EntryPoint = "Recast_RemoveTile", CallingConvention = Wrapper.convention )]
    public unsafe static extern void RemoveTile( IntPtr world, ref Vec3 position );
	}

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

	[ExtendedFunctionalityDescriptor( "Engine.Editor.RecastNavigationSystemExtendedFunctionalityDescriptor, RecastNavigationSystem.Editor" )]
	public class RecastNavigationSystem : MapGeneralObject
	{
    static List<RecastNavigationSystem> instances = new List<RecastNavigationSystem>();
    static ReadOnlyCollection<RecastNavigationSystem> instancesReadOnly;

    [FieldSerialize( "boundsMin" )]
    Vec3 boundsMin = new Vec3( -100, -100, -100 );

    [FieldSerialize( "boundsMax" )]
    Vec3 boundsMax = new Vec3( 100, 100, 100 );

    [FieldSerialize( "tileSize" )]
    int tileSize = 32;

    [FieldSerialize( "cellSize" )]
    float cellSize = .3f;

    [FieldSerialize( "cellHeight" )]
    float cellHeight = .3f;

    [FieldSerialize( "trianglesPerChunk" )]
    int trianglesPerChunk = 512;

    [FieldSerialize( "minRegionSize" )]
    int minRegionSize = 8;

    [FieldSerialize( "mergeRegionSize" )]
    int mergeRegionSize = 20;

    [FieldSerialize( "monotonePartitioning" )]
    bool monotonePartitioning = false;

    [FieldSerialize( "maxEdgeLength" )]
    float maxEdgeLength = 12;

    [FieldSerialize( "maxEdgeError" )]
    float maxEdgeError = 1.3f;

    [FieldSerialize( "maxVerticesPerPolygon" )]
    int maxVerticesPerPolygon = 6;

    [FieldSerialize( "detailSampleDistance" )]
    float detailSampleDistance = 6;

    [FieldSerialize( "detailMaxSampleError" )]
    float detailMaxSampleError = 1;

    [FieldSerialize( "agentHeight" )]
    float agentHeight = 2.0f;

    [FieldSerialize( "agentRadius" )]
    float agentRadius = .6f;

    [FieldSerialize( "agentMaxClimb" )]
    float agentMaxClimb = .9f;

    [FieldSerialize( "agentMaxSlope" )]
    Degree agentMaxSlope = 45;

    [FieldSerialize( "geometries" )]
    List<Entity> geometries = new List<Entity>();
    ReadOnlyCollection<Entity> geometriesReadOnly;

    [FieldSerialize( "alwaysDrawNavMesh" )]
    bool alwaysDrawNavMesh;

    [FieldSerialize( "pathfindingMaxNodes" )]
    int pathfindingMaxNodes = 8192;

    [FieldSerialize( "dataDirectory" )]
    string dataDirectory = "RecastNavigationSystem";

    //[FieldSerialize( "gridHeight" )]
    //float gridHeight = .5f;

    IntPtr recastWorld;

    Vec3[] debugNavigationMeshVertices;
    int[] debugNavigationMeshIndices;

    //Vec3[] tileGridMeshVertices;
    //int[] tileGridMeshIndices;
    //Vec3[] cellGridMeshVertices;
    //int[] cellGridMeshIndices;

    //bool drawTileGrid;

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

    [TypeField]
    RecastNavigationSystemType __type = null;
    /// <summary>
    /// Gets the entity type.
    /// </summary>
    public new RecastNavigationSystemType Type { get { return __type; } }

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

    class IndexVertexBufferCollector
    {
    	//!!!!!!need instancing
    	public Vec3[] resultVertices = new Vec3[ 4096 ];
    	public int[] resultIndices = new int[ 4096 ];
    	public int resultVertexCount;
    	public int resultIndexCount;

    	public void Add( Vec3[] vertices, int vertexCount, int[] indices, int indexCount )
    	{
        int newVertexCount = resultVertexCount + vertexCount;
        int newIndexCount = resultIndexCount + indexCount;

        if( newVertexCount > resultVertices.Length )
        {
        	int s = resultVertices.Length;
        	while( newVertexCount > s )
            s *= 2;
        	Vec3[] old = resultVertices;
        	resultVertices = new Vec3[ s ];
        	Array.Copy( old, resultVertices, old.Length );
        }

        if( newIndexCount > resultIndices.Length )
        {
        	int s = resultIndices.Length;
        	while( newIndexCount > s )
            s *= 2;
        	int[] old = resultIndices;
        	resultIndices = new int[ s ];
        	Array.Copy( old, resultIndices, old.Length );
        }

        Array.Copy( vertices, 0, resultVertices, resultVertexCount, vertexCount );
        for( int n = 0; n < indexCount; n++ )
        	resultIndices[ resultIndexCount + n ] = resultVertexCount + indices[ n ];
        resultVertexCount = newVertexCount;
        resultIndexCount = newIndexCount;
    	}

    }

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

    public RecastNavigationSystem()
    {
    	instances.Add( this );

    	geometriesReadOnly = new ReadOnlyCollection<Entity>( geometries );

    	NativeLibraryManager.PreLoadLibrary( "Recast" );
    }

    public static IList<RecastNavigationSystem> Instances
    {
    	get
    	{
        if( instancesReadOnly == null )
        	instancesReadOnly = new ReadOnlyCollection<RecastNavigationSystem>( instances );
        return instancesReadOnly;
    	}
    }

    [Category( "Debug" )]
    [DefaultValue( false )]
    public bool AlwaysDrawNavMesh
    {
    	get { return alwaysDrawNavMesh; }
    	set { alwaysDrawNavMesh = value; }
    }

    //[Browsable( false )] //SodanKerjuu: controlled by the initialize toolbox form
    //public bool DrawTileGrid
    //{
    //   get { return drawTileGrid; }
    //   set { drawTileGrid = value; }
    //}

    //[DefaultValue( .5f )]
    //public float GridHeight
    //{
    //   get { return gridHeight; }
    //   set
    //   {
    //      gridHeight = value;
    //      MathFunctions.Saturate( ref gridHeight );
    //      ClearDebugGrids();
    //   }
    //}

    [Category( "Grid" )]
    public Vec3 BoundsMin
    {
    	get { return boundsMin; }
    	set
    	{
        if( boundsMin == value )
        	return;
        boundsMin = value;

        //ClearDebugGrids();
    	}
    }

    [Category( "Grid" )]
    public Vec3 BoundsMax
    {
    	get { return boundsMax; }
    	set
    	{
        if( boundsMax == value )
        	return;
        boundsMax = value;

        //ClearDebugGrids();
    	}
    }

    [Category( "Grid" )]
    [DefaultValue( 32 )]
    [LocalizedDescription( "������ ������.", "RecastNavigationSystem" )]
    public int TileSize
    {
    	get { return tileSize; }
    	set
    	{
        if( value < 16 )
        	value = 16;
        tileSize = value;
    	}
    }

    [Category( "Grid" )]
    [DefaultValue( .3f )]
    [LocalizedDescription( "���������� �� ������ � �������, ������������ ��� ������� �������� ���������. ������ � ������� �������� � ����� ��������. ������ � ������� �������� �����, ������������ ���������� ����. ����� ������ �������� ��������� ��������������� ������ ����� ����� ��������������� �������� ���������, �� ��� ����� ������� ��������� ��������� � ������.", "RecastNavigationSystem" )]
    public float CellSize
    {
    	get { return cellSize; }
    	set
    	{
        if( value < .01f )
        	value = .01f;
        cellSize = value;
    	}
    }

    [Category( "Grid" )]
    [DefaultValue( .3f )]
    [LocalizedDescription( "���������� �� ������, ������������ ��� ������� �������� ���������. ������ �������� � ����� ��������.", "RecastNavigationSystem" )]
    public float CellHeight
    {
    	get { return cellHeight; }
    	set
    	{
        if( value < .01f )
        	value = .01f;
        cellHeight = value;
    	}
    }

    [Category( "Grid" )]
    [DefaultValue( 512 )]
    [LocalizedDescription( "������������ ���������� ������������� ��� ������� ����� �� ���������� ������ AABB.", "RecastNavigationSystem" )]
    public int TrianglesPerChunk
    {
    	get { return trianglesPerChunk; }
    	set
    	{
        if( value < 128 )
        	value = 128;
        trianglesPerChunk = value;
    	}
    }

    [Category( "Regions" )]
    [DefaultValue( 8 )]
    [LocalizedDescription( "����������� ������ ������� ��� �� ��������� (���������) ��������. �������� � ��������. �������, ������� �� ������� �� � ����� ������ �������� � ����� ������ ������ ����� �������, ����� ����������� �� �������� �����. �� ���� ��� ������ �� ����� ��������� �����������.", "RecastNavigationSystem" )]
    public int MinRegionSize
    {
    	get { return minRegionSize; }
    	set
    	{
        if( value < 1 )
        	value = 1;
        minRegionSize = value;
    	}
    }

    [Category( "Regions" )]
    [DefaultValue( 20 )]
    [LocalizedDescription( "����� ������� ������ ����� ������� �����, ���� ��������, ���������� � ����� �������� ���������. �������� � ��������. �������� ��������� ���������� ��������� ��������. ��� �������� �������� � �������� ������������� ����, ��� �������� ������ � ��������� ��������� ������� ����� �������� � ������� ��������� ��������.", "RecastNavigationSystem" )]
    public int MergeRegionSize
    {
    	get { return mergeRegionSize; }
    	set
    	{
        if( value < 0 )
        	value = 0;
        mergeRegionSize = value;
    	}
    }

    [Category( "Regions" )]
    [DefaultValue( false )]
    [LocalizedDescription( "��������� ���������� ����������� �� ������� ������� ��� ���������.", "RecastNavigationSystem" )]
    public bool MonotonePartitioning
    {
    	get { return monotonePartitioning; }
    	set { monotonePartitioning = value; }
    }

    [Category( "Polygonization" )]
    [DefaultValue( 12.0f )]
    [LocalizedDescription( "������������ ����� ����� ��������������, �������������� ������� �����. ������ ������ ����� ��������� � ��������� ������, ���� ��� �������� ����� ��������� ��� ������������� �����. ������� �������� �������� ��� �������.", "RecastNavigationSystem" )]
    public float MaxEdgeLength
    {
    	get { return maxEdgeLength; }
    	set
    	{
        if( value < 0 )
        	value = 0;
        maxEdgeLength = value;
    	}
    }

    [Category( "Polygonization" )]
    [DefaultValue( 1.3f )]
    [LocalizedDescription( "������������ ����������, �� ������� ���� ����� ����� ����������� �� �������� ���������. ����� ������ �������� �������� � ����, ��� ����� ����� ����� ����� ����� ��������� ������� ��������� ��������� xz �� ���� ���������� ����� �������������.", "RecastNavigationSystem" )]
    public float MaxEdgeError
    {
    	get { return maxEdgeError; }
    	set
    	{
        if( value < .1f )
        	value = .1f;
        maxEdgeError = value;
    	}
    }

    [Category( "Polygonization" )]
    [DefaultValue( 6 )]
    public int MaxVerticesPerPolygon
    {
    	get { return maxVerticesPerPolygon; }
    	set
    	{
        if( value < 3 )
        	value = 3;
        maxVerticesPerPolygon = value;

        //!!!!!!
        //need change debug drawing NavMesh. at this time navmesh draws as triangle list.
    	}
    }

    [Category( "Detail Mesh" )]
    [DefaultValue( 6.0f )]
    [LocalizedDescription( "������������� ���������� �������, ������������ ��� ������������� ����� ������ � ������������ �������� ���������. ������ �� ��, ��������� ������ �������� ����� ������ ������������� ������� ����������� �������� ���������. ����� ������� �������� �������� � �������� ����� �������, ������� ����� ����� ������������� ����������� �������� ��������� �� ���� ����� �������� ��������� ����� ������������� � ����� ������� ������ �� ���������.", "RecastNavigationSystem" )]
    public float DetailSampleDistance
    {
    	get { return detailSampleDistance; }
    	set
    	{
        if( value < 0 )
        	value = 0;
        detailSampleDistance = value;
    	}
    }

    [Category( "Detail Mesh" )]
    [DefaultValue( 1.0f )]
    [LocalizedDescription( "������������ ����������, �� ������� ����������� ����� ������� ����� ����������� �� ����������� �������� ���������.", "RecastNavigationSystem" )]
    public float DetailMaxSampleError
    {
    	get { return detailMaxSampleError; }
    	set
    	{
        if( value < 0 )
        	value = 0;
        detailMaxSampleError = value;
    	}
    }

    [Category( "Agent" )]
    [DefaultValue( 2.0f )]
    [LocalizedDescription( "����������� ������, �� ������� ����� ��� ����� ������.", "RecastNavigationSystem" )]
    public float AgentHeight
    {
    	get { return agentHeight; }
    	set
    	{
        if( value < .1f )
        	value = .1f;
        agentHeight = value;
    	}
    }

    [Category( "Agent" )]
    [DefaultValue( .6f )]
    [LocalizedDescription( "������ ������.", "RecastNavigationSystem" )]
    public float AgentRadius
    {
    	get { return agentRadius; }
    	set
    	{
        if( value < 0 )
        	value = 0;
        agentRadius = value;
    	}
    }

    [Category( "Agent" )]
    [DefaultValue( .9f )]
    [LocalizedDescription( "������������ ������ ����� �������� �����, �� ������� ����� ��������� �����.", "RecastNavigationSystem" )]
    public float AgentMaxClimb
    {
    	get { return agentMaxClimb; }
    	set
    	{
        if( value < .001f )
        	value = .001f;
        agentMaxClimb = value;
    	}
    }

    [Category( "Agent" )]
    [DefaultValue( typeof( Degree ), "45" )]
    [Editor( typeof( SingleValueEditor ), typeof( UITypeEditor ) )]
    [EditorLimitsRange( 1, 89 )]
    [LocalizedDescription( "������������ ������� ���� ������� � ��������.", "RecastNavigationSystem" )]
    public Degree AgentMaxSlope
    {
    	get { return agentMaxSlope; }
    	set
    	{
        if( value < 1 )
        	value = 1;
        if( value > 89 )
        	value = 89;
        agentMaxSlope = value;
    	}
    }

    [Browsable( false )]
    public IList<Entity> Geometries
    {
    	get { return geometriesReadOnly; }
    }

    [Category( "Pathfinding" )]
    [DefaultValue( 8192 )]
    [LocalizedDescription( "������������ ���������� ������������ ��������� ����� (�� ����� 65536).", "RecastNavigationSystem" )]
    public int PathfindingMaxNodes
    {
    	get { return pathfindingMaxNodes; }
    	set
    	{
        if( value < 4 )
        	value = 4;
        if( value > 65536 )
        	value = 65536;
        pathfindingMaxNodes = value;

        if( recastWorld != IntPtr.Zero )
        	Wrapper.NavQueryInit( recastWorld, pathfindingMaxNodes );
    	}
    }

    //void ClearDebugGrids()
    //{
    //   tileGridMeshVertices = null;
    //   tileGridMeshIndices = null;
    //   cellGridMeshVertices = null;
    //   cellGridMeshIndices = null;
    //}

    static Vec3 ToRecastVec3( Vec3 v )
    {
    	return new Vec3( v.X, v.Z, -v.Y );
    }

    static Vec3 ToEngineVec3( Vec3 v )
    {
    	return new Vec3( v.X, -v.Z, v.Y );
    }

    protected override bool OnLoad( TextBlock block )
    {
    	if( !base.OnLoad( block ) )
        return false;

    	InitRecastWorld();

    	string virtualDataDirectory = Path.Combine( Map.Instance.GetVirtualFileDirectory(), dataDirectory );
    	string virtualFilePath = Path.Combine( virtualDataDirectory, "NavMesh.dat" );

    	if( VirtualFile.Exists( virtualFilePath ) )
    	{
        byte[] data = VirtualFile.ReadAllBytes( virtualFilePath );
        unsafe
        {
        	fixed( byte* pData = data )
        	{
            if( Wrapper.LoadNavMesh( recastWorld, (IntPtr)pData, data.Length ) )
            {
            	Wrapper.NavQueryInit( recastWorld, pathfindingMaxNodes );
            }
        	}
        }
    	}

    	return true;
    }

    protected override void OnSave( TextBlock block )
    {
    	base.OnSave( block );

    	if( EntitySystemWorld.Instance.SerializationMode == SerializationModes.MapSceneFile )
    	{
        Log.Warning( "Scene export: RecastNavigationSystem is not supported." );
        return;
    	}

    	string mapRealFileDirectory = VirtualFileSystem.GetRealPathByVirtual(
        Map.Instance.GetVirtualFileDirectory() );
    	string realFullDataDirectory = Path.Combine( mapRealFileDirectory, dataDirectory );

    	string realFilePath = Path.Combine( realFullDataDirectory, "NavMesh.dat" );

    	if( recastWorld != IntPtr.Zero )
    	{
        if( !Directory.Exists( realFullDataDirectory ) )
        	Directory.CreateDirectory( realFullDataDirectory );

        IntPtr data;
        int size;
        Wrapper.SaveNavMesh( recastWorld, out data, out size );

        if( data != IntPtr.Zero )
        {
        	byte[] buffer = new byte[ size ];
        	Marshal.Copy( data, buffer, 0, size );

        	Wrapper.FreeMemory( data );

        	File.WriteAllBytes( realFilePath, buffer );
        }
    	}
    	else
    	{
        if( File.Exists( realFilePath ) )
        	File.Delete( realFilePath );
    	}
    }

    protected override void OnCreate()
    {
    	base.OnCreate();

    	string mapRealFileDirectory = VirtualFileSystem.GetRealPathByVirtual(
        Map.Instance.GetVirtualFileDirectory() );

    	//dataDirectory
    	for( int counter = 1; ; counter++ )
    	{
        dataDirectory = "RecastNavigationSystem";
        if( counter != 1 )
        	dataDirectory += counter.ToString();

        bool busy = false;
        foreach( RecastNavigationSystem system in Instances )
        {
        	if( system != this && dataDirectory == system.dataDirectory )
            busy = true;
        }
        if( !busy )
        {
        	string realPath = Path.Combine( mapRealFileDirectory, dataDirectory );
        	if( !Directory.Exists( realPath ) )
            break;
        }
    	}
    }

    /// <summary>Overridden from <see cref="Engine.EntitySystem.Entity"/>.</summary>
    protected override void OnPostCreate( bool loaded )
    {
    	if( !instances.Contains( this ) )
        instances.Add( this );

    	base.OnPostCreate( loaded );

    	//remove null geometry entries
    	if( loaded )
    	{
        again:
        for( int n = 0; n < geometries.Count; n++ )
        {
        	if( geometries[ n ] == null )
        	{
            geometries.RemoveAt( n );
            goto again;
        	}
        }
    	}
    }

    /// <summary>Overridden from <see cref="Engine.EntitySystem.Entity"/>.</summary>
    protected override void OnDestroy()
    {
    	DestroyRecastWorld();

    	base.OnDestroy();

    	instances.Remove( this );
    }

    public void InitRecastWorld()
    {
    	unsafe
    	{
        DestroyRecastWorld();

        Vec3 min = boundsMin;
        Vec3 max = boundsMax;
        for( int n = 0; n < 3; n++ )
        	if( max[ n ] - min[ n ] < 1 )
            max[ n ] = min[ n ] + 1;

        Vec3 recastBoundsMin = ToRecastVec3( min );
        Vec3 recastBoundsMax = ToRecastVec3( max );

        recastWorld = Wrapper.Initialize(
        	ref recastBoundsMin, ref recastBoundsMax,
        	tileSize, cellSize, cellHeight,
        	minRegionSize, mergeRegionSize, monotonePartitioning,
        	maxEdgeLength, maxEdgeError,
        	maxVerticesPerPolygon, detailSampleDistance, detailMaxSampleError,
        	agentHeight, agentRadius, agentMaxClimb, (float)agentMaxSlope );

        if( recastWorld != IntPtr.Zero )
        {
        	Wrapper.NavQueryInit( recastWorld, pathfindingMaxNodes );
        }

        //if( recastWorld != IntPtr.Zero )
        //{
        //Log.Info( "RecastWorld Initialized." );

        //int mT = 0, mPPT = 0;
        //Wrapper.GetSizes( recastWorld, out mT, out mPPT );
        //Log.Info( "MaxTiles: " + mT.ToString() + "  MaxPolygonsPerTile: " + mPPT.ToString() );
        //}
    	}
    }

    [Browsable( false )]
    public bool IsInitialized
    {
    	get { return recastWorld != IntPtr.Zero; }
    }

    public void DestroyRecastWorld()
    {
    	debugNavigationMeshVertices = null;
    	debugNavigationMeshIndices = null;

    	if( recastWorld != IntPtr.Zero )
    	{
        Wrapper.Destroy( recastWorld );
        recastWorld = IntPtr.Zero;
    	}
    }

    public void DestroyAllTiles()
    {
    	if( recastWorld == IntPtr.Zero )
        return;

    	Wrapper.DestroyAllTiles( recastWorld );

    	//refresh debug mesh
    	debugNavigationMeshVertices = null;
    	debugNavigationMeshIndices = null;
    }

    public bool BuildAllTiles( out string error )
    {
    	error = null;

    	if( recastWorld == IntPtr.Zero )
    	{
        error = "Need to initialize the Recast World.";
        return false;
    	}

    	if( geometries.Count == 0 )
    	{
        error = "No collision objects are selected.";
        return false;
    	}

    	IndexVertexBufferCollector collector = GetAllGeometriesForNavigationMesh();
    	{
        Vec3[] vertices = collector.resultVertices;
        int[] indices = collector.resultIndices;
        int vertexCount = collector.resultVertexCount;
        int indexCount = collector.resultIndexCount;

        if( vertexCount == 0 )
        {
        	error = "No vertices were gathered from collision objects.";
        	return false;
        }

        //convert to Recast space
        for( int n = 0; n < vertexCount; n++ )
        	vertices[ n ] = ToRecastVec3( vertices[ n ] );

        unsafe
        {
        	fixed( Vec3* pVertices = vertices )
        	{
            fixed( int* pIndices = indices )
            {
            	Wrapper.SetGeometry( recastWorld, (IntPtr)pVertices, vertexCount, (IntPtr)pIndices,
                indexCount, trianglesPerChunk );

            	Wrapper.BuildAllTiles( recastWorld );
            }
        	}
        }
    	}

    	//refresh debug mesh
    	debugNavigationMeshVertices = null;
    	debugNavigationMeshIndices = null;

    	return true;
    }

    static bool IsAllowSaveRecursive( Entity entity )
    {
    	while( entity != null )
    	{
        if( !entity.AllowSave )
        	return false;
        entity = entity.Parent;
    	}
    	return true;
    }

    public bool IsSupportedGeometry( Entity entity )
    {
    	if( !IsAllowSaveRecursive( entity ) )
        return false;

    	HeightmapTerrain terrain = entity as HeightmapTerrain;
    	if( terrain != null )
        return true;

    	StaticMesh staticMesh = entity as StaticMesh;
    	if( staticMesh != null )
    	{
        if( staticMesh.Collision )
        	return true;
        return false;
    	}

    	MapObject mapObject = entity as MapObject;
    	if( mapObject != null )
    	{
        foreach( MapObjectAttachedObject attachedObject in mapObject.AttachedObjects )
        {
        	MapObjectAttachedMesh attachedMesh = attachedObject as MapObjectAttachedMesh;
        	if( attachedMesh != null && attachedMesh.Collision )
            return true;
        }
    	}

    	return false;
    }

    //IndexVertexBufferCollector GetGeometriesForNavigationMesh( Bounds bounds )
    //{
    //   IndexVertexBufferCollector collector = new IndexVertexBufferCollector();

    //   �������� ������
    //   Map.Instance.GetObjects( new Box( bounds ), delegate( MapObject obj )
    //      {
    //         if( geometries.Contains( obj ) )
    //            AddEntityToCollector( collector, obj );
    //      } );

    //   //heightmapterrain �� ����������� � ������� ������, ��� �� ����� ���� ������, ������ ��� ������ �� ����� �������� ������ ����������� �����
    //   {
    //      //raycast does not hit terrain?!?
    //      /*
    //      Vec3 top = bounds.GetCenter();
    //      top.Z = boundsMax.Z;

    //      Vec3 bottom = bounds.GetCenter();
    //      bottom.Z = boundsMin.Z;

    //      RayCastResult[] results = PhysicsWorld.Instance.RayCastPiercing(new Ray(top, bottom), (int)ContactGroup.CastOnlyCollision);

    //      foreach (RayCastResult result in results)
    //      {
    //          HeightmapTerrain terrain = HeightmapTerrain.GetTerrainByBody( result.Shape.Body );
    //          if( terrain != null)
    //              if( geometries.Contains(terrain) )
    //                  AddHeightmapTerrainPartToCollector(collector, terrain, bounds); 
    //      }
    //      */

    //      //SodanKerjuu: ����� Lo-Tek, ����� ���������, ��� � ��� �� ����� ������ ���������
    //      foreach( HeightmapTerrain terrain in HeightmapTerrain.Instances )
    //         if( geometries.Contains( terrain ) )
    //            AddHeightmapTerrainPartToCollector( collector, terrain, bounds );
    //   }

    //   return collector;
    //}

    //void AddHeightmapTerrainPartToCollector( IndexVertexBufferCollector collector, HeightmapTerrain terrain, Bounds bounds )
    //{
    //   int size = terrain.GetHeightmapSizeAsInteger();

    //   Vec3[] vertices = new Vec3[ ( size + 1 ) * ( size + 1 ) ];
    //   int[] indices = new int[ size * size * 6 ];

    //   int vertexPosition = 0;
    //   int indexPosition = 0;

    //   for( int y = 0; y < size + 1; y++ )
    //   {
    //      for( int x = 0; x < size + 1; x++ )
    //      {
    //         ���� ����� ������� ����� ���, �� ����� �������?
    //         //SodanKerjuu: no need, you will have unused vertices, but they won't matter for Recast if they are not indexed
    //         //if( !terrain.GetHoleFlag( new Vec2i( x, y ) ) )
    //         //{
    //         Vec2 pos2 = terrain.GetPositionXY( new Vec2i( x, y ) );
    //         Vec3 pos = new Vec3( pos2.X, pos2.Y, terrain.GetHeight( new Vec2i( x, y ) ) );
    //         vertices[ vertexPosition ] = pos;
    //         vertexPosition++;
    //         //}
    //      }
    //   }

    //   for( int y = 0; y < size; y++ )
    //   {
    //      for( int x = 0; x < size; x++ )
    //      {
    //         if( !terrain.GetHoleFlag( new Vec2i( x, y ) ) )
    //         {
    //            indices[ indexPosition + 0 ] = ( size + 1 ) * y + x;
    //            indices[ indexPosition + 1 ] = ( size + 1 ) * y + x + 1;
    //            indices[ indexPosition + 2 ] = ( size + 1 ) * ( y + 1 ) + x + 1;
    //            indices[ indexPosition + 3 ] = ( size + 1 ) * ( y + 1 ) + x + 1;
    //            indices[ indexPosition + 4 ] = ( size + 1 ) * ( y + 1 ) + x;
    //            indices[ indexPosition + 5 ] = ( size + 1 ) * y + x;
    //            indexPosition += 6;
    //         }
    //      }
    //   }

    //   collector.Add( vertices, vertexPosition, indices, indexPosition );

    //}

    bool AddEntityToCollector( IndexVertexBufferCollector collector, Entity entity )
    {
    	//Static meshes
    	StaticMesh staticMesh = entity as StaticMesh;
    	if( staticMesh != null )
    	{
        if( staticMesh.Collision == false )
        	return false;

        Mesh mesh;
        if( !string.IsNullOrEmpty( staticMesh.CollisionSpecialMeshName ) )
        	mesh = MeshManager.Instance.Load( staticMesh.CollisionSpecialMeshName );
        else
        	mesh = MeshManager.Instance.Load( staticMesh.MeshName );

        if( mesh == null )
        	return false;

        Mat4 transform = staticMesh.GetTransform();
        foreach( SubMesh subMesh in mesh.SubMeshes )
        {
        	if( subMesh.AllowCollision )
        	{
            Vec3[] vertices;
            int[] indices;
            subMesh.GetSomeGeometry( out vertices, out indices );
            if( vertices != null )
            {
            	for( int n = 0; n < vertices.Length; n++ )
                vertices[ n ] = transform * vertices[ n ];
            	collector.Add( vertices, vertices.Length, indices, indices.Length );
            }
        	}
        }
        return true;
    	}

    	//MapObjectAttachedMesh
    	MapObject mapObject = entity as MapObject;
    	if( mapObject != null && !( entity is StaticMesh ) ) //SodanKerjuu: static meshes qualify as both
    	{
        bool added = false;

        foreach( MapObjectAttachedObject attachedObject in mapObject.AttachedObjects )
        {
        	MapObjectAttachedMesh attachedMesh = attachedObject as MapObjectAttachedMesh;
        	if( attachedMesh != null && attachedMesh.Collision )
        	{
            Mesh mesh;
            if( !string.IsNullOrEmpty( attachedMesh.CollisionSpecialMeshName ) )
            	mesh = MeshManager.Instance.Load( attachedMesh.CollisionSpecialMeshName );
            else
            	mesh = MeshManager.Instance.Load( attachedMesh.MeshName );

            if( mesh != null )
            {
            	Vec3 pos;
            	Quat rot;
            	Vec3 scl;
            	attachedMesh.GetGlobalTransform( out pos, out rot, out scl );
            	Mat4 transform = new Mat4( rot.ToMat3() * Mat3.FromScale( scl ), pos );

            	foreach( SubMesh subMesh in mesh.SubMeshes )
            	{
                if( subMesh.AllowCollision )
                {
                	Vec3[] vertices;
                	int[] indices;
                	subMesh.GetSomeGeometry( out vertices, out indices );
                	if( vertices != null )
                	{
                    for( int n = 0; n < vertices.Length; n++ )
                    	vertices[ n ] = transform * vertices[ n ];
                    collector.Add( vertices, vertices.Length, indices, indices.Length );
                    added = true;
                	}
                }
            	}
            }
        	}
        }

        return added;
    	}

    	//HeightmapTerrain
    	HeightmapTerrain terrain = entity as HeightmapTerrain;
    	if( terrain != null )
    	{
        int size = terrain.GetHeightmapSizeAsInteger();

        Vec3[] vertices = new Vec3[ ( size + 1 ) * ( size + 1 ) ];
        int[] indices = new int[ size * size * 6 ];

        int vertexPosition = 0;
        int indexPosition = 0;

        for( int y = 0; y < size + 1; y++ )
        {
        	for( int x = 0; x < size + 1; x++ )
        	{
            //SodanKerjuu: no need, you will have unused vertices, but they won't matter for Recast if they are not indexed
            //if( !terrain.GetHoleFlag( new Vec2i( x, y ) ) )
            //{
            Vec2 pos2 = terrain.GetPositionXY( new Vec2I( x, y ) );
            Vec3 pos = new Vec3( pos2.X, pos2.Y, terrain.GetHeight( new Vec2I( x, y ) ) );
            vertices[ vertexPosition ] = pos;
            vertexPosition++;
            //}
        	}
        }

        for( int y = 0; y < size; y++ )
        {
        	for( int x = 0; x < size; x++ )
        	{
            if( !terrain.GetHoleFlag( new Vec2I( x, y ) ) )
            {
            	indices[ indexPosition + 0 ] = ( size + 1 ) * y + x;
            	indices[ indexPosition + 1 ] = ( size + 1 ) * y + x + 1;
            	indices[ indexPosition + 2 ] = ( size + 1 ) * ( y + 1 ) + x + 1;
            	indices[ indexPosition + 3 ] = ( size + 1 ) * ( y + 1 ) + x + 1;
            	indices[ indexPosition + 4 ] = ( size + 1 ) * ( y + 1 ) + x;
            	indices[ indexPosition + 5 ] = ( size + 1 ) * y + x;
            	indexPosition += 6;
            }
        	}
        }

        collector.Add( vertices, vertexPosition, indices, indexPosition );
        return true;
    	}

    	return false;
    }

    IndexVertexBufferCollector GetAllGeometriesForNavigationMesh()
    {
    	IndexVertexBufferCollector collector = new IndexVertexBufferCollector();

    	foreach( Entity geometry in geometries )
    	{
        if( !geometry.Editor_IsExcludedFromWorld() )
        	AddEntityToCollector( collector, geometry );
    	}

    	return collector;
    }

    public void AddAllGeometriesOnMap()
    {
    	foreach( Entity entity in Entities.Instance.EntitiesCollection )
    	{
        if( IsSupportedGeometry( entity ) )
        {
        	if( !Geometries.Contains( entity ) )
            AddGeometry( entity );
        }
    	}
    }

    Bounds GetGeometryBounds( Entity entity )
    {
    	HeightmapTerrain terrain = entity as HeightmapTerrain;
    	if( terrain != null && terrain.Enabled )
        return terrain.CalculateBounds();

    	MapObject mapObject = entity as MapObject;
    	if( mapObject != null )
        return mapObject.MapBounds;

    	return Engine.MathEx.Bounds.Cleared;
    }

    public void RecalculateBounds()
    {
    	Bounds bounds = Bounds.Cleared;
    	foreach( Entity entity in Geometries )
    	{
        if( entity.Editor_IsExcludedFromWorld() )
        	continue;
        bounds.Add( GetGeometryBounds( entity ) );
    	}

    	if( bounds.IsCleared() )
        bounds = new Bounds( -10, -10, -10, 10, 10, 10 );

    	//needs to be whole number because decimals are rejected on the initialize toolbox
    	Vec3 padding = new Vec3( 1, 1, 1 );

    	BoundsMin = bounds.Minimum - padding;
    	BoundsMax = bounds.Maximum + padding;
    }

    public bool FindPath( Vec3 start, Vec3 end, float stepSize, Vec3 polygonPickExtents, int maxPolygonPath,
    	int maxSmoothPath, int maxSteerPoints, out Vec3[] outPath )
    {
    	unsafe
    	{
        outPath = null;

        if( recastWorld == IntPtr.Zero )
        	return false;

        //convert to Recast space
        Vec3 recastStart = ToRecastVec3( start );
        Vec3 recastEnd = ToRecastVec3( end );
        Vec3 recastPolygonPickExtents =
        	new Vec3( polygonPickExtents.X, polygonPickExtents.Z, polygonPickExtents.Y );

        Vec3* pathPointer;
        int pathCount;
        bool result = Wrapper.FindPath( recastWorld, ref recastStart, ref recastEnd, stepSize,
        	ref recastPolygonPickExtents, maxPolygonPath, maxSmoothPath, maxSteerPoints,
        	out pathPointer, out pathCount );

        if( result )
        {
        	if( pathCount > 0 )
        	{
            outPath = new Vec3[ pathCount ];
            for( int n = 0; n < pathCount; n++ )
            	outPath[ n ] = ToEngineVec3( pathPointer[ n ] );
        	}
        	else
        	{
            outPath = new Vec3[ 1 ];
            outPath[ 0 ] = start;
        	}

        	Wrapper.FreeMemory( (IntPtr)pathPointer );
        }

        return result;
    	}
    }

    //public Bounds GetCellBounds( Vec3 pos )
    //{
    //   float gridSize = tileSize * cellSize;
    //   float minX = boundsMin.X + ( (int)Math.Floor( ( pos.X - boundsMin.X ) / gridSize ) * gridSize );
    //   float minY = boundsMax.Y + ( (int)Math.Floor( ( pos.Y - boundsMax.Y ) / gridSize ) * gridSize );
    //   xx;
    //   //SodanKerjuu: mirrored Y because of Recast coordinate system

    //   return new Bounds( minX, minY, boundsMin.Z, minX + gridSize, minY + gridSize, boundsMax.Z );
    //}

    ////use this to manually set the geometry, used with BuildTileCached to speed things up
    //public void AssignGeometry( Bounds bounds )
    //{
    //   if( recastWorld == IntPtr.Zero )
    //      return;

    //   IndexVertexBufferCollector collector = GetGeometriesForNavigationMesh( bounds );

    //   if( collector.resultVertexCount > 0 )
    //   {
    //      Vec3[] vertices = collector.resultVertices;
    //      int[] indices = collector.resultIndices;
    //      int vertexCount = collector.resultVertexCount;
    //      int indexCount = collector.resultIndexCount;

    //      //convert to Recast space
    //      for( int n = 0; n < vertexCount; n++ )
    //         vertices[ n ] = ToRecastVec3( vertices[ n ] );

    //      unsafe
    //      {
    //         fixed( Vec3* pVertices = vertices )
    //         fixed( int* pIndices = indices )
    //            Wrapper.SetGeometry( recastWorld, (IntPtr)pVertices, vertexCount, (IntPtr)pIndices, indexCount );
    //      }
    //   }
    //}

    ////this will use the previously assigned geometry instead of getting new one
    //public void BuildTileCached( Vec3 position )
    //{
    //   if( recastWorld == IntPtr.Zero )
    //      return;

    //   Vec3 targetPosition = ToRecastVec3( position );
    //   Wrapper.BuildTile( recastWorld, ref targetPosition );

    //   //redraw debug mesh
    //   debugNavigationMeshVertices = null;
    //   debugNavigationMeshIndices = null;
    //}

    //public void BuildTile( Vec3 position )
    //{
    //   if( recastWorld == IntPtr.Zero )
    //      return;

    //   Bounds selectionBounds = GetCellBounds( position );

    //   IndexVertexBufferCollector collector = GetGeometriesForNavigationMesh( selectionBounds );
    //   if( collector.resultVertexCount > 0 )
    //   {
    //      Vec3[] vertices = collector.resultVertices;
    //      int[] indices = collector.resultIndices;
    //      int vertexCount = collector.resultVertexCount;
    //      int indexCount = collector.resultIndexCount;

    //      //convert to Recast space
    //      for( int n = 0; n < vertexCount; n++ )
    //         vertices[ n ] = ToRecastVec3( vertices[ n ] );

    //      unsafe
    //      {
    //         Log.Info( "SetGeometry: Vertices: {0}, Indices {1}", vertexCount, indexCount );

    //         fixed( Vec3* pVertices = vertices )
    //         fixed( int* pIndices = indices )
    //         {
    //            Wrapper.SetGeometry( recastWorld, (IntPtr)pVertices, vertexCount, (IntPtr)pIndices, indexCount );
    //            Vec3 targetPosition = ToRecastVec3( position );
    //            Wrapper.BuildTile( recastWorld, ref targetPosition );

    //            //redraw debug mesh
    //            debugNavigationMeshVertices = null;
    //            debugNavigationMeshIndices = null;
    //         }
    //      }
    //   }
    //}

    //public void RemoveTile( Vec3 position )
    //{
    //   if( recastWorld == IntPtr.Zero )
    //      return;

    //   Vec3 targetPosition = ToRecastVec3( position );
    //   Wrapper.RemoveTile( recastWorld, ref targetPosition );

    //   debugNavigationMeshVertices = null;
    //   debugNavigationMeshIndices = null;
    //}

    protected override void OnDeleteSubscribedToDeletionEvent( Entity entity )
    {
    	base.OnDeleteSubscribedToDeletionEvent( entity );

    	if( Geometries.Contains( entity ) )
        RemoveGeometry( entity );
    }

    protected override void OnRender( Camera camera )
    {
    	base.OnRender( camera );

    	if( camera.Purpose == Camera.Purposes.MainCamera )
    	{
        //if( drawTileGrid )
        //   DebugRenderTileGrid( camera );

        bool drawMapEditor = false;
        if( MapEditorInterface.Instance != null )
        {
        	//bool allow
        	try
        	{
            bool v = (bool)MapEditorInterface.Instance.SendCustomMessage( this, "IsAllowToRenderNavigationMesh", null );
            if( v )
            	drawMapEditor = true;
        	}
        	catch { }
        }

        if( alwaysDrawNavMesh || drawMapEditor )
        	DebugDrawNavMesh( camera );

        //draw global bounds
        bool mapEditorIsSelected = MapEditorInterface.Instance != null &&
        	MapEditorInterface.Instance.IsEntitySelected( this );
        if( mapEditorIsSelected )
        {
        	camera.DebugGeometry.Color = new ColorValue( 0, 0, 1 );
        	Bounds bounds = new Bounds( boundsMin, boundsMax );
        	camera.DebugGeometry.AddBounds( bounds );
        }



        //bool mapEditorIsSelected = false;
        //if( MapEditorInterface.Instance != null && MapEditorInterface.Instance.IsEntitySelected( this ) )
        //   mapEditorIsSelected = true;

        //if( alwaysDrawNavMesh || mapEditorIsSelected )
        //   DebugDrawNavMesh( camera );

        ////draw global bounds
        //if( mapEditorIsSelected )
        //{
        //   camera.DebugGeometry.Color = new ColorValue( 0, 0, 1 );

        //   Bounds bounds = new Bounds( boundsMin, boundsMax );
        //   camera.DebugGeometry.AddBounds( bounds );
        //}
    	}
    }

    public void DebugDrawNavMesh( Camera camera )
    {
    	if( recastWorld == IntPtr.Zero )
        return;

    	if( debugNavigationMeshVertices == null )
    	{
        if( !GetDebugNavigationMeshGeometry( out debugNavigationMeshVertices ) )
        	return;

        debugNavigationMeshIndices = new int[ debugNavigationMeshVertices.Length ];
        for( int n = 0; n < debugNavigationMeshIndices.Length; n++ )
        	debugNavigationMeshIndices[ n ] = n;
    	}

    	//Render NavMesh
    	{
        Mat4 transform = new Mat4( Mat3.Identity, new Vec3( 0, 0, .1f ) );

        //draw without depth test
        {
        	camera.DebugGeometry.SetSpecialDepthSettings( false, false );

        	camera.DebugGeometry.Color = new ColorValue( 0, 1, 0, .1f );
        	camera.DebugGeometry.AddVertexIndexBuffer( debugNavigationMeshVertices,
            debugNavigationMeshIndices, transform, false, true );

        	camera.DebugGeometry.Color = new ColorValue( 1, 1, 0, .1f );
        	camera.DebugGeometry.AddVertexIndexBuffer( debugNavigationMeshVertices,
            debugNavigationMeshIndices, transform, true, true );

        	camera.DebugGeometry.RestoreDefaultDepthSettings();
        }

        //draw with depth test
        {
        	camera.DebugGeometry.Color = new ColorValue( 0, 1, 0, .3f );
        	camera.DebugGeometry.AddVertexIndexBuffer( debugNavigationMeshVertices,
            debugNavigationMeshIndices, transform, false, true );
        	camera.DebugGeometry.Color = new ColorValue( 1, 1, 0, .3f );
        	camera.DebugGeometry.AddVertexIndexBuffer( debugNavigationMeshVertices,
            debugNavigationMeshIndices, transform, true, true );
        }
    	}
    }

    //void DebugRenderTileGrid( Camera camera )
    //{
    //   //make a tile grid
    //   {
    //      if( tileGridMeshVertices == null )
    //         CreateTileGridMesh( out tileGridMeshVertices, out tileGridMeshIndices, false );

    //      camera.DebugGeometry.Color = new ColorValue( 0f, 1f, 0f, .3f );
    //      camera.DebugGeometry.AddVertexIndexBuffer( tileGridMeshVertices, tileGridMeshIndices,
    //         Mat4.Identity, true, false );
    //   }

    //   //make a cell grid
    //   {
    //      if( cellGridMeshVertices == null )
    //         CreateTileGridMesh( out cellGridMeshVertices, out cellGridMeshIndices, true );

    //      camera.DebugGeometry.Color = new ColorValue( 1f, 0f, 0f, .3f );
    //      camera.DebugGeometry.AddVertexIndexBuffer( cellGridMeshVertices, cellGridMeshIndices,
    //         Mat4.Identity, true, false );
    //   }

    //   //add the bounds
    //   {
    //      camera.DebugGeometry.Color = new ColorValue( 0f, 1f, 1f, .6f );
    //      camera.DebugGeometry.AddBounds( new Bounds( boundsMin, boundsMax ) );
    //   }
    //}

    //void CreateTileGridMesh( out Vec3[] vertices, out int[] indices, bool cellSplit )
    //{
    //   int size;
    //   if( cellSplit )
    //      size = 128;
    //   else
    //      size = 64;

    //   vertices = new Vec3[ ( size + 1 ) * ( size + 1 ) ];
    //   {
    //      int vertexPosition = 0;
    //      for( int y = 0; y < size + 1; y++ )
    //      {
    //         for( int x = 0; x < size + 1; x++ )
    //         {
    //            xx;
    //            //SodanKerjuu: mirrored Y because of Recast coordinate system
    //            if( cellSplit )
    //            {
    //               vertices[ vertexPosition ] = new Vec3(
    //                  boundsMin.X + x * tileSize * cellSize,
    //                  boundsMax.Y - y * tileSize * cellSize,
    //                  boundsMin.Z + gridHeight * ( boundsMax.Z - boundsMin.Z ) );
    //            }
    //            else
    //            {
    //               vertices[ vertexPosition ] = new Vec3(
    //                  boundsMin.X + x * tileSize,
    //                  boundsMax.Y - y * tileSize,
    //                  boundsMin.Z + gridHeight * ( boundsMax.Z - boundsMin.Z ) );
    //            }
    //            vertexPosition++;
    //         }
    //      }
    //   }

    //   indices = new int[ size * size * 6 ];
    //   {
    //      int indexPosition = 0;
    //      for( int y = 0; y < size; y++ )
    //      {
    //         for( int x = 0; x < size; x++ )
    //         {
    //            indices[ indexPosition + 0 ] = ( size + 1 ) * y + x;
    //            indices[ indexPosition + 1 ] = ( size + 1 ) * y + x + 1;
    //            indices[ indexPosition + 2 ] = ( size + 1 ) * ( y + 1 ) + x + 1;
    //            indices[ indexPosition + 3 ] = ( size + 1 ) * ( y + 1 ) + x + 1;
    //            indices[ indexPosition + 4 ] = ( size + 1 ) * ( y + 1 ) + x;
    //            indices[ indexPosition + 5 ] = ( size + 1 ) * y + x;
    //            indexPosition += 6;
    //         }
    //      }
    //   }
    //}

    public bool GetDebugNavigationMeshGeometry( out Vec3[] vertices )
    {
    	vertices = null;

    	if( recastWorld == IntPtr.Zero )
        return false;

    	unsafe
    	{
        Vec3* nativeVertices;
        int vertexCount;
        if( !Wrapper.GetNavigationMesh( recastWorld, out nativeVertices, out vertexCount ) )
        	return false;

        vertices = new Vec3[ vertexCount ];
        for( int n = 0; n < vertices.Length; n++ )
        	vertices[ n ] = ToEngineVec3( nativeVertices[ n ] );

        Wrapper.FreeMemory( (IntPtr)nativeVertices );
    	}

    	return true;
    }

    public void AddGeometry( Entity entity )
    {
    	if( geometries.Contains( entity ) )
        Log.Fatal( "RecastNavigationSystem: AddGeometry: This entity is already added." );

    	geometries.Add( entity );
    	SubscribeToDeletionEvent( entity );
    }

    public void RemoveGeometry( Entity entity )
    {
    	if( !geometries.Contains( entity ) )
        return;

    	UnsubscribeToDeletionEvent( entity );
    	geometries.Remove( entity );
    }

    public void RemoveAllGeometries()
    {
    	while( geometries.Count != 0 )
        RemoveGeometry( geometries[ geometries.Count - 1 ] );
    }
	}
}

��

mybb@mybb.ru (Wowka70) — Fri, 17 Jan 2020 16:54:12 +0300

�� . � �� (((

�� 3.�.�?

mybb@mybb.ru (Wowka70) — Sat, 04 Jan 2020 22:07:00 +0300

��

NeoAxis Engine �� : �� Turret(��) � �� .

mybb@mybb.ru (Kamil) — Mon, 23 Dec 2019 18:29:03 +0300

� �� ? �� ? �� , � �� . ��, �� .

�� (��)

mybb@mybb.ru (Wowka70) — Fri, 29 Nov 2019 19:04:43 +0300

LMMS
�� !

��: Linux, Windows, Mac.

��.��: https://lmms.io

�� .

mybb@mybb.ru (Wowka70) — Sat, 09 Nov 2019 19:03:11 +0300

�� /�� :

��:

486 float realDamage = damage * ReceiveDamageCoefficient * _type.reductionBy - _type.minusDamage;

��

��:

if(_type.minusDamage != 0)
    {
    	if(realDamage <= 0)
    	{
        realDamage = 0;
    	}
    }

�� BTR

mybb@mybb.ru (Wowka70) — Mon, 07 Oct 2019 06:25:28 +0300

�� .

�� (car.cs) �� (gun.cs) ��

��

��: Andrey Holkin

�� - ��

��

mybb@mybb.ru (Wowka70) — Wed, 14 Aug 2019 07:34:41 +0300

Data.archive

loadingPriority = 0.5

NeoAxis Engine �� :�� NPS � ��

mybb@mybb.ru (Wowka70) — Fri, 19 Jul 2019 06:05:31 +0300

Bandit.animationTree

��:

blocks
{
	block Output
	{
    uin = 1
    in = 100
	}

	/////////////////////////////////////////////
	//Attack trigger

	block Trigger
	{
    uin = 100
    triggerName = "fire"
    off = 500
    on = 101
	}

	block Animation
	{
    uin = 101
    animationName = "attack1"
    speed = 1
	}

	/////////////////////////////////////////////
	//Attack stomach gun trigger

	block Trigger
	{
    uin = 500
    triggerName = "fireStomachGun"
    off = 200
    on = 501
	}

	block Animation
	{
    uin = 501
    animationName = "attack2"
    speed = 1
	}

	/////////////////////////////////////////////
	//Select walk or idle

	block Transition
	{
    uin = 200
	
    selectedIndexSource = 201
    animation0 = 400 // go to idle animation
    animation1 = 310 // go to walk
	}

	block Parameter
	{
    uin = 201
    parameterName = "move"
    value = 0
	}

	/////////////////////////////////////////////
	//Walk

	block Direction8Sides
	{
    uin = 310

    angleSource = 311
    speedMultiplierSource = 316

    forward = 312
    backward = 315
    left = 318
    right = 319
    forwardLeft = 312
    forwardRight = 312
    backwardLeft = 315
    backwardRight = 315
	}

	block Parameter
	{
    uin = 311
    parameterName = "moveAngle"
    value = 0
	}

	block Parameter
	{
    uin = 316
    parameterName = "moveSpeed"
    value = 1
	}

	block Animation
	{
    uin = 312
    animationName = "run"
    speed = 0.45
	}

	block Animation
	{
    uin = 315
    animationName = "run"
    speed = -0.4
	}

	block Animation
	{
    uin = 318
    animationName = "left"
    speed = 1
	}

	block Animation
	{
    uin = 319
    animationName = "left"
    speed = -1
	}
	/////////////////////////////////////////////
	//Idle

	block Animation
	{
    uin = 400
    animationName = "idle"
    speed = 1
	}

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

}

NeoAxis Engine �� :�� MeleeWeapon (�� )

mybb@mybb.ru (Wowka70) — Wed, 17 Jul 2019 11:30:14 +0300

��:

[FieldSerialize]
    float ReductionBy = 1.0f;

��:

[DefaultValue( 1.0f )]
    public float reductionBy
    {
    	get { return ReductionBy; }
    	set { ReductionBy = value; }
    }

��:

float realDamage = damage * ReceiveDamageCoefficient * _type.reductionBy;

�� DedicatedServer ��

mybb@mybb.ru (Wowka70) — Wed, 10 Jul 2019 07:13:02 +0300

� �� .

�� IP ��, �� (�� )

�� https://ivit.pro/services/avail-services/

�� .

��

�� .

NeoAxis Engine version:3.x.x

�������

�������� Actor

��� ������� ����� ������ � ������� ����?

����������� ������ ������

��� ����� �� Unity

����� ������ ! �������� ������ !!!

������� + ���������� GameCharacterAI

��� ���������

��� ���������

������ 3d ������� � �������� (3ds max)

3 ������� ��� ������� � ������ � ����

����� �� ������� ���� ��������� ������?

����������� ����������� NPC

������ ������ ��� GUI

������� ������ RecastNavigationSystem.cs

�� ��������� ������

����� �� �������� ������ ����� ������ ������ 3.�.�?

NeoAxis Engine ���� : ����� ������ Turret(������) � �������� ������.

���������� �������� ������(���������)

���������� ����� ��� ������������� ������.

����� BTR

���������� ����� �������� � ������� �������

NeoAxis Engine ���� :�������� NPS � ����

NeoAxis Engine ���� :����� �� ����� MeleeWeapon (������ �������� ���)

������� DedicatedServer ��������� ��� ������� �������������

��

�� Actor

�� ?

��

�� Unity

�� ! �� !!!

�� + �� GameCharacterAI

��

��

�� 3d �� (3ds max)

3 ��

�� ?

�� NPC

�� GUI

�� RecastNavigationSystem.cs

��

�� 3.�.�?

NeoAxis Engine �� : �� Turret(��) � �� .

�� (��)

�� .

�� BTR

��

NeoAxis Engine �� :�� NPS � ��

NeoAxis Engine �� :�� MeleeWeapon (�� )

�� DedicatedServer ��