ИИ в компьютерных играх

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
 
namespace P8_1
{
    /// 

    /// This is the main type for your game
    /// 
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;
        Texture2D txtBackground;
        Texture2D txtEnemy;
        Texture2D txtMe;
        Texture2D txtWall;
        //Массив для конструирования уровня
        public int[,] Layer;
        Rectangle recBackround = new Rectangle(0, 0, 640, 512);
        Rectangle recSprite = new Rectangle(0, 0, 64, 64);
 
        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
        }
 
        protected override void Initialize()
        {
            // TODO: Add your initialization logic here
            Layer = new int[8, 10] { 
            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 
            { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 }, 
            { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 }, 
            { 0, 0, 0, 0, 1, 6, 0, 0, 0, 0 }, 
            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 
            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
            { 0, 0, 0, 0, 0, 0, 0, 0, 5, 0 },
            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
            };
            //Устанавливаем разрешение игрового окна
            //640х512
 
            graphics.PreferredBackBufferWidth = 640;
            graphics.PreferredBackBufferHeight = 512;
            graphics.ApplyChanges();
            base.Initialize();
        }
 
 
        protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);
            Services.AddService(typeof(SpriteBatch), spriteBatch);
            txtBackground = Content.Load<Texture2D>("background");
            txtEnemy = Content.Load<Texture2D>("enemy");
            txtMe = Content.Load<Texture2D>("me");
            txtWall = Content.Load<Texture2D>("wall");
            //Вызываем процедуру расстановки объектов в игровом окне
            AddSprites();
 
            // TODO: use this.Content to load your game content here
        }
        //Процедура расстановки объектов в игровом окне
        void AddSprites()
        {
            //Переменные для временного хранения адреса
            //объекта-игрока
            int a = 0, b = 0;
            //Просматриваем массив Layer
            for (int i = 0; i < 8; i++)
            {
                for (int j = 0; j < 10; j++)
                {
                    //Если элемент с индексом (i,j) равен 1 - 
                    //устанавливаем в соответствующую позицию элемент с
                    //номером 1, то есть - стену
                    if (Layer[i, j] == 1)
                        Components.Add(new GameObj.Wall(this, ref txtWall, new Vector2(j, i), recSprite));
                    if (Layer[i, j] == 5)
                        Components.Add(new GameObj.Enemy(this, ref txtEnemy, new Vector2(j, i), new Rectangle(0, 0, 32, 32)));
                    //Если обнаружен объект игрока - запишем его координаты
                    if (Layer[i, j] == 6)
                    {
                        a = i;
                        b = j;
                    }
                }
            }
            //Последним установим объект игрока - так он гарантированно
            //расположен поверх всех остальных объектов
            Components.Add(new GameObj.Me(this, ref txtMe, new Vector2(b, a), new Rectangle(0, 0, 32, 32)));
        }
 
        protected override void UnloadContent()
        {
        }
 
 
        protected override void Update(GameTime gameTime)
        {
            base.Update(gameTime);
        }
 
        protected override void Draw(GameTime gameTime)
        {
            spriteBatch.Begin();
            //выведем фоновое изображение
            spriteBatch.Draw(txtBackground, recBackround, Color.White);
            //Выведем игровые объекты
            base.Draw(gameTime);
            spriteBatch.End();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Content;
 
namespace P8_1.GameObj
{
 
    public class gBaseClass : Microsoft.Xna.Framework.DrawableGameComponent
    {
        Texture2D sprTexture;
        public Vector2 sprPosition;
        public Rectangle sprRectangle;
        //Прямоугольник, представляющий игровое окно
        public Rectangle scrBounds;
        //Скорость объекта
        public float sprSpeed;
        public gBaseClass(Game game, ref Texture2D _sprTexture,
            Vector2 _sprPosition, Rectangle _sprRectangle)
            : base(game)
        {
            sprTexture = _sprTexture;
            //Именно здесь производится перевод индекса элемента массива
            //в координаты на игровом экране
            sprPosition = _sprPosition * 64;
            sprRectangle = _sprRectangle;
            scrBounds = new Rectangle(0, 0,
             game.Window.ClientBounds.Width,
             game.Window.ClientBounds.Height);
        }
 
 
        public override void Initialize()
        {
            base.Initialize();
        }
 
        /// 

        /// Allows the game component to update itself.
        /// 
        /// Provides a snapshot of timing values.
        public override void Update(GameTime gameTime)
        {
            base.Update(gameTime);
        }
        public override void Draw(GameTime gameTime)
        {
            SpriteBatch sprBatch =
                (SpriteBatch)Game.Services.GetService(typeof(SpriteBatch));
            sprBatch.Draw(sprTexture, sprPosition, Color.White);
            base.Draw(gameTime);
        }
        //Проверка на столкновение с каким-либо объектом
       public bool IsCollideWithObject(gBaseClass spr)
        {
            return (this.sprPosition.X + this.sprRectangle.Width > spr.sprPosition.X &&
                        this.sprPosition.X < spr.sprPosition.X + spr.sprRectangle.Width &&
                        this.sprPosition.Y + this.sprRectangle.Height > spr.sprPosition.Y &&
                        this.sprPosition.Y < spr.sprPosition.Y + spr.sprRectangle.Height);
 
 
        }
        //Процедуры для перемещения объекта
        public void MoveUp(float speed)
        {
            this.sprPosition.Y -= speed;
        }
        public void MoveDown(float speed)
        {
            this.sprPosition.Y += speed;
        }
        public void MoveLeft(float speed)
        {
            this.sprPosition.X -= speed;
        }
        public void MoveRight(float speed)
        {
            this.sprPosition.X += speed;
        }
        //Проверка на столкновение со стеной
       public bool IsCollideWithWall()
        {
            foreach (gBaseClass spr in Game.Components)
            {
                if (spr.GetType() == (typeof(Wall)))
                {
                    if (IsCollideWithObject(spr)) return true;
                }
            }
 
            return false;
        }
        //Проверка на столкновение с границами экрана
       public void Check()
        {
            if (sprPosition.X < scrBounds.Left)
            {
                sprPosition.X = scrBounds.Left;
            }
            if (sprPosition.X > scrBounds.Width - sprRectangle.Width)
            {
                sprPosition.X = scrBounds.Width - sprRectangle.Width;
            }
            if (sprPosition.Y < scrBounds.Top)
            {
                sprPosition.Y = scrBounds.Top;
            }
            if (sprPosition.Y > scrBounds.Height - sprRectangle.Height)
            {
                sprPosition.Y = scrBounds.Height - sprRectangle.Height;
            }
        }
 
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Content;
 
namespace P8_1.GameObj
{
    public class Wall : gBaseClass
    {
        public Wall(Game game, ref Texture2D _sprTexture,
            Vector2 _sprPosition, Rectangle _sprRectangle)
            : base(game, ref _sprTexture, _sprPosition, _sprRectangle)
        {
            // TODO: Construct any child components here
        }
 
        public override void Initialize()
        {
            // TODO: Add your initialization code here
 
            base.Initialize();
        }
 
        public override void Update(GameTime gameTime)
        {
            // TODO: Add your update code here
 
            base.Update(gameTime);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Content;
 
 
namespace P8_1.GameObj
{
    public class Me : gBaseClass
    {
        public Me(Game game, ref Texture2D _sprTexture,
            Vector2 _sprPosition, Rectangle _sprRectangle)
            : base(game, ref _sprTexture, _sprPosition, _sprRectangle)
        {
            sprSpeed = 2;
            // TODO: Construct any child components here
        }
 
        public override void Initialize()
        {
 
            base.Initialize();
        }
 
        public void IsCollideWithAny()
        {
            //Заводим переменную для временного хранения
            //ссылки на объект, с которым столкнулся игровой объект
            gBaseClass FindObj = null;
            //Проверка на столкновение с объектами Enemy
            foreach (gBaseClass spr in Game.Components)
            {
                if (spr.GetType() == (typeof(Enemy)))
                {
                    if (IsCollideWithObject(spr))
                    {
                        FindObj = spr;
                    }
                }
            }
 
            if (FindObj != null)
            {
 
                this.Dispose();
            }
        }
 
        //Процедура, отвечающая за перемещение игрового объекта
        void Move()
        {
            KeyboardState kbState = Keyboard.GetState();
            //При нажатии кнопки "Вверх"
            if (kbState.IsKeyDown(Keys.Up))
            {
                    MoveUp(sprSpeed);
 
                    while (IsCollideWithWall())
                    {
                        MoveDown((sprSpeed / 10));
                    }
                }
 
            //При нажатии кнопки "Вниз"
            //Происходит обычная процедура перемещения
            //объекта с проверкой
            if (kbState.IsKeyDown(Keys.Down))
            {
                MoveDown(sprSpeed);
                while (IsCollideWithWall())
                {
                    MoveUp((sprSpeed / 10));
                }
            }
            //Точно так же обрабатывается
            //нажатие кнопки "Влево"
            if (kbState.IsKeyDown(Keys.Left))
            {
                MoveLeft(sprSpeed);
                while (IsCollideWithWall())
                {
                    MoveRight((sprSpeed / 10));
                }
            }
            //Аналогично - перемещение вправо
            if (kbState.IsKeyDown(Keys.Right))
            {
                MoveRight(sprSpeed);
                while (IsCollideWithWall())
                {
                    MoveLeft((sprSpeed / 10));
                }
            }
 
        }
 
        public override void Update(GameTime gameTime)
        {
            // TODO: Add your update code here
            //Вызовем процедуру перемещения объекта по клавиатурным командам
            Move();
            //Проверим, не вышел ли он за границы экрана, если надо
            //исправим его позицию
            Check();
            IsCollideWithAny();
            base.Update(gameTime);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Content;
 
namespace P8_1.GameObj
{
    public class Enemy : gBaseClass
    {
        Vector2 Direction;
        public Enemy(Game game, ref Texture2D _sprTexture,
            Vector2 _sprPosition, Rectangle _sprRectangle)
            : base(game, ref _sprTexture, _sprPosition, _sprRectangle)
        {
            sprSpeed = 1;
            Direction = = new Vector2(0, 0);
            // TODO: Construct any child components here
        }
 
        public override void Initialize()
        {
            // TODO: Add your initialization code here
 
            base.Initialize();
        }
        //Вычисление направления на объект-игрока и передвижение в
        //этом направлении
        void SeekAndDestroy()
        {
            foreach (gBaseClass spr in Game.Components)
            {
                if (spr.GetType() == (typeof(Me)))
                {
                    //найдем разницу между координатами преследователя и
                    //игрока
                    Direction  = (this.sprPosition - spr.sprPosition);
                    //Если разность по X положительная
                    //переместим преследователя влево
                    //с учетом того, что стены для него 
                    //непроницаемы.
                    if (Direction.X > 0)
                    {
                        MoveLeft(sprSpeed);
                        while (IsCollideWithWall())
                        {
                            MoveRight((sprSpeed / 10));
                        }
                    }
                    //При отрицательной разности по X
                    //переместим объект вправо
                    if (Direction.X < 0)
                    {
                        MoveRight(sprSpeed);
                        while (IsCollideWithWall())
                        {
                            MoveLeft((sprSpeed / 10));
                        }
                    }
                    //При положительной разности по Y
                    //переместим объект вверх
                    if (Direction.Y > 0)
                    {
                        MoveUp(sprSpeed);
                        while (IsCollideWithWall())
                        {
                            MoveDown((sprSpeed / 10));
                        }
                    }
                    //При отрицательной разности по Y переместим
                    //объект вниз
                    if (Direction.Y < 0)
                    {
                        MoveDown(sprSpeed);
                        while (IsCollideWithWall())
                        {
                            MoveUp((sprSpeed / 10));
                        }
 
                    }
 
                }
            }
        }
 
        public override void Update(GameTime gameTime)
        {
            // Перемещение к объекту игрока
            SeekAndDestroy();
            //Проверка на столкновение с границами экрана
            Check();
            base.Update(gameTime);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
 
namespace P8_2
{
 
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;
        Texture2D txtBackground;
        Texture2D txtEnemy;
        Texture2D txtMe;
        Texture2D txtWall;
        //Массив для конструирования уровня
        public int[,] Layer;
        Rectangle recBackround = new Rectangle(0, 0, 640, 512);
        Rectangle recSprite = new Rectangle(0, 0, 64, 64);
 
        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
        }
 
        protected override void Initialize()
        {
            // TODO: Add your initialization logic here
            Layer = new int[8, 10] { 
            { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 }, 
            { 0, 1, 1, 1, 1, 1, 0, 1, 0, 0 }, 
            { 0, 1, 0, 0, 0, 0, 0, 0, 1, 0 }, 
            { 0, 0, 0, 0, 1, 1, 0, 0, 1, 0 }, 
            { 0, 5, 0, 0, 1, 0, 1, 0, 0, 0 }, 
            { 0, 0, 1, 0, 0, 0, 0, 1, 1, 1 },
            { 0, 0, 0, 0, 0, 0, 0, 0, 1, 6 },
            { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
            };
            //Устанавливаем разрешение игрового окна
            //640х512
 
            graphics.PreferredBackBufferWidth = 640;
            graphics.PreferredBackBufferHeight = 512;
            graphics.ApplyChanges();
            base.Initialize();
        }
 
        protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);
            Services.AddService(typeof(SpriteBatch), spriteBatch);
            txtBackground = Content.Load<Texture2D>("background");
            txtEnemy = Content.Load<Texture2D>("enemy");
            txtMe = Content.Load<Texture2D>("me");
            txtWall = Content.Load<Texture2D>("wall");
            //Вызываем процедуру расстановки объектов в игровом окне
            AddSprites();
 
            // TODO: use this.Content to load your game content here
        }
        //Процедура расстановки объектов в игровом окне
        void AddSprites()
        {
            //Переменные для временного хранения адреса
            //объекта-игрока
            int a = 0, b = 0;
            //Просматриваем массив Layer
            for (int i = 0; i < 8; i++)
            {
                for (int j = 0; j < 10; j++)
                {
                    //Если элемент с индексом (i,j) равен 1 - 
                    //устанавливаем в соответствующую позицию элемент с
                    //номером 1, то есть - стену
                    if (Layer[i, j] == 1)
                        Components.Add(new GameObj.Wall(this, ref txtWall, new Vector2(j, i), recSprite));
                    if (Layer[i, j] == 5)
                        Components.Add(new GameObj.Enemy(this, ref txtEnemy, new Vector2(j, i), new Rectangle(0, 0, 32, 32)));
                    //Если обнаружен объект игрока - запишем его координаты
                    if (Layer[i, j] == 6)
                    {
                        a = i;
                        b = j;
                    }
                }
            }
            //Последним установим объект игрока - так он гарантированно
            //расположен поверх всех остальных объектов
            Components.Add(new GameObj.Me(this, ref txtMe, new Vector2(b, a), new Rectangle(0, 0, 32, 32)));
        }
 
        protected override void UnloadContent()
        {
        }
        protected override void Update(GameTime gameTime)
        {
            base.Update(gameTime);
        }
 
        protected override void Draw(GameTime gameTime)
        {
            spriteBatch.Begin();
            //выведем фоновое изображение
            spriteBatch.Draw(txtBackground, recBackround, Color.White);
            //Выведем игровые объекты
            base.Draw(gameTime);
            spriteBatch.End();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Content;
 
namespace P8_2.GameObj
{
    /// 

    /// This is a game component that implements IUpdateable.
    /// 
    public class gBaseClass : Microsoft.Xna.Framework.DrawableGameComponent
    {
        Texture2D sprTexture;
        public Vector2 sprPosition;
        public Rectangle sprRectangle;
        //Прямоугольник, представляющий игровое окно
        public Rectangle scrBounds;
        //Скорость объекта
        public float sprSpeed;
        public gBaseClass(Game game, ref Texture2D _sprTexture,
            Vector2 _sprPosition, Rectangle _sprRectangle)
            : base(game)
        {
            sprTexture = _sprTexture;
            //Именно здесь производится перевод индекса элемента массива
            //в координаты на игровом экране
            sprPosition = _sprPosition * 64;
            sprRectangle = _sprRectangle;
            scrBounds = new Rectangle(0, 0,
             game.Window.ClientBounds.Width,
             game.Window.ClientBounds.Height);
        }
 
        public override void Initialize()
        {
            base.Initialize();
        }
 
        public override void Update(GameTime gameTime)
        {
            base.Update(gameTime);
        }
        public override void Draw(GameTime gameTime)
        {
            SpriteBatch sprBatch =
                (SpriteBatch)Game.Services.GetService(typeof(SpriteBatch));
            sprBatch.Draw(sprTexture, sprPosition, Color.White);
            base.Draw(gameTime);
        }
        //Проверка на столкновение с каким-либо объектом
        public bool IsCollideWithObject(gBaseClass spr)
        {
            return (this.sprPosition.X + this.sprRectangle.Width > spr.sprPosition.X &&
                        this.sprPosition.X < spr.sprPosition.X + spr.sprRectangle.Width &&
                        this.sprPosition.Y + this.sprRectangle.Height > spr.sprPosition.Y &&
                        this.sprPosition.Y < spr.sprPosition.Y + spr.sprRectangle.Height);
 
 
        }
        //Процедуры для перемещения объекта
        public void MoveUp(float speed)
        {
            this.sprPosition.Y -= speed;
        }
        public void MoveDown(float speed)
        {
            this.sprPosition.Y += speed;
        }
        public void MoveLeft(float speed)
        {
            this.sprPosition.X -= speed;
        }
        public void MoveRight(float speed)
        {
            this.sprPosition.X += speed;
        }
        //Проверка на столкновение со стеной
        public bool IsCollideWithWall()
        {
            foreach (gBaseClass spr in Game.Components)
            {
                if (spr.GetType() == (typeof(Wall)))
                {
                    if (IsCollideWithObject(spr)) return true;
                }
            }
 
            return false;
        }
        //Проверка на столкновение с границами экрана
        public void Check()
        {
            if (sprPosition.X < scrBounds.Left)
            {
                sprPosition.X = scrBounds.Left;
            }
            if (sprPosition.X > scrBounds.Width - sprRectangle.Width)
            {
                sprPosition.X = scrBounds.Width - sprRectangle.Width;
            }
            if (sprPosition.Y < scrBounds.Top)
            {
                sprPosition.Y = scrBounds.Top;
            }
            if (sprPosition.Y > scrBounds.Height - sprRectangle.Height)
            {
                sprPosition.Y = scrBounds.Height - sprRectangle.Height;
            }
        }
        public bool CheckBounds()
        {
            return ((sprPosition.X < scrBounds.Left|
                sprPosition.X > scrBounds.Width - sprRectangle.Width|
                sprPosition.Y < scrBounds.Top|
                sprPosition.Y > scrBounds.Height - sprRectangle.Height));
 
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Content;
 
namespace P8_2.GameObj
{
    public class Wall : gBaseClass
    {
        public Wall(Game game, ref Texture2D _sprTexture,
            Vector2 _sprPosition, Rectangle _sprRectangle)
            : base(game, ref _sprTexture, _sprPosition, _sprRectangle)
        {
            // TODO: Construct any child components here
        }
 
 
        public override void Initialize()
        {
            // TODO: Add your initialization code here
 
            base.Initialize();
        }
 
        public override void Update(GameTime gameTime)
        {
            // TODO: Add your update code here
 
            base.Update(gameTime);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Content;
 
 
namespace P8_2.GameObj
{
    public class Me : gBaseClass
    {
        public Me(Game game, ref Texture2D _sprTexture,
            Vector2 _sprPosition, Rectangle _sprRectangle)
            : base(game, ref _sprTexture, _sprPosition, _sprRectangle)
        {
            sprSpeed = 2;
            // TODO: Construct any child components here
        }
 
        public override void Initialize()
        {
 
            base.Initialize();
        }
 
        public void IsCollideWithAny()
        {
            //Заводим переменную для временного хранения
            //ссылки на объект, с которым столкнулся игровой объект
            gBaseClass FindObj = null;
 
 
            //Проверка на столкновение с объектами Enemy
            foreach (gBaseClass spr in Game.Components)
            {
                if (spr.GetType() == (typeof(Enemy)))
                {
                    if (IsCollideWithObject(spr))
                    {
                        FindObj = spr;
                    }
                }
            }
 
            if (FindObj != null)
            {
 
                this.Dispose();
            }
        }
 
        //Процедура, отвечающая за перемещение игрового объекта
        void Move()
        {
            KeyboardState kbState = Keyboard.GetState();
            //При нажатии кнопки "Вверх"
            if (kbState.IsKeyDown(Keys.Up))
            {
                MoveUp(sprSpeed);
 
                while (IsCollideWithWall())
                {
                    MoveDown((sprSpeed / 10));
                }
            }
 
            //При нажатии кнопки "Вниз"
            //Происходит обычная процедура перемещения
            //объекта с проверкой
            if (kbState.IsKeyDown(Keys.Down))
            {
                MoveDown(sprSpeed);
                while (IsCollideWithWall())
                {
                    MoveUp((sprSpeed / 10));
                }
            }
            //Точно так же обрабатывается
            //нажатие кнопки "Влево"
            if (kbState.IsKeyDown(Keys.Left))
            {
                MoveLeft(sprSpeed);
                while (IsCollideWithWall())
                {
                    MoveRight((sprSpeed / 10));
                }
            }
            //Аналогично - перемещение вправо
            if (kbState.IsKeyDown(Keys.Right))
            {
                MoveRight(sprSpeed);
                while (IsCollideWithWall())
                {
                    MoveLeft((sprSpeed / 10));
                }
            }
 
        }
 
        public override void Update(GameTime gameTime)
        {
            // TODO: Add your update code here
            //Вызовем процедуру перемещения объекта по клавиатурным командам
            Move();
            //Проверим, не вышел ли он за границы экрана, если надо
            //исправим его позицию
            Check();
            IsCollideWithAny();
            base.Update(gameTime);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Content;
 
namespace P8_2.GameObj
{
 
    public class Enemy : gBaseClass
    {
        Vector2 Direction;
        //Переменная, задающая первоначальное направление движения
        int WhereToMove = 1;
        //Генератор случайных чисел
        Random r = new Random();
        //Переменная для исключения повторного
        //поворота объекта при движении вдоль
        //стены или границы экрана
        bool flag = true;
        //Переменная для исключения повторного поворота объекта
        //при движении в свободном пространстве
        bool flag1 = false;
        //Количество ходов в свободном пространстве перед поворотом значение
        int FreeMoveCount = 150;
 
        public Enemy(Game game, ref Texture2D _sprTexture,
            Vector2 _sprPosition, Rectangle _sprRectangle)
            : base(game, ref _sprTexture, _sprPosition, _sprRectangle)
        {
            sprSpeed = 1;
            Direction = new Vector2(0, 0);
            // TODO: Construct any child components here
        }
 
        public override void Initialize()
        {
            // TODO: Add your initialization code here
 
            base.Initialize();
        }
 
        //Функция для реализации "взгляда" объекта. Если он видит
        //объект преследования - возвращает True, иначе - False
        bool simulateMove(Vector2 testPosition)
        {
            //Находится ли объект игрока так, что объект
            //управляемый компьютером может "видеть" его.
            //Предположим, что да
            bool IsCollide = true;
            bool CollisionDetected = false;
            Vector2 Dir;
            Vector2 OldPosition = this.sprPosition;
            if (testPosition.X == -1 & testPosition.Y == -1)
            {
                foreach (gBaseClass spr in Game.Components)
                {
 
                    if (spr.GetType() == (typeof(Me)))
                    {
 
                        while (CollisionDetected == false)
                        {
                            Dir = (this.sprPosition - new Vector2 (spr.sprPosition.X, spr.sprPosition .Y));
                            if (Dir.X > 0) MoveLeft(Math.Abs(Dir.X / 100));
                            if (Dir.X < 0) MoveRight(Math.Abs(Dir.X / 100));
                            if (Dir.Y > 0) MoveUp(Math.Abs(Dir.Y / 100));
                            if (Dir.Y < 0) MoveDown(Math.Abs(Dir.Y / 100));
                            if (IsCollideWithWall())
                            {
                                CollisionDetected = true;
                                IsCollide = false;
 
                            }
                            if (IsCollideWithObject(spr))
                            {
                                CollisionDetected = true;
                                IsCollide = true;
 
 
                            }
                        }
                    }
                }
 
            }
            else //Проверяем на столкновение объекта и стены
                //эта часть функции реализует "зрение" объекта
            {
                while (CollisionDetected == false)
                {
                    Dir = (this.sprPosition - testPosition);
                    if (Dir.X > 0) MoveLeft(Math.Abs(Dir.X / 100));
                    if (Dir.X < 0) MoveRight(Math.Abs(Dir.X / 100));
                    if (Dir.Y > 0) MoveUp(Math.Abs(Dir.Y / 100));
                    if (Dir.Y < 0) MoveDown(Math.Abs(Dir.Y / 100));
                    if (IsCollideWithWall())
                    {
                        CollisionDetected = true;
                        IsCollide = true;
 
                    }
                    if (CheckBounds())
                    {
                        CollisionDetected = true;
                        IsCollide = true;
                    }
                    if (Math.Abs(Dir.X) < 0.1 & Math.Abs(Dir.Y) < 0.1)
                    {
                        CollisionDetected = true;
                        IsCollide = false;
                    }
                }
 
            }
 
 
            this.sprPosition = OldPosition;
            return IsCollide;
 
        }
 
 
 
 
        void SeekAndDestroy()
        {
            foreach (gBaseClass spr in Game.Components)
            {
                if (spr.GetType() == (typeof(Me)))
                {
                    //найдем разницу между координатами преследователя и игрока
                    Direction = (this.sprPosition - spr.sprPosition);
                    //Если разность по X положительная
                    //переместим преследователя влево
                    //с учетом того, что стены для него непроницаемы.
                    if (Direction.X > 0)
                    {
                        MoveLeft(sprSpeed);
                        while (IsCollideWithWall())
                        {
                            MoveRight((sprSpeed / 10));
                        }
 
                    }
                    //При отрицательной разности по X переместим объект вправо 
                    if (Direction.X < 0)
                    {
                        MoveRight(sprSpeed);
                        while (IsCollideWithWall())
                        {
                            MoveLeft((sprSpeed / 10));
                        }
 
                    }
                    //При положительной разности по Y переместим объект вверх
                    if (Direction.Y > 0)
                    {
                        MoveUp(sprSpeed);
                        while (IsCollideWithWall())
                        {
                            MoveDown((sprSpeed / 10));
                        }
 
                    }
                    //При отрицательной разности по Y переместим объект вниз
                    if (Direction.Y < 0)
                    {
                        MoveDown(sprSpeed);
                        while (IsCollideWithWall())
                        {
                            MoveUp((sprSpeed / 10));
                        }
 
                    }
 
                }
            }
        }
        //Движение вдоль стены или в свободном пространстве
        //Направление движения
        //1 - влево
        //2 - вправо
        //3 - вверх
        //4 - вниз
        void WallWalk(int Direction)
        {
            if (Direction == 1)
            {
 
                MoveLeft(sprSpeed);
 
            }
 
            if (Direction == 2)
            {
 
                MoveRight(sprSpeed);
 
            }
            if (Direction == 3)
            {
                MoveUp(sprSpeed);
 
            }
            if (Direction == 4)
            {
                MoveDown(sprSpeed);
 
            }
 
        }
        /// 

        /// Allows the game component to update itself.
        /// 
        /// Provides a snapshot of timing values.
        public override void Update(GameTime gameTime)
        {
 
            //Если на пути нет препятствий
            //Перемещение к объекту игрока
 
 
            if (simulateMove(new Vector2(-1, -1)))
            {
                SeekAndDestroy();
 
            }
            else 
            {
                //Перемещение вдоль стены или в свободном пространстве
                WallWalk(WhereToMove);
 
                //Разрешить повороты вдоль стены
                flag = true;
 
 
                if (IsCollideWithWall() | CheckBounds())
                {
                    //Разрешить повороты в пространстве
                    //Найдя "разрыв" в стене объект повернет в него
                    flag1 = true;
 
                    //
                    if (WhereToMove == 1 & flag)
                    {
                        WhereToMove = 3;
                        //Если сделан поворот
                        //Нельзя сразу же делать поворот в другую сторону
                        flag = false;
                    }
                    if (WhereToMove == 2 & flag)
                    {
 
                        WhereToMove = 4;
                        flag = false;
                    }
                    if (WhereToMove == 3 & flag)
                    {
                        WhereToMove = 2;
                        flag = false;
                    }
                    if (WhereToMove == 4 & flag)
                    {
                        WhereToMove = 1;
                        flag = false;
                    }
                }
 
                //Блок обработки перемещений в пространстве
                //и в "разрывах" стен
 
                //Если выполнено количество шагов, заданное
                //в переменной FreeMoveCount
                //Установить новое случайное значение для этой переменной
                //Разрешить повороты в свободном пространстве
                if (FreeMoveCount <0)
                {
                    FreeMoveCount = r.Next(20, 100);
                    flag1 = true;
                }
 
                //Если не было поворота вдоль стены
                //И разрешены повороты в пространстве
                //И выше объекта нет препятствия
                //То - сменить направление движения на "вверх"
                //После
                if (flag&flag1 & WhereToMove == 2 & simulateMove(new Vector2(this.sprPosition.X, this.sprPosition.Y - 5)) == false)
                {
                    WhereToMove = 3;
                    flag1 = false;
                    flag = false;
                }
                //Если при движении вверх обнаруживаем, что нет препятствия слева
                //поворачиваем влево
 
                if (flag&flag1 & WhereToMove == 3 & simulateMove(new Vector2(this.sprPosition.X - 5, this.sprPosition.Y)) == false)
                {
                    WhereToMove = 1;
                    flag1 = false;
                    flag = false;
                }
 
                //Если при движении влево обнаруживаем, что нет препятсвия внизу
                //двигаемся вниз
                if (flag&flag1 & WhereToMove == 1 & simulateMove(new Vector2(this.sprPosition.X, this.sprPosition.Y + 5)) == false)
                {
                    WhereToMove = 4;
                    flag1 = false;
                    flag = false;
                }
 
                //Если двигались вниз и обнаружили, что справа нет препятствия
                //Двигаемся вправо
                if (flag&flag1 & WhereToMove == 4 & simulateMove(new Vector2(this.sprPosition.X + 5, this.sprPosition.Y)) == false)
                {
                    WhereToMove = 2;
                    flag1 = false;
                    flag = false;
                }
 
            }
 
            //Проверка на столкновение с границами экрана
            Check();
            //Уменьшаем на 1 количество допустимых ходов в 
            //свободном пространстве
            FreeMoveCount--;
            base.Update(gameTime);
        }
    }
}