spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C#-Quelltext

class GameLoop
{
    private const double MINSPAN = 1000 / 60;
    private Random rnd = new Random();
    private double testDistance = 0;

    public void Run()
    {
        DateTime baseTime = DateTime.Now;
        DateTime startTime = baseTime;
        DateTime endTime = baseTime;

        for (int i = 0; i < 20; i++)
        {
            endTime = DateTime.Now.AddMilliseconds(MINSPAN);
            this.calculate(endTime.Subtract(startTime).TotalMilliseconds);
            double remainingTime = endTime.Subtract(DateTime.Now).TotalMilliseconds;
            if (remainingTime > 0)
                Thread.Sleep((int)Math.Ceiling(remainingTime));

            startTime = endTime;
        }

        Debug.WriteLine("time elapsed: " + endTime.Subtract(baseTime).TotalMilliseconds.ToString()
            + "; distance passed: " + this.testDistance.ToString());
    }

    private void calculate(double milliseconds)
    {
        Thread.Sleep(rnd.Next((int)(MINSPAN * 2)));
        this.testDistance += milliseconds;
    }
}

C#-Quelltext

namespace ThingsSimulation
{
    public partial class Form1 : Form
    {
        private System.Windows.Forms.Button button1 = new System.Windows.Forms.Button();
        private System.Windows.Forms.Button button2 = new System.Windows.Forms.Button();
        private System.Windows.Forms.Button button3 = new System.Windows.Forms.Button();
        private System.Windows.Forms.Timer timer = new System.Windows.Forms.Timer();
        private List<Thing> things;
        private int r = 5;
        private SolidBrush brush = new SolidBrush(Color.Magenta);
        public Form1()
        {
            this.button1.Location = new System.Drawing.Point(10, 10);
            this.button1.Size = new System.Drawing.Size(60, 26);
            this.button1.Text = "test1";
            this.button1.Click += new System.EventHandler(this.button1_Click);
            this.Controls.Add(this.button1);
            this.button2.Location = new System.Drawing.Point(80, 10);
            this.button2.Size = new System.Drawing.Size(60, 26);
            this.button2.Text = "test2";
            this.button2.Click += new System.EventHandler(this.button2_Click);
            this.Controls.Add(this.button2);
            this.button3.Location = new System.Drawing.Point(150, 10);
            this.button3.Size = new System.Drawing.Size(60, 26);
            this.button3.Text = "reset";
            this.button3.Click += new System.EventHandler(this.button3_Click);
            this.Controls.Add(this.button3);
            this.timer.Interval = 3;
            this.timer.Tick += new System.EventHandler(this.timer_Tick);
            this.timer.Enabled = true;
            this.Size = new Size(800, 500);
            this.DoubleBuffered = true;
            this.things = new List<Thing>();
        }
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);

            foreach (Thing thing in this.things)
                e.Graphics.FillEllipse(new SolidBrush(thing.Color), thing.X - r, thing.Y - r, r * 2, r * 2);

            e.Graphics.DrawString("Objects: " + things.Count.ToString(), this.Font, Brushes.Black, 10, 40);
        }
        private void timer_Tick(object sender, EventArgs e)
        {
            foreach (Thing t in things)
            {
                t.X += t.VX;
                if (t.X == r || t.X == this.ClientSize.Width - r)
                    t.VX *= -1;

                t.Y += t.VY;
                if (t.Y == r || t.Y == this.ClientSize.Height - r)
                    t.VY *= -1;
            }

            for (int i = 0; i < this.things.Count; i++)
            {
                Thing ti = this.things[i];
                for (int j = i + 1; j < this.things.Count; j++)
                {
                    Thing tj = this.things[j];
                    if (ti.X == tj.X && ti.Y == tj.Y)
                        ti.Abandoned = tj.Abandoned = true;
                }
            }

            List<Thing> thingsTemp = new List<Thing>();
            foreach (Thing t in this.things)
                if (!t.Abandoned)
                    thingsTemp.Add(t);

            this.things = thingsTemp;

            this.Invalidate();
            Application.DoEvents();
        }
        private void button1_Click(object sender, EventArgs e)
        {
            for (int i = 10; i < 310; i += 10)
                this.things.Add(new Thing(i, 310 - i, 1, 1, Color.Blue));

            for (int i = 10; i < 310; i += 10)
                this.things.Add(new Thing(this.ClientSize.Width - i - r, 310 - i - r, -1, 1, Color.Red));
        }
        private void button2_Click(object sender, EventArgs e)
        {
            for (int i = 10; i < 310; i += 10)
                this.things.Add(new Thing(i, 310 - i, 1, 1, Color.Magenta));

            for (int i = 10; i < 310; i += 10)
                this.things.Add(new Thing(this.ClientSize.Width - i, 310 - i, -1, 1, Color.CadetBlue));
        }
        private void button3_Click(object sender, EventArgs e)
        {
            this.things = new List<Thing>();
        }
    }

    public class Thing
    {
        public int X;
        public int Y;
        public int VX;
        public int VY;
        public bool Abandoned = false;
        public Color Color;

        public Thing(int x, int y, int vx, int vy, Color color)
        {
            this.X = x;
            this.Y = y;
            this.VX = vx;
            this.VY = vy;
            this.Color = color;
        }
    }
}

C#-Quelltext

namespace ThingsSimulation
{
    public class Form1 : Form
    {
        private string help =
            "\t[ESC]\tquit\t" + Environment.NewLine +
            "\t[SPACE]\trestart\t" + Environment.NewLine +
            Environment.NewLine +
            "\t[F1]\tpause\\help\t" + Environment.NewLine +
            "\t[F2]\tshow things life\t" + Environment.NewLine +
            "\t[F3]\tshow bullet life\t" + Environment.NewLine +
            "\t[F4]\tuse random colors\t" + Environment.NewLine +
            Environment.NewLine +
            "\t[F5]\t" + GameMode.Single.ToString() + "\t" + Environment.NewLine +
            "\t[F6]\t" + GameMode.Lines.ToString() + "\t" + Environment.NewLine +
            "\t[F7]\t" + GameMode.Random.ToString() + "\t" + Environment.NewLine +
            "\t[F8]\t" + GameMode.Overdose.ToString() + "\t" + Environment.NewLine +
            Environment.NewLine +
            "\t[LEFT]\tmove left\t" + Environment.NewLine +
            "\tor [S]" + Environment.NewLine + Environment.NewLine +
            "\t[RIGHT]\tmove right\t" + Environment.NewLine +
            "\tor [F]" + Environment.NewLine + Environment.NewLine +
            "\t[UP]\tshoot (" + BULLET_LIFE + " energie)\t" + Environment.NewLine +
            "\tor [E]" + Environment.NewLine + Environment.NewLine +
            "\t[DOWN]\tshield (" + SHIELD_LIFE + " energie)\t" + Environment.NewLine +
            "\tor [D]";

        [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
        private static extern short GetKeyState(int keyCode);

        private const double FPS = 1000 / 60;
        private const int BULLET_SPEED = 6;
        private const int BULLET_R = 5;
        private const int BULLET_LIFE = 5;
        private const int BULLET_TICK_CD = 3;
        private const int Bullet_COLOR_RANGE = 60;
        private Color bulletCollor { get { return Color.FromArgb(130, 130, 0); } }

        private const int SHIELD_SPEED = 3;
        private const int SHIELD_R = 45;
        private const int SHIELD_LIFE = 100;
        private const int SHIELD_TICK_CD = 60;
        private const int SHIELD_START_DELAY = 60;

        private const int PLAYER_SPEED = 6;
        private const int PLAYER_R = 15;
        private const int PLAYER_LIFE = 1000;
        private const int PLAYER_ENERGIE = 1000;
        private const int PLAYER_ENERGIE_TICK_CD = 1;
        private const int PLAYER_COLOR_RANGE = 200;
        private Color playerColor { get { return Color.FromArgb(0, 50, 255); } }

        private const int THING_R = 10;
        private const int THING_LIFE = 10;
        private Color thingColor { get { return Color.FromArgb(0, 140, 0); } }
        private const int THING_COLOR_RANGE = 80;

        private bool quit = false;
        private double infoFPS = 0;
        private int score = 0;
        private bool thingInfo = false;
        private bool bulletInfo = false;
        private bool thingsRndColor = false;
        private Random rnd;

        private ulong tickCount = 0;
        private ulong lastBulletTick = 0;
        private ulong lastShieldTick = 0;
        private ulong lastEnergieTick = 0;

        private Player player;
        private List<Thing> things;
        private List<Bullet> bullets;

        private enum GameMode { Single, Lines, Random, Overdose };
        private GameMode gameMode = GameMode.Single;

        public Form1()
        {
            this.StartPosition = FormStartPosition.CenterScreen;
            this.Text = "Things Simulation";
            this.BackColor = Color.Black;
            this.Shown += new System.EventHandler(this.Form1_Shown);
            this.Size = new Size((int)(Screen.PrimaryScreen.Bounds.Width * 0.4), (int)(Screen.PrimaryScreen.Bounds.Height * 0.4));
            this.DoubleBuffered = true;
            this.Font = new System.Drawing.Font("Consolas", 10F);
            this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.Form1_FormClosing);
            this.Resize += new System.EventHandler(this.Form1_Resize);
        }
        private void InitializeComponent()
        {
            this.SuspendLayout();
            // 
            // Form1
            // 
            this.Name = "Form1";
            this.ResumeLayout(false);
        }
        private void Form1_Shown(object sender, EventArgs e)
        {
            this.restart();
            this.showHelp();
            this.gameLoop();
        }
        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            this.quit = true;
        }
        private void Form1_Resize(object sender, EventArgs e)
        {
            this.restart();
        }
        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);

            if (this.WindowState == FormWindowState.Minimized)
                return;

            // things
            foreach (Thing t in this.things)
                t.Paint(e.Graphics);

            // player
            this.player.Paint(e.Graphics);

            // bullets
            foreach (Bullet b in this.bullets)
                b.Paint(e.Graphics);

            // things info
            if (this.thingInfo)
                foreach (Thing t in this.things)
                    t.PaintInfo(e.Graphics);

            // player info
            if (this.thingInfo)
                this.player.PaintInfo(e.Graphics);

            // bullet info
            if (this.bulletInfo)
                foreach (Bullet b in this.bullets) b.PaintInfo(e.Graphics);

            // game info
            e.Graphics.DrawString(
                "    fps: " + this.infoFPS + "ms" + Environment.NewLine +
                " things: " + things.Count.ToString() + Environment.NewLine +
                "bullets: " + bullets.Count.ToString() + Environment.NewLine +
                "   life: " + player.Life.ToString() + Environment.NewLine +
                "energie: " + player.Energie.ToString() + Environment.NewLine +
                "  score: " + score.ToString(), this.Font, Brushes.LightGreen, 4, 4);
        }
        private void restart()
        {
            this.rnd = new Random();
            this.score = 0;
            this.tickCount = this.lastShieldTick = this.lastBulletTick = 0;
            this.player = new Player((int)(this.ClientSize.Width / 2), (int)(this.ClientSize.Height - PLAYER_R),
                PLAYER_SPEED, 0, PLAYER_R, PLAYER_LIFE, PLAYER_ENERGIE, this.playerColor, PLAYER_COLOR_RANGE);
            this.things = new List<Thing>();
            this.bullets = new List<Bullet>();

            if (this.gameMode == GameMode.Lines) this.gameModeLines();
            else if (this.gameMode == GameMode.Random) this.gameModeRandom();
            else if (this.gameMode == GameMode.Overdose) this.gameModeOverdose();
            else this.gameModeSolo();
        }
        private void gameModeSolo()
        {
            this.things.Add(new Thing(200, 200, 1, -1, 35, 35, this.getThingColor(), THING_COLOR_RANGE));
        }
        private void gameModeLines()
        {
            int a = 30; int j = 20;
            int w = this.ClientSize.Width;
            for (int i = 0; i < j; i++)
            {
                this.things.Add(new Thing(a + i * 8, a + i * 8, 1, 1, THING_R, THING_LIFE, this.getThingColor(), THING_COLOR_RANGE));
                this.things.Add(new Thing(a + i * 10, a + i * 5, 2, 1, THING_R, THING_LIFE, this.getThingColor(), THING_COLOR_RANGE));
                this.things.Add(new Thing(a + i * 8, (j * 8 + a) - i * 8, 1, -1, THING_R, THING_LIFE, this.getThingColor(), THING_COLOR_RANGE));
                this.things.Add(new Thing(a + i * 10, (j * 8 + a) - i * 5, 2, -1, THING_R, THING_LIFE, this.getThingColor(), THING_COLOR_RANGE));

                this.things.Add(new Thing(w - a - i * 8, a + i * 8, -1, 1, THING_R, THING_LIFE, this.getThingColor(), THING_COLOR_RANGE));
                this.things.Add(new Thing(w - a - i * 10, a + i * 5, -2, 1, THING_R, THING_LIFE, this.getThingColor(), THING_COLOR_RANGE));
                this.things.Add(new Thing(w - a - i * 8, (j * 8 + a) - i * 8, -1, -1, THING_R, THING_LIFE, this.getThingColor(), THING_COLOR_RANGE));
                this.things.Add(new Thing(w - a - i * 10, (j * 8 + a) - i * 5, -2, -1, THING_R, THING_LIFE, this.getThingColor(), THING_COLOR_RANGE));
            }

            int b = 30; a = 40; j = 10;
            for (int i = 0; i < j; i++)
            {
                this.things.Add(new Thing(a + i * 8, (j * 8) + b - i * 8, -1, 1, THING_R, THING_LIFE, this.getThingColor(), THING_COLOR_RANGE));
                this.things.Add(new Thing(a + i * 8, (j * 8) + b + i * 8, -1, 1, THING_R, THING_LIFE, this.getThingColor(), THING_COLOR_RANGE));
                this.things.Add(new Thing(a + (j * 8) + i * 8 - 8, 8 + b + i * 8, -1, 1, THING_R, THING_LIFE, this.getThingColor(), THING_COLOR_RANGE));
                this.things.Add(new Thing((j * 8) + a + i * 8 - 8, (j * 8 * 2) + b - 8 - i * 8, -1, 1, THING_R, THING_LIFE, this.getThingColor(), THING_COLOR_RANGE));

                this.things.Add(new Thing(w - a - j * 8 - i * 8, 8 + b + i * 8, 1, 1, THING_R, THING_LIFE, this.getThingColor(), THING_COLOR_RANGE));
                this.things.Add(new Thing(w - a - j * 8 - i * 8, j * 8 * 2 + b - 8 - i * 8, 1, 1, THING_R, THING_LIFE, this.getThingColor(), THING_COLOR_RANGE));
                this.things.Add(new Thing(w - a - i * 8 - 8, j * 8 + b - i * 8, 1, 1, THING_R, THING_LIFE, this.getThingColor(), THING_COLOR_RANGE));
                this.things.Add(new Thing(w - a - i * 8 - 8, j * 8 + b + i * 8, 1, 1, THING_R, THING_LIFE, this.getThingColor(), THING_COLOR_RANGE));
            }
        }
        private void gameModeRandom()
        {
            int x1 = 100; int y1 = 100;
            int x2 = this.ClientSize.Width - 100; int y2 = this.ClientSize.Height - 200;
            int w = x2 - x1; int h = y2 - y1;

            for (int i = 0; i < 30; i++)
            {
                int r = rnd.Next(10, 60); int x = rnd.Next(0, 2) == 1 ? -1 : 1; int y = rnd.Next(0, 2) == 1 ? -1 : 1;
                this.things.Add(new Thing(x1 + rnd.Next(w), y1 + rnd.Next(h), x * rnd.Next(1, 5),
                    y * rnd.Next(1, 3), r, r, this.getThingColor(), THING_COLOR_RANGE));
            }
        }
        private void gameModeOverdose()
        {
            int x1 = 100; int y1 = 100;
            int x2 = this.ClientSize.Width - 100; int y2 = this.ClientSize.Height - 200;
            int w = x2 - x1; int h = y2 - y1;

            for (int i = 0; i < 1000; i++)
            {
                int r = rnd.Next(10, 30); int x = rnd.Next(0, 2) == 1 ? -1 : 1; int y = rnd.Next(0, 2) == 1 ? -1 : 1;
                this.things.Add(new Thing(x1 + rnd.Next(w), y1 + rnd.Next(h), x * rnd.Next(0, 3),
                    y * rnd.Next(0, 3), r, r, this.getThingColor(), 100));
            }
        }
        private void gameLoop()
        {
            DateTime startTime = DateTime.Now;
            DateTime endTime = startTime;

            while (!this.quit)
            {
                endTime = DateTime.Now.AddMilliseconds(FPS);
                this.infoFPS = endTime.Subtract(startTime).TotalMilliseconds;
                this.calculate();
                this.Invalidate();
                Application.DoEvents();
                double remainingTime = endTime.Subtract(DateTime.Now).TotalMilliseconds;
                if (remainingTime > 0) Thread.Sleep((int)Math.Ceiling(remainingTime));
                this.tickCount++;
                startTime = endTime;
            }
            this.Close();
        }
        private void calculate()
        {
            // input

            if ((GetKeyState(27) & 0x8000) == 0x8000) { this.quit = true; return; } // esc
            if ((GetKeyState(32) & 0x8000) == 0x8000) { Thread.Sleep(200); this.restart(); return; }   // space

            if ((GetKeyState(112) & 0x8000) == 0x8000) { this.showHelp(); } // F1
            if ((GetKeyState(113) & 0x8000) == 0x8000) { Thread.Sleep(200); this.thingInfo = !this.thingInfo; }     // F2
            if ((GetKeyState(114) & 0x8000) == 0x8000) { Thread.Sleep(200); this.bulletInfo = !this.bulletInfo; }   // F3
            if ((GetKeyState(115) & 0x8000) == 0x8000) { Thread.Sleep(200); this.thingsRndColor = !this.thingsRndColor; this.restart(); return; } // F4

            if ((GetKeyState(116) & 0x8000) == 0x8000) { Thread.Sleep(200); this.gameMode = GameMode.Single; this.restart(); }      // F5
            if ((GetKeyState(117) & 0x8000) == 0x8000) { Thread.Sleep(200); this.gameMode = GameMode.Lines; this.restart(); }       // F6
            if ((GetKeyState(118) & 0x8000) == 0x8000) { Thread.Sleep(200); this.gameMode = GameMode.Random; this.restart(); }      // F7
            if ((GetKeyState(119) & 0x8000) == 0x8000) { Thread.Sleep(200); this.gameMode = GameMode.Overdose; this.restart(); }    // F8

            bool keyS = (GetKeyState(83) & 0x8000) == 0x8000;
            bool keyE = (GetKeyState(69) & 0x8000) == 0x8000;
            bool keyF = (GetKeyState(70) & 0x8000) == 0x8000;
            bool keyD = (GetKeyState(68) & 0x8000) == 0x8000;
            bool keyLeft = (GetKeyState(37) & 0x8000) == 0x8000;
            bool keyUp = (GetKeyState(38) & 0x8000) == 0x8000;
            bool keyRight = (GetKeyState(39) & 0x8000) == 0x8000;
            bool keyDown = (GetKeyState(40) & 0x8000) == 0x8000;

            // energie

            if (this.tickCount - this.lastEnergieTick > PLAYER_ENERGIE_TICK_CD)
                if (this.player.Energie < PLAYER_ENERGIE)
                {
                    this.player.Energie++;
                    this.lastEnergieTick = this.tickCount;
                }

            // move player

            if (keyS || keyLeft) { player.VX = -Math.Abs(player.VX); player.X += player.VX; }
            if (keyF || keyRight) { player.VX = Math.Abs(player.VX); player.X += player.VX; }

            if (player.X <= player.R) { player.X = player.R; player.VX = Math.Abs(player.VX); }
            if (player.X >= this.ClientSize.Width - player.R) { player.X = this.ClientSize.Width - player.R; player.VX = -Math.Abs(player.VX); }

            // move bullets

            foreach (Bullet b in this.bullets)
                if (b is Shield)
                {
                    if (this.tickCount - ((Shield)b).StartTick > SHIELD_START_DELAY)
                        b.Y += b.VY;
                }
                else
                    b.Y += b.VY;

            // add bullet

            if (keyE || keyUp)
                if (this.player.Energie > BULLET_LIFE)
                    if (this.tickCount - this.lastBulletTick > BULLET_TICK_CD)
                    {
                        bullets.Add(new Bullet(player.X, player.Y1 - BULLET_R, 0, -BULLET_SPEED, BULLET_R, BULLET_LIFE, bulletCollor, Bullet_COLOR_RANGE));
                        this.lastBulletTick = this.tickCount;
                        this.player.Energie -= BULLET_LIFE;
                    }

            // add shield

            if (keyD || keyDown)
                if (this.player.Energie > SHIELD_LIFE)
                    if (this.tickCount - this.lastShieldTick > SHIELD_TICK_CD)
                    {
                        bullets.Add(new Shield(player.X, player.Y, 0, -SHIELD_SPEED, SHIELD_R, SHIELD_LIFE, bulletCollor, Bullet_COLOR_RANGE, this.tickCount));
                        this.lastShieldTick = this.tickCount;
                        this.player.Energie -= SHIELD_LIFE;
                    }

            // move things

            foreach (Thing t in things)
            {
                t.X += t.VX;
                if (t.X <= t.R)
                {
                    t.VX *= -1;
                    t.X = t.R;
                }

                if (t.X >= this.ClientSize.Width - t.R)
                {
                    t.VX *= -1;
                    t.X = this.ClientSize.Width - t.R;
                }

                t.Y += t.VY;
                if (t.Y <= t.R)
                {
                    t.VY *= -1;
                    t.Y = t.R;
                }

                if (t.Y >= this.ClientSize.Height - t.R)
                {
                    t.VY *= -1;
                    t.Y = this.ClientSize.Height - t.R;
                }
            }

            // collision thing <-> player

            foreach (Thing t in things)
                if (t.Life > 0)
                    if (this.player.IntersectRectangle(t))
                    { player.Life -= t.Life; t.Life = 0; }

            // collision bullet <-> top of map

            foreach (Bullet b in this.bullets)
                if (b.Life > 0)
                    if (b.Y + b.R <= b.R)
                        b.Life = 0;

            // collision thing  <-> bullet

            foreach (Thing t in things)
                if (t.Life > 0)
                    foreach (Bullet b in this.bullets)
                        if (b.Life > 0)
                            if (b.IntersectRectangle(t))
                            {
                                b.Life--;
                                t.Life--;
                                score++;
                            }

            // remove things

            List<Thing> thingsTemp = new List<Thing>();
            foreach (Thing t in this.things)
                if (t.Life > 0)
                    thingsTemp.Add(t);

            this.things = thingsTemp;

            // remove bullets

            List<Bullet> bulletsTemp = new List<Bullet>();
            foreach (Bullet b in this.bullets)
                if (b.Life > 0)
                    bulletsTemp.Add(b);

            // player dead / finisch

            if (this.player.Life < 1 || this.things.Count == 0)
            {
                this.Invalidate();

                string s = string.Empty;
                if (this.player.Life < 1)
                {
                    s = "\tyou are dead.\t" + Environment.NewLine + Environment.NewLine;
                    this.player.Life = PLAYER_LIFE;
                }

                s += "\tplayed ticks: " + this.tickCount.ToString() + '\n' + Environment.NewLine;
                s += "\tscore: " + this.score.ToString() + '\n';

                MessageBox.Show(s, "Things Simulation", MessageBoxButtons.OK);
                if (this.things.Count == 0)
                    restart();
            }

            this.bullets = bulletsTemp;
        }
        private void showHelp()
        {
            MessageBox.Show(this.help, "help", MessageBoxButtons.OK);
            Thread.Sleep(200);
        }
        private Color getThingColor()
        {
            if (this.thingsRndColor)
                return Color.FromArgb(rnd.Next(50, 200), rnd.Next(50, 200), rnd.Next(50, 200));

            return thingColor;
        }
    }
    public class Thing
    {
        protected const int COLOR_OFFSET = 20;
        private const int MIN_R = 4;
        public int X;
        public int Y;
        public int VX;
        public int VY;
        public int R;
        protected int life;
        protected double lifeOnePercent;
        protected double radiusOnePercent;
        protected Color color;
        protected byte colorRange;
        protected Font font = new System.Drawing.Font("Consolas", 9F);

        public Thing(int x, int y, int vx, int vy, int r, int life, Color color, byte colorRange)
        {
            this.X = x;
            this.Y = y;
            this.VX = vx;
            this.VY = vy;
            this.R = r;
            this.radiusOnePercent = (r - MIN_R) * 0.01;
            this.lifeOnePercent = life * 0.01;
            this.Life = life;
            this.color = color;
            this.colorRange = colorRange;
        }
        public int Life
        {
            get { return this.life; }
            set
            {
                int i = (int)((value / this.lifeOnePercent) * this.radiusOnePercent) + MIN_R;

                if (i < MIN_R)
                    this.R = MIN_R;
                else
                    this.R = i;

                this.life = value;
            }
        }
        public int X1 { get { return X - R; } }
        public int Y1 { get { return Y - R; } }
        public int X2 { get { return X + R; } }
        public int Y2 { get { return Y + R; } }
        public int W { get { return R + R; } }
        public int H { get { return R + R; } }
        public bool IntersectRectangle(Thing t)
        {
            // http://www.back-side.net/codingrects.html

            int xl = X1;
            int yo = Y1;
            int xr = t.X1 + t.W;
            int yu = t.Y1 + t.H;

            if (t.X1 < X1)
                xl = t.X1;
            if (t.Y1 < Y1)
                yo = t.Y1;
            if (X1 + W > t.X1 + t.W)
                xr = X1 + W;
            if (Y1 + H > t.Y1 + t.H)
                yu = Y1 + H;

            return (W + t.W > xr - xl & H + t.H > yu - yo);
        }
        public virtual void Paint(Graphics g)
        {
            g.FillEllipse(new SolidBrush(calculateColor(0)), X1, Y1, W, H);
            g.DrawEllipse(new Pen(calculateColor(COLOR_OFFSET)), X1, Y1, W, H);
        }
        public virtual void PaintInfo(Graphics g)
        {
            g.DrawString(this.Life.ToString(), this.font, Brushes.White, X, Y);
        }
        protected virtual Color calculateColor(int offset)
        {
            byte factor = (byte)(this.colorRange - ((this.Life / this.lifeOnePercent) * this.colorRange * 0.01) + offset);
            int i = this.color.R + factor;
            int r = i > byte.MaxValue ? byte.MaxValue : (byte)i;
            i = this.color.G + factor;
            int g = i > byte.MaxValue ? byte.MaxValue : (byte)i;
            i = this.color.B + factor;
            int b = i > byte.MaxValue ? byte.MaxValue : (byte)i;
            return Color.FromArgb(r, g, b);
        }
    }
    public class Bullet : Thing
    {
        public Bullet(int x, int y, int vx, int vy, int r, int life, Color color, byte colorRange) : base(x, y, vx, vy, r, life, color, colorRange) { }
        public virtual void Paint(Graphics g)
        {
            g.DrawEllipse(new Pen(calculateColor(0)), X1, Y1, W, H);
        }
    }
    public class Shield : Bullet
    {
        public ulong StartTick = 0;
        public Shield(int x, int y, int vx, int vy, int r, int life, Color color, byte colorRange, ulong startTick)
            : base(x, y, vx, vy, r, life, color, colorRange)
        {
            this.StartTick = startTick;
        }
    }
    public class Player : Thing
    {
        private int maxR;
        public int Energie;
        public Player(int x, int y, int vx, int vy, int r, int life, int energie, Color color, byte colorRange)
            : base(x, y, vx, vy, r, life, color, colorRange)
        {
            this.maxR = r;
            this.Energie = energie;
        }
        public override void Paint(Graphics g)
        {
            g.FillEllipse(new SolidBrush(calculateColor(0)), X - this.maxR, Y - this.maxR, this.maxR * 2, this.maxR * 2);
            g.DrawEllipse(new Pen(calculateColor(COLOR_OFFSET)), X - this.maxR, Y - this.maxR, this.maxR * 2, this.maxR * 2);
        }
    }
}