Managed C++/CLI

virtual void OnPaint(PaintEventArgs^ e) override
{

}

#include "stdafx.h"
using namespace System;
using namespace System::Drawing;
using namespace System::Windows::Forms;
using namespace System::Collections::Generic; // Required to make lists.

public ref class Snake_Part
{
	public:
			Panel^ panel;

			Snake_Part( Form ^ form ) // Class Constructor.
			{ 
				panel = gcnew Panel();
				panel->BackColor = Color::Blue;
				panel->Width = 20; panel->Height = 20;
				form->Controls->Add(panel);
			}
};

public ref class Form1 : public Form 
{
	public:
			List<Snake_Part^>^ Parts; // A list that contains the snake parts.
			int length; // The length of the  snake.
			Timer^ Timer1; // The timer that will move the snake;
			//Panel^ p;
			Form1() // Class constructor.
			{	
				Parts = gcnew List<Snake_Part^>();
				Timer1 = gcnew Timer();
				Timer1->Interval = 2000;
				Timer1->Start();
				Timer1->Tick += gcnew System::EventHandler(this, &Form1::timer1_Tick);
				Make_Snake();
			}
			
			void Make_Snake()
			{
				double clr = 255;
				double dclr = 128 / 2;

				for(int I = 0; I <= 3; I++)
				{
					Snake_Part^ p = gcnew Snake_Part(this);
					p->panel->BackColor = Color::FromArgb(0,0,clr);
					Parts->Add(p);
					clr -= dclr;
				}

				for each (Snake_Part^ p in Parts)
				{
					length += p->panel->Width + 2;
					p->panel->Left = length;
				}	
			}

			void move_snake()
			{
					
			}

			System::Void timer1_Tick(System::Object^  sender, System::EventArgs^  e) // A timer that will move the snake;
			{
				move_snake();
				
			}
};

[STAThread]
int main()
{
    Application::Run(gcnew Form1());
}

Retrieve the last segment.

Store it in the Head segment holder variable.

Push it onto the front of the snake.

Calculate the new head position.

Position the Head segment according to the new position.

#include "stdafx.h"
using namespace System;
using namespace System::Drawing;
using namespace System::Windows::Forms;
using namespace System::Collections::Generic; // Required to make lists.

public ref class snake_segment
{
	public:
			Panel^ panel;

			snake_segment( Form ^ form ) // Class Constructor.
			{ 
				panel = gcnew Panel();
				panel->BackColor = Color::Blue;
				panel->Width = 20; panel->Height = 20;
				form->Controls->Add(panel);
			}
};

public ref class Form1 : public Form 
{
	public:
			List<snake_segment^>^ segments; // A list that contains the snake segments.
			int l; // Length of the snake at begining of game.
			int size; // The number of segments in snake/list.
			int last;  // The last segment of in the snake.
			int x, y; // The coordinates of the snake segment(head).
			int x2,y2; // Values that will store the direction the snake will move.
			Timer^ Timer1; // The timer that will move the snake;
			bool game_started;

			Form1() // Class constructor.
			{	
				segments = gcnew List<snake_segment^>();
				Timer1 = gcnew Timer();
				Timer1->Interval = 2000;
				Timer1->Start();
				Timer1->Tick += gcnew System::EventHandler(this, &Form1::timer1_Tick);
				this->KeyDown += gcnew System::Windows::Forms::KeyEventHandler(this, &Form1::Form_KeyDown);
				Make_Snake();
			}
			
			void Make_Snake()
			{
				double clr = 255;
				double dclr = 128 / 2;

				for(int I = 0; I <= 3; I++)
				{
					snake_segment^ s = gcnew snake_segment(this);
					s->panel->BackColor = Color::FromArgb(0,0,clr);
					segments->Add(s);
					clr -= dclr;
				}

				for each (snake_segment^ s in segments)
				{
					l += s->panel->Width + 2;
					s->panel->Left = l;
				}	
			}

			void get_size_of_snake()
			{
				size=0;
				for each (snake_segment^ s in segments)
				{
					size++;	
				}				
			}

			void head_position() // The head position at start of game.
			{
				x = segments[size-1]->panel->Left;
				y = segments[size-1]->panel->Top;
			}

			void move_snake()
			{
				if(x2 ==1){segments[last]->panel->Left = x + segments[last]->panel->Width + 2;} // Move snake right.
				if(y2 == -1){segments[last]->panel->Left = x;segments[last]->panel->Top = x;} // Move snake down.
				x = segments[last]->panel->Left;
				y = segments[last]->panel->Top;
				last++;
				if(last >= size){last=0;}
			}

			System::Void timer1_Tick(System::Object^  sender, System::EventArgs^  e) // A timer that will move the snake;
			{
				get_size_of_snake();
				if(!game_started){head_position();game_started=true;} // Find first head position at start of game.
				move_snake();
			}

			System::Void Form_KeyDown(System::Object^ sender, System::Windows::Forms::KeyEventArgs^ e)
			{
				if(e->KeyCode == Keys::Down){y2 = -1;}
				if(e->KeyCode == Keys::Up){y2 = 1;}
				if(e->KeyCode == Keys::Left){x2 = -1;}
				if(e->KeyCode == Keys::Right){x2 = 1;}
			}
};

[STAThread]
int main()
{
    Application::Run(gcnew Form1());
}

void move_snake()
			{
				if(x2 ==1) // Move snake right.
				{
					segments[last]->panel->Left = x + segments[last]->panel->Width + 2;
					x = segments[last]->panel->Left;
					y = segments[last]->panel->Top;
					last++;
					if(last >= size){last=0;}
				} 
				if(y2 == -1) // Move snake down.
				{
					segments[last]->panel->Top = y + segments[last]->panel->Height + 2;
					segments[last]->panel->Left = x;
					x = segments[last]->panel->Left;
					y = segments[last]->panel->Top;
					last++;
					if(last >= size){last=0;}
				} 
				
			}

if ( y2 == -1 ) // Move down
{
    segments[last]->panel->Top = y + segments[head]->panel->Top + 2;
    segments[last]->panel->Left = segments[head]->panel->Left;

    head = last;
    last++;
    if ( last >= size )
    {
        last = 0;
    }

}

void check_for_collision()
			{
				for(int Tail = 0; Tail <= (size-1); Tail++)
				{
					for(int I = 0;I <= (size-1); I++)
					{
						if(I != head){segments[I]->panel->BackColor= Color::Blue;} else
						{
							segments[head]->panel->BackColor= Color::Yellow; // Color the head a different yellow.
						}

						if(head!= Tail && segments[head]->panel->Left == segments[Tail]->panel->Left && segments[head]->panel->Top == segments[Tail]->panel->Top) // Detect a collision is segments overlap.
						{
							segments[head]->panel->BackColor= Color::Red;
							Timer1->Stop();
						}
					
					}
				}
			}

#include "stdafx.h"
using namespace System;
using namespace System::Drawing;
using namespace System::Windows::Forms;
using namespace System::Collections::Generic; // Required to make lists.

public ref class snake_segment
{
	public:
			Panel^ panel; // A Panel is used to make the snake.

			snake_segment( Form ^ form ) // Class Constructor.
			{ 
				
				panel = gcnew Panel();
				//panel->BackColor= Color::Blue;
				panel->Width = 20; panel->Height = 20;
				form->Controls->Add(panel);
			}
};

public ref class Form1 : public Form 
{
	public:
			List<snake_segment^>^ segments; // A list that contains the snake segments.
			int l; // Length of the snake at begining of game.
			int size; // The number of segments in snake/list.
			int tail;  // The tail segment of the snake.
			int head;  // The head segment of the snake.
			int x, y; // The coordinates of the snake segment(head).
			int direction; // Stores the direction the snake will move.
			Timer^ Timer1; // The timer that will move the snake.
			bool game_started;
			

			Form1() // Class constructor.
			{	
				segments = gcnew List<snake_segment^>();
				Timer1 = gcnew Timer();
				Timer1->Interval = 500;
				Timer1->Start();
				Timer1->Tick += gcnew System::EventHandler(this, &Form1::timer1_Tick);
				this->KeyDown += gcnew System::Windows::Forms::KeyEventHandler(this, &Form1::Form_KeyDown);
				Make_Snake();
			}
			
			void Make_Snake()
			{
				for(int I = 0; I <= 5; I++)
				{
					snake_segment^ s = gcnew snake_segment(this);
					s->panel->BackColor = Color::FromArgb(0,0,255);
					segments->Add(s);
				}

				for each (snake_segment^ s in segments) // Position the segments at start of game.
				{
					l += s->panel->Width + 2;
					s->panel->Left = l;
				}
				get_size_of_snake();
				segments[size-1]->panel->BackColor= Color::Yellow; // Color the head yellow.
			}

			void get_size_of_snake() // Get the size of the snake when a new segment is added by eating something etc.
			{
				size=0;
				for each (snake_segment^ s in segments)
				{
					size++;	
				}
				head=size-1;
			}

			void head_position() // The head position at start of game.
			{
				x = segments[size-1]->panel->Left;
				y = segments[size-1]->panel->Top;
			}

			void move_snake()
			{
				if(direction==1) // Move snake left.
				{
					segments[tail]->panel->Location = Drawing::Point(x - 20 - 2,y); // Note using "Location" instead of "Left/Top" solved a problem where the segment would flicker as it's being moved to the head position.
					head = tail;
					x = segments[head]->panel->Left;
					y = segments[head]->panel->Top;
					tail++;
					if(tail >= size){tail=0;}
				}

				if(direction==-1) // Move snake right.
				{
					segments[tail]->panel->Location = Drawing::Point(x + 20 + 2,y);
					head = tail;
					x = segments[head]->panel->Left;
					y = segments[head]->panel->Top;
					tail++;
					if(tail >= size){tail=0;}
				}

				if(direction==2) // Move snake up;
				{
					segments[tail]->panel->Location = Drawing::Point(x,y - 20 - 2);
					head = tail;
					x = segments[head]->panel->Left;
					y = segments[head]->panel->Top;
					tail++;
					if(tail >= size){tail=0;}
				}
				
				if(direction==-2) // Move snake down;
				{
					segments[tail]->panel->Location = Drawing::Point(x,y + 20 + 2);
					head = tail;
					x = segments[head]->panel->Left;
					y = segments[head]->panel->Top;
					tail++;
					if(tail >= size){tail=0;}
				}
				
			}

			void check_for_collision()
			{
				for(int Tail = 0; Tail <= (size-1); Tail++)
				{
					for(int I = 0;I <= (size-1); I++)
					{
						if(I != head){segments[I]->panel->BackColor= Color::Blue;} else
						{
							segments[head]->panel->BackColor= Color::Yellow; // Color the head a different yellow.
						}

						if(head!= Tail && segments[head]->panel->Left == segments[Tail]->panel->Left && segments[head]->panel->Top == segments[Tail]->panel->Top) // Detect a collision is segments overlap.
						{
							segments[head]->panel->BackColor= Color::Red;
							Timer1->Stop();
						}
					
					}
				}
			}

			System::Void timer1_Tick(System::Object^  sender, System::EventArgs^  e) // A timer that will move the snake;
			{
				
				if(!game_started){head_position();game_started=true;} // Find first head position at start of game.
				move_snake();
				check_for_collision();
			}

			System::Void Form_KeyDown(System::Object^ sender, System::Windows::Forms::KeyEventArgs^ e)
			{
				if(e->KeyCode == Keys::Left){direction=1;}
				if(e->KeyCode == Keys::Right){direction=-1;}
				if(e->KeyCode == Keys::Up){direction=2;}
				if(e->KeyCode == Keys::Down){direction=-2;}

				if(e->KeyCode == Keys::Space) // Add a new segment to the snake.
				{
					snake_segment^ s = gcnew snake_segment(this);
					segments->Insert(tail,s);
					head = tail;
					segments[tail]->panel->Location = Drawing::Point(x + segments[head]->panel->Width + 2,y); 
					x = segments[head]->panel->Left;
					y = segments[head]->panel->Top;
					tail++;
					get_size_of_snake();
					if(tail >= size){tail=0;}
				}	
			}
};

[STAThread]
int main()
{
    Application::Run(gcnew Form1());
}

for (int ThisSegment = 0; ThisSegment < (size-1); ThisSegment ++ )
{
    if ( ThisSegment == head ) continue;

    if ( segments[ThisSegment]->panel->Left == segments[head]->panel->Left &&
         segments[ThisSegment]->panel->Top  == segments[head]->panel->Top )
    {
        Timer->Stop();
    }
} 

using namespace System;

using namespace System::ComponentModel;
using namespace System::Collections;
using namespace System::Windows::Forms;
using namespace System::Data;
using namespace System::Drawing;

using namespace System::Collections::Generic;

public ref class object{	
	public:			
		PictureBox^ Box3;						
		
		object( Form ^ form ) // Class Constructor.			
		{				
			Box3 = gcnew PictureBox();				
			Box3->Left = 150;				
			Box3->Top = 50;				
			Box3->Width = 100;				
			Box3->Height = 100;				
			Box3->BackColor = System::Drawing::Color::Red;				
			form->Controls->Add(Box3);			
		}
};

public ref class missile{	
	public:			
		PictureBox^ Box1;			
		
		missile( Form ^ form ) // Class Constructor.			
		{				
			Box1 = gcnew PictureBox();				
			Box1->Left = 150;				
			Box1->Top = 240;				
			Box1->Width = 10;				
			Box1->Height = 10;				
			Box1->BackColor = System::Drawing::Color::Blue;				
			form->Controls->Add(Box1);				
		}		
		
		void update()
		{
			Box1->Top--;
		}
};

public ref class Form1 : public System::Windows::Forms::Form
{
public:		
	PictureBox^ Box2;			
	object^ o1;			
	Timer^ Timer3;			
	bool x;			
	List<missile^>^ Missiles;
		
	Form1() // Class constructor.			
	{		
		Missiles = gcnew List<missile^>();

		x=false;				
		Timer3 = gcnew Timer();				
		Timer3->Interval = 1;				
		Timer3->Start();				
		Box2 = gcnew PictureBox();				
		Box2->BackColor = Color::Blue;				
		Box2->Top = 240;				
		Box2->Left = (this->Width / 2) - 40;				
		Box2->Width = 40;				
		Box2->Height = 10;				
		this->Controls->Add(Box2);				
		this->KeyDown += gcnew System::Windows::Forms::KeyEventHandler(this, &Form1::Form_KeyDown);				
		Timer3->Tick += gcnew System::EventHandler(this, &Form1::timer3_Tick);			
	}			
		
	System::Void Form_KeyDown(System::Object^ sender, System::Windows::Forms::KeyEventArgs^ e)			
	{					
		if(e->KeyCode == Keys::Up)
		{
			x=true;
			missile^ m = gcnew missile(this);
			m->Box1->Left = Box2->Left + (Box2->Width / 2) - 10;
			Missiles->Add(m);
		}				
			
		if(e->KeyCode == Keys::Left) {Box2->Left -= 4; }							
		if(e->KeyCode == Keys::Right){Box2->Left += 4; }				
		if(e->KeyCode == Keys::Down) {o1 = gcnew object(this); }			
	}			
		
	bool IsMissileOffScreen(missile^ m)
	{
		return m->Box1->Bottom < 0;
	};

	System::Void timer3_Tick(System::Object^  sender, System::EventArgs^  e)			
	{		
		for each (missile^ m in Missiles)
		{
			m->update();
				if(x==true && o1 != nullptr)				
			{					
				if (m->Box1->Top == o1->Box3->Bottom)
				{
					m->Box1->BackColor = Color::Green;
				}				
			}	
		}

		Missiles->RemoveAll(gcnew Predicate<missile^>(this, &Form1::IsMissileOffScreen));
	}			
		
	bool isColliding(PictureBox^ box1, PictureBox^ box3)			
	{	
		Rectangle r2 = o1->Box3->Bounds;				
		for each (missile^ m in Missiles)
		{
			Rectangle r1 = m->Box1->Bounds;				
			if (r1.IntersectsWith(r2)) //return true if they collide		
				return true;
		}
		return false;
	}			
};

System::Void timer3_Tick(System::Object^  sender, System::EventArgs^  e)
{
    for each (missile^ m in Missiles)
    {
        m->update();

        if(x==true && o1 != nullptr)
        {
            if (o1->Box3->Bounds.IntersectsWith(m->Box1->Bounds))
            {
                m->Box1->BackColor = Color::Green;
            }
        }
    }

    Missiles->RemoveAll(gcnew Predicate<missile^>(this, &Form1::IsMissileOffScreen));
}