Пишем первую игру на MonoGame

Success: MonoGame.Templates.CSharp::3.8.3 installed the following templates:
Template Name                Short Name         Language  Tags
---------------------------  -----------------  --------  -------------------------------------------------------------
MonoGame 2D StartKit                          mg2dstartkit                [C#]        MonoGame/Games/Mobile/Android/iOS/Desktop/Windows/Linux/macOS
MonoGame Android Application                  mgandroid                   [C#]        MonoGame/Games/Mobile/Android
MonoGame Blank 2D StartKit                    mgblank2dstartkit           [C#]        MonoGame/Games/Mobile/Android/iOS/Desktop/Windows/Linux/macOS
MonoGame Content Pipeline Extension           mgpipeline                  [C#]        MonoGame/Games/Extensions
MonoGame Cross-Platform Desktop Application   mgdesktopgl                 [C#]        MonoGame/Games/Desktop/Windows/Linux/macOS
MonoGame Game Library                         mglib                       [C#]        MonoGame/Games/Library
MonoGame iOS Application                      mgios                       [C#]        MonoGame/Games/Mobile/iOS
MonoGame Shared Library Project               mgshared                    [C#]        MonoGame/Games/Library
MonoGame Windows Desktop Application          mgwindowsdx                 [C#]        MonoGame/Games/Desktop/Windows/Linux/macOS

public class Game1 : Game
{
    private GraphicsDeviceManager _graphics;
    private SpriteBatch _spriteBatch;
 
    public Game1()
    {
        _graphics = new GraphicsDeviceManager(this);
        Content.RootDirectory = "Content";
        IsMouseVisible = true;
    }
 
    protected override void Initialize()
    {
        // TODO: Add your initialization logic here
 
        base.Initialize();
    }
 
    protected override void LoadContent()
    {
        _spriteBatch = new SpriteBatch(GraphicsDevice);
 
        // TODO: use this.Content to load your game content here
    }
 
    protected override void Update(GameTime gameTime)
    {
        if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
            Exit();
 
        // TODO: Add your update logic here
 
        base.Update(gameTime);
    }
 
    protected override void Draw(GameTime gameTime)
    {
        GraphicsDevice.Clear(Color.CornflowerBlue);
 
        // TODO: Add your drawing code here
 
        base.Draw(gameTime);
    }
}

protected override void Initialize()
{
    _graphics.PreferredBackBufferWidth = 1280;
    _graphics.PreferredBackBufferHeight = 720;
    _graphics.ApplyChanges();
    
    base.Initialize();
}

protected override void LoadContent()
{
    _spriteBatch = new SpriteBatch(GraphicsDevice);
    
    _playerTexture = Content.Load<Texture2D>("Player");
    _backgroundTexture = Content.Load<Texture2D>("Background");
    _font = Content.Load<SpriteFont>("GameFont");
    _jumpSound = Content.Load<SoundEffect>("Jump");
}

protected override void UnloadContent()
{
    // Освобождаем ресурсы, созданные вручную
    _manuallyCreatedTexture?.Dispose();
    
    base.UnloadContent();
}

protected override void Update(GameTime gameTime)
{
    // Выход из игры при нажатии Escape
    if (Keyboard.GetState().IsKeyDown(Keys.Escape))
        Exit();
    
    // Вычисляем время, прошедшее с предыдущего кадра (в секундах)
    float deltaTime = (float)gameTime.ElapsedGameTime.TotalSeconds;
    
    // Обновляем позицию игрока
    _playerPosition += _playerVelocity * deltaTime;
    
    // Проверяем коллизии
    if (CheckCollision(_playerPosition, _obstacles))
    {
        _playerVelocity = Vector2.Zero;
        _gameState = GameState.GameOver;
    }
    
    base.Update(gameTime);
}

protected override void Update(GameTime gameTime)
{
    float deltaTime = (float)gameTime.ElapsedGameTime.TotalSeconds;
    
    HandleInput(deltaTime);
    UpdatePhysics(deltaTime);
    CheckCollisions();
    UpdateAnimations(deltaTime);
    UpdateParticles(deltaTime);
    
    base.Update(gameTime);
}

protected override void Draw(GameTime gameTime)
{
    GraphicsDevice.Clear(Color.CornflowerBlue);
    
    _spriteBatch.Begin();
    
    // Рисуем фон
    _spriteBatch.Draw(_backgroundTexture, Vector2.Zero, Color.White);
    
    // Рисуем игрока
    _spriteBatch.Draw(_playerTexture, _playerPosition, null, Color.White, 
                       _playerRotation, _playerOrigin, 1.0f, SpriteEffects.None, 0);
    
    // Рисуем очки
    _spriteBatch.DrawString(_font, $"Score: {_score}", new Vector2(10, 10), Color.White);
    
    _spriteBatch.End();
    
    base.Draw(gameTime);
}

// Установка частоты обновления 30 кадров в секунду
this.TargetElapsedTime = TimeSpan.FromSeconds(1 / 30.0);

// Отключение фиксированного временного шага
this.IsFixedTimeStep = false;

_graphics.SynchronizeWithVerticalRetrace = true; // Включить V-Sync
_graphics.ApplyChanges();

// Плохо: выделение памяти в каждом кадре
protected override void Update(GameTime gameTime)
{
    Vector2 direction = new Vector2(1, 0); // Новый объект в каждом кадре
    _position += direction * 5 * (float)gameTime.ElapsedGameTime.TotalSeconds;
}
 
// Хорошо: переиспользование объектов
private readonly Vector2 _direction = new Vector2(1, 0);
protected override void Update(GameTime gameTime)
{
    _position += _direction * 5 * (float)gameTime.ElapsedGameTime.TotalSeconds;
}

// Только если объект видим на экране
if (IsVisible(_objectPosition, _objectSize))
{
    UpdateObject(gameTime);
    DrawObject();
}

// Лучше так
_spriteBatch.Begin(SpriteSortMode.Texture);
// Рисуем все спрайты с одинаковыми параметрами
_spriteBatch.End();
 
// Чем так
_spriteBatch.Begin();
// Рисуем один спрайт
_spriteBatch.End();
_spriteBatch.Begin();
// Рисуем другой спрайт
_spriteBatch.End();

// В методе LoadContent
_playerTexture = Content.Load<Texture2D>("Player");

protected override void Draw(GameTime gameTime)
{
    GraphicsDevice.Clear(Color.CornflowerBlue);
    
    _spriteBatch.Begin();
    _spriteBatch.Draw(_playerTexture, _playerPosition, Color.White);
    _spriteBatch.End();
    
    base.Draw(gameTime);
}

// Базовая отрисовка в позиции
_spriteBatch.Draw(_texture, _position, Color.White);
 
// Отрисовка с масштабом, вращением и точкой привязки
_spriteBatch.Draw(
    _texture,             // Текстура для отрисовки
    _position,            // Позиция на экране
    null,                 // Прямоугольник для вырезания части текстуры (null = вся текстура)
    Color.White,          // Цветовой фильтр (белый = без изменений)
    _rotation,            // Угол поворота в радианах
    _origin,              // Точка привязки/центр вращения (0,0 = верхний левый угол)
    _scale,               // Масштаб (1.0f = оригинальный размер)
    SpriteEffects.None,   // Эффекты отражения
    0                     // Глубина отрисовки (для сортировки)
);

public class Player
{
    private Texture2D _texture;
    public Vector2 Position { get; set; }
    public float Rotation { get; set; }
    public Vector2 Velocity { get; set; }
    
    public Player(Texture2D texture, Vector2 position)
    {
        _texture = texture;
        Position = position;
        Velocity = Vector2.Zero;
    }
    
    public void Update(GameTime gameTime)
    {
        float deltaTime = (float)gameTime.ElapsedGameTime.TotalSeconds;
        Position += Velocity * deltaTime;
    }
    
    public void Draw(SpriteBatch spriteBatch)
    {
        spriteBatch.Draw(_texture, Position, null, Color.White, Rotation, 
                          new Vector2(_texture.Width / 2, _texture.Height / 2), 
                          1.0f, SpriteEffects.None, 0);
    }
}

private Player _player;
 
protected override void LoadContent()
{
    _spriteBatch = new SpriteBatch(GraphicsDevice);
    Texture2D playerTexture = Content.Load<Texture2D>("Player");
    _player = new Player(playerTexture, new Vector2(100, 100));
}
 
protected override void Update(GameTime gameTime)
{
    if (Keyboard.GetState().IsKeyDown(Keys.Escape))
        Exit();
    
    _player.Update(gameTime);
    
    base.Update(gameTime);
}
 
protected override void Draw(GameTime gameTime)
{
    GraphicsDevice.Clear(Color.CornflowerBlue);
    
    _spriteBatch.Begin();
    _player.Draw(_spriteBatch);
    _spriteBatch.End();
    
    base.Draw(gameTime);
}

public void HandleInput(KeyboardState keyboardState, float deltaTime)
{
    // Сбрасываем скорость
    Velocity = Vector2.Zero;
    
    // Проверяем нажатия клавиш и устанавливаем скорость
    if (keyboardState.IsKeyDown(Keys.W) || keyboardState.IsKeyDown(Keys.Up))
        Velocity.Y = -200; // Движение вверх
        
    if (keyboardState.IsKeyDown(Keys.S) || keyboardState.IsKeyDown(Keys.Down))
        Velocity.Y = 200; // Движение вниз
        
    if (keyboardState.IsKeyDown(Keys.A) || keyboardState.IsKeyDown(Keys.Left))
        Velocity.X = -200; // Движение влево
        
    if (keyboardState.IsKeyDown(Keys.D) || keyboardState.IsKeyDown(Keys.Right))
        Velocity.X = 200; // Движение вправо
        
    // Нормализуем вектор, чтобы диагональное движение не было быстрее
    if (Velocity != Vector2.Zero)
        Velocity = Vector2.Normalize(Velocity) * 200;
}

protected override void Update(GameTime gameTime)
{
    float deltaTime = (float)gameTime.ElapsedGameTime.TotalSeconds;
    KeyboardState keyboardState = Keyboard.GetState();
    
    if (keyboardState.IsKeyDown(Keys.Escape))
        Exit();
    
    _player.HandleInput(keyboardState, deltaTime);
    _player.Update(gameTime);
    
    base.Update(gameTime);
}

MouseState mouseState = Mouse.GetState();
Vector2 mousePosition = new Vector2(mouseState.X, mouseState.Y);
 
// Поворачиваем игрока в сторону мыши
Vector2 direction = mousePosition - _player.Position;
_player.Rotation = (float)Math.Atan2(direction.Y, direction.X);
 
// Проверяем нажатия кнопок мыши
if (mouseState.LeftButton == ButtonState.Pressed)
{
    // Выстрел или другое действие
}

private KeyboardState _previousKeyboardState;
 
protected override void Update(GameTime gameTime)
{
    KeyboardState currentKeyboardState = Keyboard.GetState();
    
    // Проверка, была ли клавиша нажата в этом кадре
    if (currentKeyboardState.IsKeyDown(Keys.Space) && 
        !_previousKeyboardState.IsKeyDown(Keys.Space))
    {
        // Действие при нажатии пробела
    }
    
    _previousKeyboardState = currentKeyboardState;
    
    base.Update(gameTime);
}

// Загрузка звука
SoundEffect jumpSound = Content.Load<SoundEffect>("Jump");
SoundEffectInstance jumpSoundInstance = jumpSound.CreateInstance();
 
// Воспроизведение один раз
jumpSound.Play();
 
// Или с настройками громкости, панорамы и высоты тона
jumpSound.Play(0.5f, 0.0f, 0.0f); // Громкость 50%, центр, нормальная высота
 
// Для более сложного управления используйте экземпляр
jumpSoundInstance.Volume = 0.7f;
jumpSoundInstance.IsLooped = false;
jumpSoundInstance.Play();
 
// Остановка звука
jumpSoundInstance.Stop();

// Загрузка музыки
Song backgroundMusic = Content.Load<Song>("Music/Background");
 
// Воспроизведение
MediaPlayer.Play(backgroundMusic);
MediaPlayer.IsRepeating = true;
MediaPlayer.Volume = 0.5f;
 
// Остановка
MediaPlayer.Stop();

public class Animation
{
    private Texture2D _spritesheet;
    private readonly Rectangle[] _frames;
    private int _currentFrame;
    private float _timePerFrame;
    private float _timer;
    public bool IsLooping { get; set; } = true;
    public bool IsFinished { get; private set; }
 
    public Animation(Texture2D spritesheet, int frameCount, int frameWidth, int frameHeight, float fps)
    {
        _spritesheet = spritesheet;
        _frames = new Rectangle[frameCount];
        _timePerFrame = 1f / fps;
        
        // Создаем прямоугольники для каждого кадра
        for (int i = 0; i < frameCount; i++)
        {
            _frames[i] = new Rectangle(i * frameWidth, 0, frameWidth, frameHeight);
        }
    }
 
    public void Update(float deltaTime)
    {
        if (IsFinished) return;
        
        _timer += deltaTime;
        
        if (_timer >= _timePerFrame)
        {
            _currentFrame++;
            _timer = 0;
            
            if (_currentFrame >= _frames.Length)
            {
                if (IsLooping)
                    _currentFrame = 0;
                else
                {
                    _currentFrame = _frames.Length - 1;
                    IsFinished = true;
                }
            }
        }
    }
 
    public void Draw(SpriteBatch spriteBatch, Vector2 position, Color color)
    {
        spriteBatch.Draw(_spritesheet, position, _frames[_currentFrame], color);
    }
    
    public void Reset()
    {
        _currentFrame = 0;
        _timer = 0;
        IsFinished = false;
    }
}

// Загружаем спрайтшит
Texture2D runSpritesheet = Content.Load<Texture2D>("RunAnimation");
 
// Создаем анимацию бега (8 кадров по 64x64 пикселя, 12 FPS)
Animation runAnimation = new Animation(runSpritesheet, 8, 64, 64, 12);
 
// В методе Update
runAnimation.Update((float)gameTime.ElapsedGameTime.TotalSeconds);
 
// В методе Draw
runAnimation.Draw(_spriteBatch, _playerPosition, Color.White);

private Dictionary<string, Animation> _animations = new Dictionary<string, Animation>();
private string _currentAnimation = "idle";
 
// В LoadContent
_animations["idle"] = new Animation(Content.Load<Texture2D>("IdleAnimation"), 4, 64, 64, 8);
_animations["run"] = new Animation(Content.Load<Texture2D>("RunAnimation"), 8, 64, 64, 12);
_animations["jump"] = new Animation(Content.Load<Texture2D>("JumpAnimation"), 6, 64, 64, 10);
_animations["jump"].IsLooping = false;  // Прыжок проиграется только один раз
 
// В Update
_animations[_currentAnimation].Update(deltaTime);
 
// Для смены анимации
public void SetAnimation(string animName)
{
    if (_currentAnimation != animName)
    {
        _currentAnimation = animName;
        _animations[_currentAnimation].Reset();
    }
}

public enum GameState
{
    MainMenu,
    Playing,
    Paused,
    GameOver
}
 
private GameState _currentState = GameState.MainMenu;
 
protected override void Update(GameTime gameTime)
{
    switch (_currentState)
    {
        case GameState.MainMenu:
            UpdateMainMenu(gameTime);
            break;
        case GameState.Playing:
            UpdateGameplay(gameTime);
            break;
        case GameState.Paused:
            UpdatePaused(gameTime);
            break;
        case GameState.GameOver:
            UpdateGameOver(gameTime);
            break;
    }
    
    base.Update(gameTime);
}
 
protected override void Draw(GameTime gameTime)
{
    GraphicsDevice.Clear(Color.CornflowerBlue);
    
    _spriteBatch.Begin();
    
    switch (_currentState)
    {
        case GameState.MainMenu:
            DrawMainMenu();
            break;
        case GameState.Playing:
            DrawGameplay();
            break;
        case GameState.Paused:
            DrawGameplay();  // Рисуем игру на заднем фоне
            DrawPaused();    // Рисуем паузу поверх
            break;
        case GameState.GameOver:
            DrawGameplay();  // Показываем где умер
            DrawGameOver();
            break;
    }
    
    _spriteBatch.End();
    
    base.Draw(gameTime);
}

public abstract class GameScreen
{
    public bool IsActive { get; set; } = true;
    
    public abstract void Update(GameTime gameTime);
    public abstract void Draw(SpriteBatch spriteBatch);
    
    public virtual void OnEnter() { }
    public virtual void OnExit() { }
}
 
public class ScreenManager
{
    private Stack<GameScreen> _screens = new Stack<GameScreen>();
    
    public void PushScreen(GameScreen screen)
    {
        if (_screens.Count > 0)
            _screens.Peek().IsActive = false;
            
        _screens.Push(screen);
        screen.OnEnter();
    }
    
    public void PopScreen()
    {
        if (_screens.Count > 0)
        {
            GameScreen screen = _screens.Pop();
            screen.OnExit();
            
            if (_screens.Count > 0)
                _screens.Peek().IsActive = true;
        }
    }
    
    public void Update(GameTime gameTime)
    {
        if (_screens.Count > 0 && _screens.Peek().IsActive)
            _screens.Peek().Update(gameTime);
    }
    
    public void Draw(SpriteBatch spriteBatch)
    {
        // Рисуем все экраны, начиная с нижнего
        foreach (var screen in _screens.Reverse())
        {
            screen.Draw(spriteBatch);
        }
    }
}

public bool Intersects(Rectangle rectA, Rectangle rectB)
{
    return rectA.X < rectB.X + rectB.Width &&
           rectA.X + rectA.Width > rectB.X &&
           rectA.Y < rectB.Y + rectB.Height &&
           rectA.Y + rectA.Height > rectB.Y;
}

public bool Intersects(Vector2 centerA, float radiusA, Vector2 centerB, float radiusB)
{
    float distance = Vector2.Distance(centerA, centerB);
    return distance < radiusA + radiusB;
}

public Rectangle GetBounds()
{
    return new Rectangle(
        (int)(Position.X - Origin.X * Scale),
        (int)(Position.Y - Origin.Y * Scale),
        (int)(Texture.Width * Scale),
        (int)(Texture.Height * Scale)
    );
}

if (_player.GetBounds().Intersects(_enemy.GetBounds()))
{
    // Произошло столкновение!
}

// Константы физики
private const float Gravity = 800f;
private const float JumpForce = -400f;
private bool _isGrounded = false;
 
// В Update
public void Update(GameTime gameTime)
{
    float deltaTime = (float)gameTime.ElapsedGameTime.TotalSeconds;
    
    // Применяем гравитацию
    Velocity.Y += Gravity * deltaTime;
    
    // Обновляем позицию
    Position += Velocity * deltaTime;
    
    // Проверяем столкновения с землей
    _isGrounded = false;
    foreach (var platform in _platforms)
    {
        if (GetBounds().Intersects(platform.GetBounds()))
        {
            // Мы столкнулись с платформой
            // Восстанавливаем позицию
            Position = new Vector2(Position.X, platform.Position.Y - Texture.Height);
            
            // Останавливаем падение
            Velocity.Y = 0;
            _isGrounded = true;
        }
    }
    
    // Прыжок по нажатию пробела
    if (_isGrounded && Keyboard.GetState().IsKeyDown(Keys.Space))
    {
        Velocity.Y = JumpForce;
        _isGrounded = false;
    }
}

public class Game1 : Game
{
    private GraphicsDeviceManager _graphics;
    private SpriteBatch _spriteBatch;
    
    private Player _player;
    private List<Square> _squares;
    private ScoreManager _scoreManager;
    private ParticleSystem _particleSystem;
    
    private Texture2D _squareTexture;
    private Texture2D _playerTexture;
    private SpriteFont _font;
    private SoundEffect _catchSound;
    private SoundEffect _missSound;
    
    private Random _random;
    private float _squareSpawnTimer;
    private float _squareSpawnDelay = 2.0f; // Начальная задержка 2 секунды
    private int _missedSquares;
    private int _maxMissedSquares = 5;
    private GameState _gameState = GameState.Playing;
    
    public enum GameState
    {
        Playing,
        GameOver
    }
    
    public Game1()
    {
        _graphics = new GraphicsDeviceManager(this);
        Content.RootDirectory = "Content";
        IsMouseVisible = true;
        
        _graphics.PreferredBackBufferWidth = 800;
        _graphics.PreferredBackBufferHeight = 600;
    }
 
    // Остальные методы добавим ниже
}

protected override void LoadContent()
{
    _spriteBatch = new SpriteBatch(GraphicsDevice);
    
    // Создаем текстуру квадрата 32x32 пикселя
    _squareTexture = new Texture2D(GraphicsDevice, 32, 32);
    Color[] data = new Color[32 * 32];
    for (int i = 0; i < data.Length; i++)
        data[i] = Color.White; // Белый цвет, который мы будем тонировать при отрисовке
    _squareTexture.SetData(data);
    
    // Создаем текстуру платформы 128x16 пикселей
    _playerTexture = new Texture2D(GraphicsDevice, 128, 16);
    data = new Color[128 * 16];
    for (int i = 0; i < data.Length; i++)
        data[i] = Color.White;
    _playerTexture.SetData(data);
    
    // Загружаем шрифт (предполагается, что он уже добавлен в контент)
    _font = Content.Load<SpriteFont>("Font");
    
    // Загружаем звуки (предполагается, что они уже добавлены в контент)
    _catchSound = Content.Load<SoundEffect>("Catch");
    _missSound = Content.Load<SoundEffect>("Miss");
    
    // Инициализируем игровые объекты
    _random = new Random();
    _squares = new List<Square>();
    _player = new Player(_playerTexture, new Vector2(_graphics.PreferredBackBufferWidth / 2, _graphics.PreferredBackBufferHeight - 30));
    _scoreManager = new ScoreManager(_font);
    _particleSystem = new ParticleSystem(GraphicsDevice);
}

public class Player
{
    public Vector2 Position { get; set; }
    public Texture2D Texture { get; private set; }
    public float Speed { get; set; } = 400f;
    public Rectangle Bounds => new Rectangle((int)Position.X - Texture.Width / 2, (int)Position.Y - Texture.Height / 2, Texture.Width, Texture.Height);
    
    public Player(Texture2D texture, Vector2 position)
    {
        Texture = texture;
        Position = position;
    }
    
    public void Update(GameTime gameTime, int screenWidth)
    {
        float deltaTime = (float)gameTime.ElapsedGameTime.TotalSeconds;
        KeyboardState keyboardState = Keyboard.GetState();
        
        // Перемещение влево/вправо
        if (keyboardState.IsKeyDown(Keys.Left) || keyboardState.IsKeyDown(Keys.A))
            Position.X -= Speed * deltaTime;
        if (keyboardState.IsKeyDown(Keys.Right) || keyboardState.IsKeyDown(Keys.D))
            Position.X += Speed * deltaTime;
        
        // Ограничиваем движение экраном
        Position.X = Math.Clamp(Position.X, Texture.Width / 2, screenWidth - Texture.Width / 2);
    }
    
    public void Draw(SpriteBatch spriteBatch)
    {
        spriteBatch.Draw(Texture, Position, null, Color.LightBlue, 0f, new Vector2(Texture.Width / 2, Texture.Height / 2), 1f, SpriteEffects.None, 0f);
    }
}

public class Square
{
    public Vector2 Position { get; set; }
    public Vector2 Velocity { get; set; }
    public Color Color { get; set; }
    public Texture2D Texture { get; private set; }
    public bool IsActive { get; set; } = true;
    public Rectangle Bounds => new Rectangle((int)Position.X - Texture.Width / 2, (int)Position.Y - Texture.Height / 2, Texture.Width, Texture.Height);
    
    public Square(Texture2D texture, Vector2 position, Vector2 velocity, Color color)
    {
        Texture = texture;
        Position = position;
        Velocity = velocity;
        Color = color;
    }
    
    public void Update(GameTime gameTime)
    {
        float deltaTime = (float)gameTime.ElapsedGameTime.TotalSeconds;
        Position += Velocity * deltaTime;
    }
    
    public void Draw(SpriteBatch spriteBatch)
    {
        if (IsActive)
            spriteBatch.Draw(Texture, Position, null, Color, 0f, new Vector2(Texture.Width / 2, Texture.Height / 2), 1f, SpriteEffects.None, 0f);
    }
}

public class ScoreManager
{
    public int Score { get; private set; }
    public int Level => Math.Max(1, Score / 10 + 1); // Каждые 10 очков - новый уровень
    private SpriteFont _font;
    
    public ScoreManager(SpriteFont font)
    {
        _font = font;
        Score = 0;
    }
    
    public void AddScore(int points)
    {
        Score += points;
    }
    
    public void Draw(SpriteBatch spriteBatch, int screenWidth)
    {
        string scoreText = $"Очки: {Score}";
        string levelText = $"Уровень: {Level}";
        
        spriteBatch.DrawString(_font, scoreText, new Vector2(10, 10), Color.White);
        spriteBatch.DrawString(_font, levelText, new Vector2(screenWidth - _font.MeasureString(levelText).X - 10, 10), Color.White);
    }
}

public class ParticleSystem
{
    private struct Particle
    {
        public Vector2 Position;
        public Vector2 Velocity;
        public Color Color;
        public float Size;
        public float Lifetime;
        public float Age;
    }
    
    private List<Particle> _particles = new List<Particle>();
    private Texture2D _particleTexture;
    private Random _random = new Random();
    
    public ParticleSystem(GraphicsDevice graphicsDevice)
    {
        // Создаем одно-пиксельную текстуру для частиц
        _particleTexture = new Texture2D(graphicsDevice, 1, 1);
        _particleTexture.SetData(new[] { Color.White });
    }
    
    public void AddParticles(Vector2 position, Color color, int count)
    {
        for (int i = 0; i < count; i++)
        {
            _particles.Add(new Particle
            {
                Position = position,
                Velocity = new Vector2(
                    (float)(_random.NextDouble() * 2 - 1) * 100,
                    (float)(_random.NextDouble() * 2 - 1) * 100
                ),
                Color = color,
                Size = (float)_random.NextDouble() * 5 + 1,
                Lifetime = (float)_random.NextDouble() * 0.5f + 0.5f,
                Age = 0
            });
        }
    }
    
    public void Update(GameTime gameTime)
    {
        float deltaTime = (float)gameTime.ElapsedGameTime.TotalSeconds;
        
        for (int i = _particles.Count - 1; i >= 0; i--)
        {
            Particle particle = _particles[i];
            particle.Age += deltaTime;
            
            if (particle.Age >= particle.Lifetime)
            {
                _particles.RemoveAt(i);
                continue;
            }
            
            particle.Position += particle.Velocity * deltaTime;
            particle.Velocity *= 0.97f; // Небольшое замедление
            _particles[i] = particle;
        }
    }
    
    public void Draw(SpriteBatch spriteBatch)
    {
        foreach (var particle in _particles)
        {
            float alpha = 1f - (particle.Age / particle.Lifetime);
            Color color = particle.Color * alpha;
            
            spriteBatch.Draw(
                _particleTexture,
                particle.Position,
                null,
                color,
                0f,
                Vector2.Zero,
                particle.Size,
                SpriteEffects.None,
                0f
            );
        }
    }
}

protected override void Update(GameTime gameTime)
{
    if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
        Exit();
 
    float deltaTime = (float)gameTime.ElapsedGameTime.TotalSeconds;
    
    if (_gameState == GameState.Playing)
    {
        // Обновляем игрока
        _player.Update(gameTime, _graphics.PreferredBackBufferWidth);
        
        // Обновляем существующие квадраты
        for (int i = _squares.Count - 1; i >= 0; i--)
        {
            _squares[i].Update(gameTime);
            
            // Проверка коллизий с игроком
            if (_squares[i].Bounds.Intersects(_player.Bounds) && _squares[i].IsActive)
            {
                _squares[i].IsActive = false;
                _scoreManager.AddScore(1);
                _catchSound.Play(0.5f, 0, 0);
                _particleSystem.AddParticles(_squares[i].Position, _squares[i].Color, 20);
                _squares.RemoveAt(i);
                continue;
            }
            
            // Проверка, не упал ли квадрат за пределы экрана
            if (_squares[i].Position.Y > _graphics.PreferredBackBufferHeight + 20)
            {
                _squares.RemoveAt(i);
                _missedSquares++;
                _missSound.Play(0.5f, 0, 0);
                
                if (_missedSquares >= _maxMissedSquares)
                    _gameState = GameState.GameOver;
            }
        }
        
        // Генерация новых квадратов
        _squareSpawnTimer += deltaTime;
        if (_squareSpawnTimer >= _squareSpawnDelay)
        {
            _squareSpawnTimer = 0;
            
            // С каждым уровнем квадраты падают быстрее и чаще
            _squareSpawnDelay = Math.Max(0.5f, 2.0f - (_scoreManager.Level - 1) * 0.1f);
            
            // Создаем квадрат в случайной позиции с случайным цветом
            float x = (float)_random.NextDouble() * (_graphics.PreferredBackBufferWidth - 50) + 25;
            Vector2 position = new Vector2(x, -20);
            Vector2 velocity = new Vector2(0, 100 + _scoreManager.Level * 20);
            
            Color color = new Color(
                (float)_random.NextDouble(),
                (float)_random.NextDouble(),
                (float)_random.NextDouble()
            );
            
            _squares.Add(new Square(_squareTexture, position, velocity, color));
        }
    }
    else if (_gameState == GameState.GameOver)
    {
        // Проверка нажатия для рестарта
        if (Keyboard.GetState().IsKeyDown(Keys.R))
            RestartGame();
    }
    
    // Обновляем систему частиц в любом случае
    _particleSystem.Update(gameTime);
    
    base.Update(gameTime);
}
 
protected override void Draw(GameTime gameTime)
{
    GraphicsDevice.Clear(Color.Black);
    
    _spriteBatch.Begin();
    
    // Рисуем игровые объекты
    foreach (var square in _squares)
        square.Draw(_spriteBatch);
    
    _player.Draw(_spriteBatch);
    _particleSystem.Draw(_spriteBatch);
    
    // Рисуем интерфейс
    _scoreManager.Draw(_spriteBatch, _graphics.PreferredBackBufferWidth);
    
    // Отображаем пропущенные квадраты
    string missedText = $"Пропущено: {_missedSquares}/{_maxMissedSquares}";
    _spriteBatch.DrawString(_font, missedText, new Vector2(10, 40), Color.White);
    
    // Если игра окончена, показываем сообщение
    if (_gameState == GameState.GameOver)
    {
        string gameOverText = "ИГРА ОКОНЧЕНА";
        string restartText = "Нажмите R для рестарта";
        
        Vector2 gameOverSize = _font.MeasureString(gameOverText);
        Vector2 restartSize = _font.MeasureString(restartText);
        
        _spriteBatch.DrawString(_font, gameOverText,
            new Vector2(_graphics.PreferredBackBufferWidth / 2 - gameOverSize.X / 2,
                        _graphics.PreferredBackBufferHeight / 2 - gameOverSize.Y),
            Color.Red, 0, Vector2.Zero, 2f, SpriteEffects.None, 0);
            
        _spriteBatch.DrawString(_font, restartText,
            new Vector2(_graphics.PreferredBackBufferWidth / 2 - restartSize.X / 2,
                        _graphics.PreferredBackBufferHeight / 2 + 50),
            Color.White);
    }
    
    _spriteBatch.End();
    
    base.Draw(gameTime);
}
 
private void RestartGame()
{
    _squares.Clear();
    _missedSquares = 0;
    _scoreManager = new ScoreManager(_font);
    _squareSpawnTimer = 0;
    _squareSpawnDelay = 2.0f;
    _gameState = GameState.Playing;
}

CatchTheSquare/
├── Content/
│   ├── Content.mgcb    # Файл контент-менеджера
│   ├── Font.spritefont # Шрифт для текста
│   ├── Catch.wav       # Звук при ловле квадрата
│   └── Miss.wav        # Звук при пропуске квадрата
├── Game1.cs            # Основной класс игры
├── Player.cs           # Класс платформы игрока
├── Square.cs           # Класс падающих квадратов
├── ScoreManager.cs     # Управление очками
├── ParticleSystem.cs   # Система частиц
└── Program.cs          # Точка входа в приложение

using System;
 
namespace CatchTheSquare
{
    public static class Program
    {
        [STAThread]
        static void Main()
        {
            using (var game = new Game1())
                game.Run();
        }
    }
}

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using System;
 
namespace CatchTheSquare
{
    public class Player
    {
        public Vector2 Position { get; set; }
        public Texture2D Texture { get; private set; }
        public float Speed { get; set; } = 400f;
        public Rectangle Bounds => new Rectangle(
            (int)Position.X - Texture.Width / 2, 
            (int)Position.Y - Texture.Height / 2, 
            Texture.Width, 
            Texture.Height);
        
        public Player(Texture2D texture, Vector2 position)
        {
            Texture = texture;
            Position = position;
        }
        
        public void Update(GameTime gameTime, int screenWidth)
        {
            float deltaTime = (float)gameTime.ElapsedGameTime.TotalSeconds;
            KeyboardState keyboardState = Keyboard.GetState();
            
            // Перемещение влево/вправо
            if (keyboardState.IsKeyDown(Keys.Left) || keyboardState.IsKeyDown(Keys.A))
                Position.X -= Speed * deltaTime;
            if (keyboardState.IsKeyDown(Keys.Right) || keyboardState.IsKeyDown(Keys.D))
                Position.X += Speed * deltaTime;
            
            // Ограничиваем движение экраном
            Position.X = Math.Clamp(Position.X, Texture.Width / 2, screenWidth - Texture.Width / 2);
        }
        
        public void Draw(SpriteBatch spriteBatch)
        {
            spriteBatch.Draw(
                Texture, 
                Position, 
                null, 
                Color.LightBlue, 
                0f, 
                new Vector2(Texture.Width / 2, Texture.Height / 2), 
                1f, 
                SpriteEffects.None, 
                0f);
        }
    }
}

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
 
namespace CatchTheSquare
{
    public class Square
    {
        public Vector2 Position { get; set; }
        public Vector2 Velocity { get; set; }
        public Color Color { get; set; }
        public Texture2D Texture { get; private set; }
        public bool IsActive { get; set; } = true;
        
        public Rectangle Bounds => new Rectangle(
            (int)Position.X - Texture.Width / 2, 
            (int)Position.Y - Texture.Height / 2, 
            Texture.Width, 
            Texture.Height);
        
        public Square(Texture2D texture, Vector2 position, Vector2 velocity, Color color)
        {
            Texture = texture;
            Position = position;
            Velocity = velocity;
            Color = color;
        }
        
        public void Update(GameTime gameTime)
        {
            float deltaTime = (float)gameTime.ElapsedGameTime.TotalSeconds;
            Position += Velocity * deltaTime;
        }
        
        public void Draw(SpriteBatch spriteBatch)
        {
            if (IsActive)
                spriteBatch.Draw(
                    Texture, 
                    Position, 
                    null, 
                    Color, 
                    0f, 
                    new Vector2(Texture.Width / 2, Texture.Height / 2), 
                    1f, 
                    SpriteEffects.None, 
                    0f);
        }
    }
}

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using System;
 
namespace CatchTheSquare
{
    public class ScoreManager
    {
        public int Score { get; private set; }
        public int Level => Math.Max(1, Score / 10 + 1); // Каждые 10 очков - новый уровень
        private SpriteFont _font;
        
        public ScoreManager(SpriteFont font)
        {
            _font = font;
            Score = 0;
        }
        
        public void AddScore(int points)
        {
            Score += points;
        }
        
        public void Draw(SpriteBatch spriteBatch, int screenWidth)
        {
            string scoreText = $"Очки: {Score}";
            string levelText = $"Уровень: {Level}";
            
            spriteBatch.DrawString(_font, scoreText, new Vector2(10, 10), Color.White);
            spriteBatch.DrawString(
                _font, 
                levelText, 
                new Vector2(screenWidth - _font.MeasureString(levelText).X - 10, 10), 
                Color.White);
        }
    }
}

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using System;
using System.Collections.Generic;
 
namespace CatchTheSquare
{
    public class ParticleSystem
    {
        private struct Particle
        {
            public Vector2 Position;
            public Vector2 Velocity;
            public Color Color;
            public float Size;
            public float Lifetime;
            public float Age;
        }
        
        private List<Particle> _particles = new List<Particle>();
        private Texture2D _particleTexture;
        private Random _random = new Random();
        
        public ParticleSystem(GraphicsDevice graphicsDevice)
        {
            // Создаем одно-пиксельную текстуру для частиц
            _particleTexture = new Texture2D(graphicsDevice, 1, 1);
            _particleTexture.SetData(new[] { Color.White });
        }
        
        public void AddParticles(Vector2 position, Color color, int count)
        {
            for (int i = 0; i < count; i++)
            {
                _particles.Add(new Particle
                {
                    Position = position,
                    Velocity = new Vector2(
                        (float)(_random.NextDouble() * 2 - 1) * 100,
                        (float)(_random.NextDouble() * 2 - 1) * 100
                    ),
                    Color = color,
                    Size = (float)_random.NextDouble() * 5 + 1,
                    Lifetime = (float)_random.NextDouble() * 0.5f + 0.5f,
                    Age = 0
                });
            }
        }
        
        public void Update(GameTime gameTime)
        {
            float deltaTime = (float)gameTime.ElapsedGameTime.TotalSeconds;
            
            for (int i = _particles.Count - 1; i >= 0; i--)
            {
                Particle particle = _particles[i];
                particle.Age += deltaTime;
                
                if (particle.Age >= particle.Lifetime)
                {
                    _particles.RemoveAt(i);
                    continue;
                }
                
                particle.Position += particle.Velocity * deltaTime;
                particle.Velocity *= 0.97f; // Небольшое замедление
                _particles[i] = particle;
            }
        }
        
        public void Draw(SpriteBatch spriteBatch)
        {
            foreach (var particle in _particles)
            {
                float alpha = 1f - (particle.Age / particle.Lifetime);
                Color color = particle.Color * alpha;
                
                spriteBatch.Draw(
                    _particleTexture,
                    particle.Position,
                    null,
                    color,
                    0f,
                    Vector2.Zero,
                    particle.Size,
                    SpriteEffects.None,
                    0f
                );
            }
        }
    }
}

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using System;
using System.Collections.Generic;
 
namespace CatchTheSquare
{
    public class Game1 : Game
    {
        private GraphicsDeviceManager _graphics;
        private SpriteBatch _spriteBatch;
        
        private Player _player;
        private List<Square> _squares;
        private ScoreManager _scoreManager;
        private ParticleSystem _particleSystem;
        
        private Texture2D _squareTexture;
        private Texture2D _playerTexture;
        private SpriteFont _font;
        private SoundEffect _catchSound;
        private SoundEffect _missSound;
        
        private Random _random;
        private float _squareSpawnTimer;
        private float _squareSpawnDelay = 2.0f; // Начальная задержка 2 секунды
        private int _missedSquares;
        private int _maxMissedSquares = 5;
        private GameState _gameState = GameState.Playing;
        
        public enum GameState
        {
            Playing,
            GameOver
        }
        
        public Game1()
        {
            _graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
            IsMouseVisible = true;
            
            _graphics.PreferredBackBufferWidth = 800;
            _graphics.PreferredBackBufferHeight = 600;
            _graphics.ApplyChanges();
        }
        
        protected override void Initialize()
        {
            base.Initialize();
        }
        
        protected override void LoadContent()
        {
            _spriteBatch = new SpriteBatch(GraphicsDevice);
            
            // Создаем текстуру квадрата 32x32 пикселя
            _squareTexture = new Texture2D(GraphicsDevice, 32, 32);
            Color[] data = new Color[32 * 32];
            for (int i = 0; i < data.Length; i++)
                data[i] = Color.White; // Белый цвет, который мы будем тонировать при отрисовке
            _squareTexture.SetData(data);
            
            // Создаем текстуру платформы 128x16 пикселей
            _playerTexture = new Texture2D(GraphicsDevice, 128, 16);
            data = new Color[128 * 16];
            for (int i = 0; i < data.Length; i++)
                data[i] = Color.White;
            _playerTexture.SetData(data);
            
            // Загружаем шрифт
            _font = Content.Load<SpriteFont>("Font");
            
            // Загружаем звуки
            _catchSound = Content.Load<SoundEffect>("Catch");
            _missSound = Content.Load<SoundEffect>("Miss");
            
            // Инициализируем игровые объекты
            _random = new Random();
            _squares = new List<Square>();
            _player = new Player(_playerTexture, new Vector2(_graphics.PreferredBackBufferWidth / 2, _graphics.PreferredBackBufferHeight - 30));
            _scoreManager = new ScoreManager(_font);
            _particleSystem = new ParticleSystem(GraphicsDevice);
        }
        
        protected override void Update(GameTime gameTime)
        {
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || 
                Keyboard.GetState().IsKeyDown(Keys.Escape))
                Exit();
            
            float deltaTime = (float)gameTime.ElapsedGameTime.TotalSeconds;
            
            if (_gameState == GameState.Playing)
            {
                // Обновляем игрока
                _player.Update(gameTime, _graphics.PreferredBackBufferWidth);
                
                // Обновляем существующие квадраты
                for (int i = _squares.Count - 1; i >= 0; i--)
                {
                    _squares[i].Update(gameTime);
                    
                    // Проверка коллизий с игроком
                    if (_squares[i].Bounds.Intersects(_player.Bounds) && _squares[i].IsActive)
                    {
                        _squares[i].IsActive = false;
                        _scoreManager.AddScore(1);
                        _catchSound.Play(0.5f, 0, 0);
                        _particleSystem.AddParticles(_squares[i].Position, _squares[i].Color, 20);
                        _squares.RemoveAt(i);
                        continue;
                    }
                    
                    // Проверка, не упал ли квадрат за пределы экрана
                    if (_squares[i].Position.Y > _graphics.PreferredBackBufferHeight + 20)
                    {
                        _squares.RemoveAt(i);
                        _missedSquares++;
                        _missSound.Play(0.5f, 0, 0);
                        
                        if (_missedSquares >= _maxMissedSquares)
                            _gameState = GameState.GameOver;
                    }
                }
                
                // Генерация новых квадратов
                _squareSpawnTimer += deltaTime;
                if (_squareSpawnTimer >= _squareSpawnDelay)
                {
                    _squareSpawnTimer = 0;
                    
                    // С каждым уровнем квадраты падают быстрее и чаще
                    _squareSpawnDelay = Math.Max(0.5f, 2.0f - (_scoreManager.Level - 1) * 0.1f);
                    
                    // Создаем квадрат в случайной позиции с случайным цветом
                    float x = (float)_random.NextDouble() * (_graphics.PreferredBackBufferWidth - 50) + 25;
                    Vector2 position = new Vector2(x, -20);
                    Vector2 velocity = new Vector2(0, 100 + _scoreManager.Level * 20);
                    
                    Color color = new Color(
                        (float)_random.NextDouble(),
                        (float)_random.NextDouble(),
                        (float)_random.NextDouble()
                    );
                    
                    _squares.Add(new Square(_squareTexture, position, velocity, color));
                }
            }
            else if (_gameState == GameState.GameOver)
            {
                // Проверка нажатия для рестарта
                if (Keyboard.GetState().IsKeyDown(Keys.R))
                    RestartGame();
            }
            
            // Обновляем систему частиц в любом случае
            _particleSystem.Update(gameTime);
            
            base.Update(gameTime);
        }
        
        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.Black);
            
            _spriteBatch.Begin();
            
            // Рисуем игровые объекты
            foreach (var square in _squares)
                square.Draw(_spriteBatch);
            
            _player.Draw(_spriteBatch);
            _particleSystem.Draw(_spriteBatch);
            
            // Рисуем интерфейс
            _scoreManager.Draw(_spriteBatch, _graphics.PreferredBackBufferWidth);
            
            // Отображаем пропущенные квадраты
            string missedText = $"Пропущено: {_missedSquares}/{_maxMissedSquares}";
            _spriteBatch.DrawString(_font, missedText, new Vector2(10, 40), Color.White);
            
            // Если игра окончена, показываем сообщение
            if (_gameState == GameState.GameOver)
            {
                string gameOverText = "ИГРА ОКОНЧЕНА";
                string restartText = "Нажмите R для рестарта";
                
                Vector2 gameOverSize = _font.MeasureString(gameOverText);
                Vector2 restartSize = _font.MeasureString(restartText);
                
                _spriteBatch.DrawString(_font, gameOverText,
                    new Vector2(_graphics.PreferredBackBufferWidth / 2 - gameOverSize.X / 2,
                                _graphics.PreferredBackBufferHeight / 2 - gameOverSize.Y),
                    Color.Red, 0, Vector2.Zero, 2f, SpriteEffects.None, 0);
                    
                _spriteBatch.DrawString(_font, restartText,
                    new Vector2(_graphics.PreferredBackBufferWidth / 2 - restartSize.X / 2,
                                _graphics.PreferredBackBufferHeight / 2 + 50),
                    Color.White);
            }
            
            _spriteBatch.End();
            
            base.Draw(gameTime);
        }
        
        private void RestartGame()
        {
            _squares.Clear();
            _missedSquares = 0;
            _scoreManager = new ScoreManager(_font);
            _squareSpawnTimer = 0;
            _squareSpawnDelay = 2.0f;
            _gameState = GameState.Playing;
        }
    }
}

public class SquareFactory
{
    private Texture2D _squareTexture;
    private Random _random;
    private int _screenWidth;
    
    public SquareFactory(Texture2D texture, int screenWidth)
    {
        _squareTexture = texture;
        _random = new Random();
        _screenWidth = screenWidth;
    }
    
    public Square CreateRandomSquare(int level)
    {
        float x = (float)_random.NextDouble() * (_screenWidth - 50) + 25;
        Vector2 position = new Vector2(x, -20);
        Vector2 velocity = new Vector2(0, 100 + level * 20);
        
        Color color = new Color(
            (float)_random.NextDouble(),
            (float)_random.NextDouble(),
            (float)_random.NextDouble()
        );
        
        return new Square(_squareTexture, position, velocity, color);
    }
}