Создание стен в игре

    static class Render
    {
        // Размер границы тайла
        private static int sizeOfBorderTile = 60;
        // Box
        private static Bitmap box;
 
        public static Bitmap DrawBox(int x, int y)
        {
            if (box == null)
                box = new Bitmap(960,600);
            var grph = Graphics.FromImage(box);
            grph.Clear(Color.Transparent);
            grph.DrawImage(Properties.Resources.TileWall,x,y,60,60);
            return box;
        }
    }
 
    public partial class TestForm : Form
    {
        bool boxMoving;
        int x, y;
        public TestForm()
        {
            InitializeComponent();
            BtnMove.Text = "Двигать";
            boxMoving = false;
            x = 0;
            y = 0;
        }
 
        private void BtnMove_Click(object sender, EventArgs e)
        {
            if (boxMoving)
            {
                BtnMove.Text = "Двигать";
                boxMoving = false;
                timerMoveBox.Enabled = false;
            }
            else
            {
                BtnMove.Text = "Остановить";
                boxMoving = true;
                timerMoveBox.Enabled = true;
            }
        }
 
        private void timerMoveBox_Tick(object sender, EventArgs e)
        {
            pbGameField.Image = Render.DrawBox(x, y);
            x += 5;
            y += 5;
        }
    }

grph.Clear(Color.Transparent);

        public static Bitmap Draw(Level lvl, int x, int y)
        {
            var grph = Graphics.FromImage(box);
            grph.Clear(Color.Transparent);
 
            for (int i = 0; i < lvl.GameField.GetLength(0); i++)
                for (int j = 0; j < lvl.GameField.GetLength(1); j++)
                {
                    if (lvl.GameField[i, j].type == TypeOfContent.Wall)
                        grph.DrawImage(Properties.Resources.TileWall, j * sizeOfBorderTile, i * sizeOfBorderTile, sizeOfBorderTile, sizeOfBorderTile);
                    else if (lvl.GameField[i, j].type == TypeOfContent.Land)
                        grph.DrawImage(Properties.Resources.TileGround, j * sizeOfBorderTile, i * sizeOfBorderTile, sizeOfBorderTile, sizeOfBorderTile);
                }
            grph.DrawImage(Properties.Resources.TileWall,x,y,60,60);
            return box;
        }

 public partial class TestForm : Form
    {
        private Level gameLevel = new Level(false);
 
        bool boxMoving, btnDown;
        bool changeX, changeY;
        int x, y;
        int coefX, coefY;
        public TestForm()
        {
            InitializeComponent();
            BtnMove.Text = "Остановить";
            timerMoveBox.Enabled = true;
            boxMoving = false;
            x = 0;
            y = 0;
            coefX = 1;
            coefY = 1;
            changeX = false;
            changeY = false;
        }
 
        private void BtnMove_Click(object sender, EventArgs e)
        {
            if (boxMoving)
            {
                BtnMove.Text = "Двигать";
                boxMoving = false;
                timerMoveBox.Enabled = false;
            }
            else
            {
                BtnMove.Text = "Остановить";
                boxMoving = true;
                timerMoveBox.Enabled = true;
            }
        }
 
        private void timerMoveBox_Tick(object sender, EventArgs e)
        {
            
            pbGameField.Image = Render.DrawBox(x, y);
            if (btnDown)
            {
                if (changeX)
                    x += coefX * 5;
                if (changeY)
                    y += coefY * 5;
            }      
        }
 
        private void TestForm_Load(object sender, EventArgs e)
        {
            pbGameField.Image = Render.DrawLevel(gameLevel);
        }
 
        private void TestForm_KeyDown(object sender, KeyEventArgs e)
        {
            btnDown = true;
            if (e.KeyCode == Keys.Up)
            {
                coefY = -1;
                changeY = true;
            }
            if (e.KeyCode == Keys.Down)
            {
                coefY = 1;
                changeY = true;
            }
            if (e.KeyCode == Keys.Left)
            {
                coefX = -1;
                changeX = true;
            }
            if (e.KeyCode == Keys.Right)
            {
                coefX = 1;
                changeX = true;
            }
        }
 
        private void TestForm_KeyUp(object sender, KeyEventArgs e)
        {
            btnDown = false;
            changeX = false;
            changeY = false;
        }     
    }

KeyPreview = true;

protected override bool ProcessDialogKey(Keys keyData)
{
}

using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Net;
using System.Runtime.InteropServices;
using System.Windows.Forms;
 
namespace WindowsFormsApplication326
{
    public partial class MainForm : Form
    {
        private LevelPanel pnLevel;
 
        public MainForm()
        {
            InitializeComponent();
 
            GameResources.Init();
            Game.Init();
 
            SetClientSizeCore(Game.State.Level.Width * Game.TileSize.Width, Game.State.Level.Height * Game.TileSize.Height);
            pnLevel = new LevelPanel() { Parent = this, Dock = DockStyle.Fill };
 
            Application.Idle += delegate { UpdateInterface(); };
        }
 
        private void UpdateInterface()
        {
            pnLevel.Invalidate();
            Game.Update();
        }
    }
 
    public static class Game
    {
        public static Size TileSize = new Size(32, 32);
        public static GameState State { get; set; }
        public static PlayerController PlayerController { get; set; }
        public static CoinController CoinController { get; set; }
 
        public static void Init()
        {
            State = new GameState();
            PlayerController = new PlayerController();
            CoinController = new CoinController();
 
            State.Level = Level.Load(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "level.txt"));
            State.Player = new Player() { Location = new PointF(1, 1), Sprite = new RowSprite() { FrameSize = new Size(70, 70)} };
            State.CoinSprite = new Sprite {FrameCount = 64, FrameSize = new Size(64, 64)};
        }
 
        public static void Update()
        {
            PlayerController.Update();
            CoinController.Update();
        }
    }
 
    /// <summary>
    /// State of the game (can be saved and loaded form file)
    /// </summary>
    [Serializable]
    public class GameState
    {
        public Level Level { get; set; }
        public Player Player { get; set; }
        public Sprite CoinSprite { get; set; }
    }
 
    public static class GameResources
    {
        public static Bitmap Wall;
        public static Bitmap Player;
        public static Bitmap Floor;
        public static Bitmap Empty;
        public static Bitmap Coin;
        public static Bitmap Water;
 
        public static void Init()
        {
            Empty = new Bitmap(Game.TileSize.Width, Game.TileSize.Height);
            Wall = LoadTile("http://figli.pp.ua/wp-content/uploads/2014/01/stone-pat-001.jpg");
            Floor = LoadTile("http://preview.turbosquid.com/Preview/2014/08/01__18_23_50/Floor.JPG289273a2-a646-40b7-9029-0944498b1a40Small.jpg");
            Player = Load("http://rpgmaker.net/media/content/users/2220/locker/Lilaf8.png");
            Coin = Load("http://assets.indiecity.com/eeaca254-71c1-4709-bdad-e9170a766504/screenshot_1353671388.png");
            Water = Load("http://i678.photobucket.com/albums/vv143/GameGuysProjects/water.png");
        }
 
        static Bitmap LoadTile(string url)
        {
            using (var res = (Bitmap)Image.FromStream(new WebClient { Proxy = null }.OpenRead(url)))
            {
                res.SetResolution(96, 96);
                return new Bitmap(res, Game.TileSize);
            }
        }
 
        static Bitmap Load(string url)
        {
            var res = (Bitmap) Image.FromStream(new WebClient {Proxy = null}.OpenRead(url));
            res.SetResolution(96, 96);
            return res;
        }
    }
 
    public static class Keyboard
    {
        [Flags]
        private enum KeyStates
        {
            None = 0,
            Down = 1,
            Toggled = 2
        }
 
        [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
        private static extern short GetKeyState(int keyCode);
 
        private static KeyStates GetKeyState(Keys key)
        {
            KeyStates state = KeyStates.None;
 
            short retVal = GetKeyState((int)key);
 
            if ((retVal & 0x8000) == 0x8000)
                state |= KeyStates.Down;
 
            if ((retVal & 1) == 1)
                state |= KeyStates.Toggled;
 
            return state;
        }
 
        public static bool IsKeyDown(Keys key)
        {
            return KeyStates.Down == (GetKeyState(key) & KeyStates.Down);
        }
 
        public static bool IsKeyToggled(Keys key)
        {
            return KeyStates.Toggled == (GetKeyState(key) & KeyStates.Toggled);
        }
    }
 
    public class PlayerController
    {
        public float Speed { get;set;}
 
        public PlayerController()
        {
            Speed = 0.06f;
        }
 
        public void Update()
        {
            var sprite = Game.State.Player.Sprite;
            var tiles = Game.State.Level.Tiles;
 
            var dx = 0;
            var dy = 0;
            var speed = Speed;
            if(Keyboard.IsKeyDown(Keys.W)) dy = -1;
            if(Keyboard.IsKeyDown(Keys.A)) dx = -1;
            if(Keyboard.IsKeyDown(Keys.S)) dy = 1;
            if(Keyboard.IsKeyDown(Keys.D)) dx = 1;
            if(Keyboard.IsKeyDown(Keys.ShiftKey)) speed *= 1.5f;
 
            var x = Game.State.Player.Location.X + dx * speed;
            var y = Game.State.Player.Location.Y + dy * speed;
            var i = (int)x;
            var j = (int)y;
            if (tiles[i + 1, j + 1].CanWalk && 
                tiles[i, j].CanWalk &&
                tiles[i + 1, j].CanWalk &&
                tiles[i, j + 1].CanWalk)
            {
                Game.State.Player.Location = new PointF(x, y);
 
                if (dy > 0) sprite.Row = 0; else
                if (dy < 0) sprite.Row = 3; else
                if (dx > 0) sprite.Row = 2; else
                if (dx < 0) sprite.Row = 1; else
                {
                    //stay
                    sprite.Row = sprite.Row == 3 ? 3 : 0;
                    sprite.CurrentFrame = 0;
                }
 
                if (dx != 0 || dy != 0)
                    Game.State.Player.Sprite.GotoNextFrame(speed*8);
            }else
            {
                //stay
                Game.State.Player.Sprite.CurrentFrame = 0;
                Game.State.Player.Sprite.Row = 0;
            }
        }
    }
 
    public class CoinController
    {
        public float Speed { get; set; }
 
        public CoinController()
        {
            Speed = 3f;
        }
 
        public void Update()
        {
            Game.State.CoinSprite.GotoNextFrame(Speed);
 
            var i = (int)(Game.State.Player.Location.X + 0.5f);
            var j = (int)(Game.State.Player.Location.Y + 0.5f);
            if (Game.State.Level.Tiles[i, j] is Coin)
                Game.State.Level.Tiles[i, j] = new Floor(){Location = new Point(i, j)};
        }
    }
 
    public class RowSprite
    {
        public Size FrameSize { get; set; }
        public float CurrentFrame { get; set; }
        public int Row { get; set; }
 
        public void GotoNextFrame(float dt)
        {
            CurrentFrame += dt;
        }
 
        public void Draw(Graphics gr, Image image, Point location, Size size)
        {
            var framesPerRow = image.Width / FrameSize.Width;
            var x = (int)CurrentFrame % framesPerRow;
            var y = Row;
 
            if (CurrentFrame >= framesPerRow) CurrentFrame = 0;
 
            var p = new Point(x * FrameSize.Width, y * FrameSize.Height);
            gr.DrawImage(image, new Rectangle(location, size), new Rectangle(p, FrameSize), GraphicsUnit.Pixel);
        }
    }
 
    public class Sprite
    {
        public Size FrameSize { get; set; }
        public float CurrentFrame { get; set; }
        public int FrameCount { get; set; }
 
        public void GotoNextFrame(float dt)
        {
            CurrentFrame += dt;
            if (CurrentFrame >= FrameCount)
                CurrentFrame = 0;
        }
 
        public void Draw(Graphics gr, Image image, Point location)
        {
            var framesPerRow = image.Width / FrameSize.Width;
            var x = (int)CurrentFrame % framesPerRow;
            var y = (int)CurrentFrame / framesPerRow;
 
            var p = new Point(x * FrameSize.Width, y * FrameSize.Height);
            gr.DrawImage(image, new Rectangle(location, Game.TileSize), new Rectangle(p, FrameSize), GraphicsUnit.Pixel);
        }
    }
 
    /// <summary>
    /// Displays level
    /// </summary>
    public class LevelPanel : UserControl
    {
        public LevelPanel()
        {
            SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer | ControlStyles.UserPaint, true);
        }
 
        protected override void OnPaintBackground(PaintEventArgs e)
        {
            //nothing
        }
 
        protected override void OnPaint(PaintEventArgs e)
        {
            //draw tiles
            foreach(var tile in Game.State.Level.Tiles)
                tile.Draw(e.Graphics);
 
            //draw player
            Game.State.Player.Draw(e.Graphics);
        }
    }
 
    [Serializable]
    public class Level
    {
        public Tile[,] Tiles { get; private set; }
 
        public int Width { get; private set; }
        public int Height { get; private set; }
 
        public static Level Load(string fileName)
        {
            var res = new Level();
            var lines = File.ReadAllLines(fileName);
 
            res.Width = lines[0].Length;
            res.Height = lines.Length;
 
            res.Tiles = new Tile[res.Width, res.Height];
 
            for (int j = 0; j < res.Height; j++)
            for (int i = 0; i < res.Width; i++) 
                switch(lines[j][i])
                {
                    case '.':
                    case ' ': res.Tiles[i, j] = new Floor { Location = new Point(i, j) }; break;
                    case '#': res.Tiles[i, j] = new Wall { Location = new Point(i, j) }; break;
                    case '@': res.Tiles[i, j] = new Coin { Location = new Point(i, j) }; break;
                    case 'w':
                    case 'W': res.Tiles[i, j] = new Water { Location = new Point(i, j) }; break;
                    default: goto case ' ';
                }
 
            return res;
        }
    }
 
    [Serializable]
    public abstract class Tile
    {
        public Point Location { get; set; }
        public Rectangle Rect
        {
            get { return new Rectangle(Game.TileSize.Width * Location.X, Game.TileSize.Width * Location.Y, Game.TileSize.Width, Game.TileSize.Height); }
        }
 
        public virtual bool CanWalk{ get { return true; } }
 
        public abstract void Draw(Graphics gr);
    }
 
    [Serializable]
    public class Floor: Tile
    {
        public override void Draw(Graphics gr)
        {
            gr.DrawImageUnscaledAndClipped(GameResources.Floor, Rect);
        }
    }
 
    [Serializable]
    public class Wall : Tile
    {
        public override bool CanWalk { get { return false; } }
 
        public override void Draw(Graphics gr)
        {
            gr.DrawImageUnscaledAndClipped(GameResources.Wall, Rect);
        }
    }
 
    [Serializable]
    public class Coin : Tile
    {
        public override void Draw(Graphics gr)
        {
            gr.DrawImageUnscaledAndClipped(GameResources.Floor, Rect);
            Game.State.CoinSprite.Draw(gr, GameResources.Coin, Rect.Location);
        }
    }
 
    [Serializable]
    public class Water : Tile
    {
        public override bool CanWalk { get{ return false; } }
 
        public override void Draw(Graphics gr)
        {
            gr.DrawImageUnscaledAndClipped(GameResources.Water, Rect);
        }
    }
 
    [Serializable]
    public class Character
    {
        public PointF Location { get;set;}
        public RowSprite Sprite { get; set; }
 
        public virtual void Draw(Graphics gr)
        {
        }
    }
 
    [Serializable]
    public class Player : Character
    {
        public override void Draw(Graphics gr)
        {
            var x = (int)(Location.X * Game.TileSize.Width);
            var y = (int)(Location.Y * Game.TileSize.Height);
            Sprite.Draw(gr, GameResources.Player, new Point(x, y), Game.TileSize);
        }
    }
}