Устройства ввода, перемещение объектов

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

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

    /// This is the main type for your game
    /// 
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;
        private Texture2D MySprite;
        private Vector2 position = new Vector2(150, 200);
 
        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
        }
 
        protected override void LoadContent()
        {
            spriteBatch = new SpriteBatch(GraphicsDevice);
            MySprite = Content.Load<Texture2D>("ball");
        }
 
        protected override void Update(GameTime gameTime)
        {
            // Allows the game to exit
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();
 
            base.Update(gameTime);
        }
 
 
        protected override void Draw(GameTime gameTime)
        {
            graphics.GraphicsDevice.Clear(Color.CornflowerBlue);
 
            spriteBatch.Begin();
            spriteBatch.Draw(MySprite, position, Color.White);
            spriteBatch.End();
 
            base.Draw(gameTime);
        }
    }
}

1
2
3
4
5
6
7
8
9
10

     KeyboardState kbState = Keyboard.GetState();
 
     if (kbState.IsKeyDown(Keys.Up))
         position.Y -= 1;
     if (kbState.IsKeyDown(Keys.Down))
         position.Y += 1;
     if (kbState.IsKeyDown(Keys.Left))
         position.X -= 1;
     if (kbState.IsKeyDown(Keys.Right))
         position.X += 1;

1
2
3

MouseState mState = Mouse.GetState();
position.X = mState.X;
position.Y = mState.Y;

1
2

bool is_MouseLB_Pressed = false;
Vector2 new_position = new Vector2();

1
2
3
4
5

protected override void Initialize()
{
    base.Initialize();
    this.IsMouseVisible = true;
}

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

protected override void Update(GameTime gameTime)
        {
            // Allows the game to exit
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();
            MouseState mState = Mouse.GetState();
            if (mState.LeftButton ==ButtonState .Pressed)
            {
                is_MouseLB_Pressed = true;
                new_position.X = mState.X;
                new_position .Y = mState .Y;
            }
            if (is_MouseLB_Pressed)
            {
                if (new_position .X -position .X >0)
                {
                    position .X +=1;
                }
                else
                {
                    position .X-=1;
                }
                if (new_position .Y-position .Y>0)
                {
                    position .Y+=1;
                }
                else
                {
                    position .Y -=1;
                }             
                if (position == new_position)
                {
                    is_MouseLB_Pressed = false;
                }
            }
        }

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

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

    /// This is a game component that implements IUpdateable.
    /// 
    public class spriteComp : Microsoft.Xna.Framework.DrawableGameComponent
    {
        private Texture2D sprTexture;
        private Rectangle sprRectangle;
        private Vector2 sprPosition;
        private Rectangle scrBounds;
 
        public spriteComp(Game game, ref Texture2D newTexture,
            Rectangle newRectangle, Vector2 newPosition)
            : base(game)
        {
            sprTexture = newTexture;
            sprRectangle = newRectangle;
            sprPosition = newPosition;
            scrBounds = new Rectangle(0, 0, 
                game.Window.ClientBounds.Width, 
                game.Window.ClientBounds.Height);
            // TODO: Construct any child components here
        }
 
        public override void Initialize()
        {
            // TODO: Add your initialization code here
 
            base.Initialize();
        }
 
        public override void Update(GameTime gameTime)
        {
            KeyboardState kbState = Keyboard.GetState();
            if (kbState.IsKeyDown(Keys.Up))
            {
                sprPosition.Y -= 5;
            }
            if (kbState.IsKeyDown(Keys.Down))
            {
                sprPosition.Y += 5;
            }
            if (kbState.IsKeyDown(Keys.Left))
            {
                sprPosition.X -= 5;
            }
            if (kbState.IsKeyDown(Keys.Right))
            {
                sprPosition.X += 5;
            }
 
            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;
            }
 
            base.Update(gameTime);
        }
        public override void Draw(GameTime gameTime)
        {
            SpriteBatch sprBatch =
                (SpriteBatch)Game.Services.GetService(typeof(SpriteBatch));
 
            sprBatch.Draw(sprTexture, sprPosition, sprRectangle, Color.White);
            base.Draw(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

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

    /// This is a game component that implements IUpdateable.
    /// 
    public class spriteComp : Microsoft.Xna.Framework.DrawableGameComponent
    {
        protected  Texture2D sprTexture;
        protected  Rectangle sprRectangle;
        protected  Vector2 sprPosition;
        protected  Rectangle scrBounds;
 
        public spriteComp(Game game, ref Texture2D newTexture,
            Rectangle newRectangle, Vector2 newPosition)
            : base(game)
        {
            sprTexture = newTexture;
            sprRectangle = newRectangle;
            sprPosition = newPosition;
            scrBounds = new Rectangle(0, 0,
                game.Window.ClientBounds.Width,
                game.Window.ClientBounds.Height);
            // TODO: Construct any child components here
        }
 
        public override void Initialize()
        {
            // TODO: Add your initialization code here
 
            base.Initialize();
        }
        public virtual void Move()
        {
            Check();
        }
        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 override void Update(GameTime gameTime)
        {
            // TODO: Add your update code here
            Move();
            base.Update(gameTime);
        }
        public override void Draw(GameTime gameTime)
        {
            SpriteBatch sprBatch =
                (SpriteBatch)Game.Services.GetService(typeof(SpriteBatch));
            sprBatch.Draw(sprTexture, sprPosition, sprRectangle, Color.White);
            base.Draw(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

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Content;
 
namespace P3_5
{
    public class gameObj1 : spriteComp 
    {
        public gameObj1(Game game, ref Texture2D newTexture,
            Rectangle newRectangle, Vector2 newPosition)
            : base(game, ref newTexture , newRectangle , newPosition )
        {
            // TODO: Construct any child components here
        }
        public override void Move()
        {
            KeyboardState kbState = Keyboard.GetState();
            if (kbState.IsKeyDown(Keys.Up))
            {
                sprPosition.Y -= 5;
            }
            if (kbState.IsKeyDown(Keys.Down))
            {
                sprPosition.Y += 5;
            }
            if (kbState.IsKeyDown(Keys.Left))
            {
                sprPosition.X -= 5;
            }
            if (kbState.IsKeyDown(Keys.Right))
            {
                sprPosition.X += 5;
            }
 
            base.Move();
        }
 
        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);
        }
        public override void Draw(GameTime gameTime)
        {
            base.Draw(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

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Content;
 
namespace P3_5
{
 
    public class gameObj2 : spriteComp
    {
        public gameObj2(Game game, ref Texture2D newTexture,
            Rectangle newRectangle, Vector2 newPosition)
            : base(game, ref newTexture, newRectangle, newPosition)
        {
            // TODO: Construct any child components here
        }
        public override void Move()
        {
            KeyboardState kbState = Keyboard.GetState();
            if (kbState.IsKeyDown(Keys.W))
            {
                sprPosition.Y -= 5;
            }
            if (kbState.IsKeyDown(Keys.S ))
            {
                sprPosition.Y += 5;
            }
            if (kbState.IsKeyDown(Keys.A ))
            {
                sprPosition.X -= 5;
            }
            if (kbState.IsKeyDown(Keys.D))
            {
                sprPosition.X += 5;
            }
 
            base.Move();
        }
 
        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);
        }
        public override void Draw(GameTime gameTime)
        {
            base.Draw(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

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

    /// This is the main type for your game
    /// 
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;
        gameObj1  gameObject;
        gameObj2 gameObject2;
        Texture2D texture;
 
        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
        }
 
        protected override void Initialize()
        {
            // TODO: Add your initialization logic here
 
            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);
            texture = Content.Load<Texture2D>("BallandBats");
            CreateNewObject();
            // TODO: use this.Content to load your game content here
        }
 
        protected void CreateNewObject()
        {
            gameObject = new gameObj1 (this, ref texture,
                new Rectangle(18, 9, 17, 88), 
                new Vector2(100, 150));
            Components.Add(gameObject1);
            gameObject2 = new gameObj2(this, ref texture,
                new Rectangle(17, 106, 17,88), 
                new Vector2(200, 150));
            Components.Add(gameObject2);
        }
 
        protected override void UnloadContent()
        {
            // TODO: Unload any non ContentManager content here
        }
 
        protected override void Update(GameTime gameTime)
        {
 
            // TODO: Add your update logic here
 
            base.Update(gameTime);
        }
 
        protected override void Draw(GameTime gameTime)
        {
            graphics.GraphicsDevice.Clear(Color.CornflowerBlue);
 
            // TODO: Add your drawing code here
            spriteBatch.Begin();
            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

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Content;
 
namespace P3_6
{
    public class spriteComp : Microsoft.Xna.Framework.DrawableGameComponent
    {
        protected Texture2D sprTexture;
        public Rectangle sprRectangle;
        public Vector2 sprPosition;
 
 
        public spriteComp(Game game, ref Texture2D newTexture,
            Rectangle newRectangle, Vector2 newPosition)
            : base(game)
        {
            sprTexture = newTexture;
            sprRectangle = newRectangle;
            sprPosition = newPosition;
 
            // 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);
        }
        public override void Draw(GameTime gameTime)
        {
            SpriteBatch sprBatch =
                (SpriteBatch)Game.Services.GetService(typeof(SpriteBatch));
            sprBatch.Draw(sprTexture, sprPosition, sprRectangle, Color.White);
            base.Draw(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

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
 
namespace P3_6
{
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;
        spriteComp  gameObject1, gameObject2;
        Texture2D texture;
        Rectangle scrBounds;
        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
        }
 
        protected override void Initialize()
        {
            // TODO: Add your initialization logic here
 
            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);
            texture = Content.Load<Texture2D>("BallandBats");
            scrBounds = new Rectangle(0, 0,
                this.Window.ClientBounds.Width,
                this.Window.ClientBounds.Height);
            CreateNewObject();
        }
 
        protected void CreateNewObject()
        {
            gameObject1 = new spriteComp (this, ref texture,
                new Rectangle(18, 9, 17, 88),
                new Vector2(100, 150));
            Components.Add(gameObject1);
            gameObject2 = new spriteComp (this, ref texture,
                new Rectangle(17, 106, 17, 88),
                new Vector2(200, 150));
            Components.Add(gameObject2);
        }
 
        void Test (spriteComp spr, Rectangle scr)
        {
            if (spr.sprPosition.X < scr.Left)
            {
                spr.sprPosition.X = scr.Left;
            }
            if (spr.sprPosition.X > scr.Width - spr.sprRectangle.Width)
            {
                spr.sprPosition.X = scr.Width - spr.sprRectangle.Width;
            }
            if (spr.sprPosition.Y < scr.Top)
            {
                spr.sprPosition.Y = scr.Top;
            }
            if (spr.sprPosition.Y > scr.Height - spr.sprRectangle.Height)
            {
                spr.sprPosition.Y = scr.Height - spr.sprRectangle.Height;
            }
        }
 
        void MoveUp(spriteComp spr)
        {
            spr.sprPosition.Y -= 5;
        }
        void MoveDown(spriteComp spr)
        {
            spr.sprPosition.Y += 5;
        }
        void MoveLeft(spriteComp spr)
        {
            spr.sprPosition.X -= 5;
        }
        void MoveRight(spriteComp spr)
        {
            spr.sprPosition.X += 5;
        }
 
        protected override void Update(GameTime gameTime)
        {
            KeyboardState kbState = Keyboard.GetState();
            if (kbState.IsKeyDown(Keys.Up))
            {
                MoveUp(gameObject1);
            }
            if (kbState.IsKeyDown(Keys.Down))
            {
                MoveDown(gameObject1);
            }
            if (kbState.IsKeyDown(Keys.Left))
            {
                MoveLeft(gameObject1);
            }
            if (kbState.IsKeyDown(Keys.Right))
            {
                MoveRight(gameObject1);
            }
            Test(gameObject1, scrBounds);
            if (kbState.IsKeyDown(Keys.W))
            {
                MoveUp(gameObject2);
            }
            if (kbState.IsKeyDown(Keys.S))
            {
                MoveDown(gameObject2);
            }
            if (kbState.IsKeyDown(Keys.A))
            {
                MoveLeft(gameObject2);
            }
            if (kbState.IsKeyDown(Keys.D))
            {
                MoveRight(gameObject2);
            }
            Test(gameObject2, scrBounds);
            base.Update(gameTime);
        }
 
        protected override void Draw(GameTime gameTime)
        {
            graphics.GraphicsDevice.Clear(Color.CornflowerBlue);
 
            spriteBatch.Begin();
            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
123
124
125
126
127
128
129

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

    /// This is a game component that implements IUpdateable.
    /// 
    public class spriteComp : Microsoft.Xna.Framework.DrawableGameComponent
    {
        protected Texture2D sprTexture;
        protected Rectangle sprRectangle;
        protected Vector2 sprPosition;
        protected Rectangle scrBounds;
        //Для генерирования случайных чисел
        protected Random randNum;
        //Количество шагов, которое пройдет спрайт
        protected int stepNumber;
        //Координата, к которой он будет двигаться
        protected Vector2 newPosition;
        //Цвет спрайта
        protected Color sprColor;
        //Скорость перемещения
        protected Vector2 speed;
 
        public spriteComp(Game game, ref Texture2D newTexture,
            Rectangle newRectangle, int Seed)
            : base(game)
        {
            sprTexture = newTexture;
            sprRectangle = newRectangle;
            //Инициализируем счетчик
            randNum = new Random(Seed);
 
            scrBounds = new Rectangle(0, 0,
                game.Window.ClientBounds.Width,
                game.Window.ClientBounds.Height);
            //Устанавливаем стартовую позицию спрайта
            sprPosition.X = (float)randNum.NextDouble() * (scrBounds.Width - sprRectangle.Width);
            sprPosition.Y = (float)randNum.NextDouble() * (scrBounds.Height  - sprRectangle.Height);
            //Колишество шагов равно нулю
            stepNumber = 0;
            //Зададим случайный цвет для придания изображению
            //соответствующего оттенка
            sprColor = new Color((byte)randNum.Next(0, 255), (byte)randNum.Next(0, 255), (byte)randNum.Next(0, 255));
            //Переменная для хранения скорости пока пуста
            speed = new Vector2 ();
            // TODO: Construct any child components here
        }
 
        public override void Initialize()
        {
            // TODO: Add your initialization code here
 
            base.Initialize();
        }
        //Перемещение спрайта
        public virtual void Move()
        {
            //Если выполнены не все шаги
            if (stepNumber > 0)
            {
                //уменьшим переменную, хранящую число шагов
                stepNumber--;
                //Модифицируем координаты в соответствии с положением
                //объекта относительно желаемой координаты
                //и в соответствии со скоростью
                if (sprPosition.X < newPosition.X) sprPosition.X += speed.X;
                if (sprPosition.X > newPosition.X) sprPosition.X -= speed.X;
                if (sprPosition.Y < newPosition.Y) sprPosition.Y += speed.Y;
                if (sprPosition.Y > newPosition.Y) sprPosition.Y -= speed.Y;
            }
            //Если предыдущий шаг завершен, переменная хранит 0
            if (stepNumber ==0)
            {
                //Установим случайное количество шагов
                stepNumber = randNum.Next(50, 200);
                //Сгененируем случайную целевую позицию
                newPosition.X = (float)randNum.NextDouble() * (scrBounds.Width - sprRectangle.Width);
                newPosition.Y = (float)randNum.NextDouble() * (scrBounds.Height - sprRectangle.Height);
                //Установим новую скорость
                speed.X = randNum.Next(1, 5);
                speed.Y = randNum.Next(1, 5);
                //Зададим новый цвет спрайта
                sprColor = new Color((byte)randNum.Next(0, 255), (byte)randNum.Next(0, 255), (byte)randNum.Next(0, 255));
 
            }
            //Вызов проверки на допустимость перемещения
            Check();
        }
        //Проверка допустимости перемещения
        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 override void Update(GameTime gameTime)
        {
            //Вызов метода для перемещения спрайта
            Move();
            base.Update(gameTime);
        }
        public override void Draw(GameTime gameTime)
        {
            SpriteBatch sprBatch =
                (SpriteBatch)Game.Services.GetService(typeof(SpriteBatch));
            sprBatch.Draw(sprTexture, sprPosition, sprRectangle, sprColor);
            base.Draw(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

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

    /// This is the main type for your game
    /// 
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;
        Texture2D texture;
        Random randNum;
 
        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
        }
 
        protected override void Initialize()
        {
            // TODO: Add your initialization logic here
 
            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);
            texture = Content.Load<Texture2D>("BallandBats");
            randNum = new Random();
            CreateNewObject();
            // TODO: use this.Content to load your game content here
        }
 
        protected void CreateNewObject()
        {
            //Цикл от 1 до случайного числ в диапазоне 50,200
            for (int i = 0; i < randNum .Next (50,200); i++)
            {
                //Добавляем в список компонентов новый компонент класса spriteComp
                Components.Add(new spriteComp(this, ref texture,
                new Rectangle(16, 203, 17, 17), i));
            }          
        }
 
        protected override void UnloadContent()
        {
        }
 
        protected override void Update(GameTime gameTime)
        {
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();
 
            base.Update(gameTime);
        }
 
        protected override void Draw(GameTime gameTime)
        {
            graphics.GraphicsDevice.Clear(Color.CornflowerBlue);
 
            // TODO: Add your drawing code here
            spriteBatch.Begin();
            base.Draw(gameTime);
            spriteBatch.End();
        }
    }
}