C / C++ / MFC

#include <SFML/Graphics.hpp>
#include <SFML/Window.hpp>
#include <SFML/Audio.hpp>
#include <iostream>
using namespace std;
using namespace sf;
int x = 5;
constexpr int windowWidth ( 800 ), windowHeight( 600 );
constexpr float ballRadius( 10.f ), ballVelocity( 6.f );
constexpr float paddleWidth( 100.f ), paddleHeight( 20.f ), paddleVelocity( 8.f );
constexpr float blockWidth( 60.f ), blockHeight( 20.f );
constexpr int countBlocksX( 11 ), countBlocksY( 6 );
constexpr int countBlocks2X(11), countBlocks2Y(3);
bool isPlaying = true;


struct Ball
{
    CircleShape shape;
    Vector2f velocity{ -ballVelocity, -ballVelocity };

    Ball(float mX, float mY)
    {
        shape.setPosition(mX, mY);
        shape.setRadius(ballRadius);
        shape.setFillColor(Color::Yellow);
        shape.setOrigin(ballRadius, ballRadius);
    }

    void update()
    {
        //Need to make the ball bounce of the window edges
        shape.move(velocity);
        //If it's leaving on the left edge, we set a positive horizontal value.
        if (left() < 0)
            velocity.x = ballVelocity;
        //Same for the right
        else if (right() > windowWidth)
            velocity.x = -ballVelocity;
        //Top
        if (top() < 0)
            velocity.y = ballVelocity;
        //And bottom
        else if (bottom() > windowHeight)
            velocity.y = -ballVelocity;
    
    }

    float x() { return shape.getPosition().x; }
    float y() { return shape.getPosition().y; }
    float left() { return x() - shape.getRadius(); }
    float right() { return x() + shape.getRadius(); }
    float top() { return y() - shape.getRadius(); }
    float bottom() { return y() + shape.getRadius(); }
};

//Create the Rectangle shape class for the brick
struct Rectangle
{
    RectangleShape shape;
    float x()       { return shape.getPosition().x; }
    float y()       { return shape.getPosition().y; }
    float left()    { return x() - shape.getSize().x / 2.f; }
    float right()   { return x() + shape.getSize().x / 2.f; }
    float top()     { return y() - shape.getSize().y / 2.f; }
    float bottom()  { return y() + shape.getSize().y / 2.f; }
};

//Class for the paddle
struct Paddle : public Rectangle
{
    //Create a variable for speed.
    Vector2f velocity;
    //Set the variables for the paddle rectangle shape.
    Paddle(float mX, float mY)
    {
        shape.setPosition(mX, mY);
        shape.setSize({ paddleWidth, paddleHeight });
        shape.setFillColor(Color::Red);
        shape.setOrigin(paddleWidth / 2.f, paddleHeight / 2.f);
    }
    // Within the update function we check if the player is moving the paddle
    void update()
    {
        shape.move(velocity);
        //To ensure that the paddle stays inside the window we only change the Velocity when it's inside the boundaries
        //Making it impossible to move outside when the initial velocity is set to zero
        if (Keyboard::isKeyPressed(Keyboard::Key::Left) && left() > 0)
        velocity.x = -paddleVelocity;
            
        else if (Keyboard::isKeyPressed(Keyboard::Key::Right) && right() < windowWidth)
            velocity.x = paddleVelocity;
        //If the player isn't pressing a buttom (legt/right) the velocity is set to zero.
        else
            velocity.x = 0;
    }
};
//Another class for the bricks
struct Brick : public Rectangle
{
    bool destroyed{ false };

    Brick(float mX, float mY)
    {
        shape.setPosition(mX, mY);
        shape.setSize({ blockWidth, blockHeight });
        shape.setFillColor(Color::Black);
        shape.setOrigin(blockWidth / 2.f, blockHeight / 2.f);
    }
};

//C++ Feature template allows us to create a generic funtion to check if two shapes are intersecting or colliding.
template <class T1, class T2>
bool isIntersecting(T1& mA, T2& mB)
{
    return mA.right() >= mB.left() && mA.left() <= mB.right() &&
        mA.bottom() >= mB.top() && mA.top() <= mB.bottom();
}

void collisionTest(Paddle& mPaddle, Ball& mBall)
{
    if (!isIntersecting(mPaddle, mBall)) return;

    mBall.velocity.y = -ballVelocity;
    if (mBall.x() < mPaddle.x())
        mBall.velocity.x = -ballVelocity;
    else
        mBall.velocity.x = ballVelocity;
}


void collisionTest(Brick& mBrick, Ball& mBall)
{
    if (!isIntersecting(mBrick, mBall)) return;
    mBrick.destroyed = true;

    float overlapLeft{ mBall.right() - mBrick.left() };
    float overlapRight{ mBrick.right() - mBall.left() };
    float overlapTop{ mBall.bottom() - mBrick.top() };
    float overlapBottom{ mBrick.bottom() - mBall.top() };

    bool ballFromLeft(abs(overlapLeft) < abs(overlapRight));
    bool ballFromTop(abs(overlapTop) < abs(overlapBottom));

    float minOverlapX{ ballFromLeft ? overlapLeft : overlapRight };
    float minOverlapY{ ballFromTop ? overlapTop : overlapBottom };

    if (abs(minOverlapX) < abs(minOverlapY))
        mBall.velocity.x = ballFromLeft ? -ballVelocity : ballVelocity;
    else
        mBall.velocity.y = ballFromTop ? -ballVelocity : ballVelocity;
}
int main()
{
    
    //We render/create the window
    RenderWindow window(VideoMode(windowWidth, windowHeight ), "Breakout Game" );
    window.setFramerateLimit(60);
    
    Paddle paddle{ windowWidth / 2, windowHeight - 50 };
    int x = 5;
//Here we use an unconditiional goto statement to allow the user to restart the game.   
restart:
    //We reference the Ball, Paddle and Bricks
    Ball ball{ windowWidth / 2, windowHeight / 2 };
    vector<Brick> bricks;
    //vector<Brick2> bricks2;

    for (int iX{ 0 }; iX < countBlocksX; ++iX)
        for (int iY{ 0 }; iY < countBlocksY; ++iY)
            bricks.emplace_back(
                (iX + 1) * (blockWidth + 3) + 22, (iY + 2) * (blockHeight + 3));
    

    // Load the text font
    sf::Font font;
    if (!font.loadFromFile("arial.ttf"))
        return EXIT_FAILURE;

    // Initialize the pause message
    sf::Text loseGame;
    loseGame.setFont(font);
    loseGame.setCharacterSize(40);
    loseGame.setPosition(80.f, 150.f);
    loseGame.setColor(sf::Color::White);
    loseGame.setString("You lost, press 'Space' to play again.");

    // Load the sounds used in the game
    sf::SoundBuffer ballSoundBuffer;
    if (!ballSoundBuffer.loadFromFile("loseSound.wav"))
        return EXIT_FAILURE;
    sf::Sound loseGameSound(ballSoundBuffer);


    while (true)
    {
        window.clear(Color::Color(49, 79, 79));

        if (Keyboard::isKeyPressed(Keyboard::Key::Space))
            goto restart;
        if (Keyboard::isKeyPressed(Keyboard::Key::Escape)) 
            break;
        
        ball.update();
        paddle.update();
        collisionTest(paddle, ball);
        for (auto& brick : bricks) collisionTest(brick, ball);
        bricks.erase(remove_if(begin(bricks), end(bricks),
            [](const Brick& mBrick)
        {   
            return mBrick.destroyed;
        }),
            end(bricks));
        
        if (isPlaying)
        {
            window.draw(ball.shape);
            window.draw(paddle.shape);
            for (auto& brick : bricks) window.draw(brick.shape);
        }
        
        else
        {
            window.clear(Color::Black);
            // Draw the pause message
            loseGameSound.play();
            window.draw(loseGame);
            if (Keyboard::isKeyPressed(Keyboard::Key::Space))
                goto restart;
            
        }
        
        window.display();
        
    }

    return 0;
}

class CJMainForm : public CWindowImpl<CJMainForm>
{
public:
	DECLARE_WND_CLASS("JMainFrameClass") 

	CJMainForm(void);
	~CJMainForm(void);
	BOOL ShowForm(BOOL bShow = TRUE);

	BEGIN_MSG_MAP( CJMainForm )
		MESSAGE_HANDLER( WM_PAINT, OnPaint)
		MESSAGE_HANDLER(WM_LBUTTONDOWN,	OnLButtonDown)
		MESSAGE_HANDLER(WM_MOUSEMOVE, OnMouseMove)
		MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBkgnd)
		MESSAGE_HANDLER(WM_QUERYENDSESSION, OnQueryEndSession)
	END_MSG_MAP()

public:
	CXAnalogClock m_wndClock;
	CCalenderWnd m_wndCalender;
	CWindow m_wndPrjTree;
	HBRUSH m_brBackGround;
	SIZE m_szbrBackGround;

protected:
	LRESULT OnPaint( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled );
	LRESULT OnLButtonDown( UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled );
	LRESULT OnMouseMove(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
	LRESULT OnEraseBkgnd(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
	LRESULT OnQueryEndSession(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
	
	HICON m_icoExit;
	HICON m_icoPrevYear;
	HICON m_icoNextYear;
	HICON m_icoPrevMonth;
	HICON m_icoNextMonth;
	HICON m_icoToday;
	HFONT m_icoTextFont;
	int m_CurrentRegion, m_nOldRegion;

	HICON m_icoNodeClosed;
	HICON m_cioNodeOpen;
	HICON m_icoAttrib;
	enum EnToolBtnState
	{
		tbs_normal = 0,
		tbs_hover,
		tbs_prress_down,
	}m_nToolBtnState[6];
	RECT m_rcToolBtn[6];

	HBRUSH m_brToolBtnHover;
	int m_nLastToolBtnHit;

	enum SKIN
	{
		cpbob = 0,
		cpnobob,
		darkblue,
		silver,
		gold,
		black,
		lightblue,
		green,
		red,
		rose,
		aqua,
		neonblue,
		bluestreak,
		crystalgreen,
		crystalblack,
		crystalblue,
		crystalred,
		crystalyellow,
		silverring,
		minimal,
		white,
	};

	void SetSkin();

	struct SKIN_MENU_DATA
	{
		UINT nID;
		UINT nClockFaceBitmapId;
		UINT nDateBitmapId;
		TCHAR *pszName;
	};
	static SKIN_MENU_DATA	m_Skins[];
	static int				m_nSkins;
	SKIN					m_eSkin;
	ATL::CString m_strSkin;

	SKIN GetSkinFromName(LPCTSTR lpszSkinName);

private:
	void ParseNode(IDispatch* pNode,HTREEITEM hParent);
	HTREEITEM CJMainForm::InsertTreeItem(HTREEITEM hItem, LPCTSTR lpszItem, int nImage,
	int nSelectedImage, HTREEITEM hParent, HTREEITEM hInsertAfter = TVI_LAST);
	BOOL SetTreeItem(HTREEITEM hItem, UINT nMask, LPCTSTR lpszItem, int nImage,
	int nSelectedImage, UINT nState, UINT nStateMask, LPARAM lParam);

	CXmlDocumentWrapper m_xmlDoc;
	HIMAGELIST m_imageListTreeView;
};

extern CJMainForm* g_pMainForm;

BOOL CJMainForm::ShowForm(BOOL bShow)
{
	if (!m_hWnd || !IsWindow())
		Create(::GetDesktopWindow(), 0, 0, (WS_POPUP | WS_VISIBLE | WS_CLIPCHILDREN) & (~WS_CAPTION), WS_EX_CONTROLPARENT | WS_EX_TOOLWINDOW);

	DWORD dw = GetLastError();
	if (m_hWnd && bShow && IsWindow())
	{
		RECT rectWorkArea;
		SystemParametersInfo(SPI_GETWORKAREA, 0, (LPVOID)&rectWorkArea, 0);
		MoveWindow(&rectWorkArea);
		SetWindowPos(HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
	}

	if (!m_wndCalender.m_hWnd)
	{
		RECT rc = {0};
		rc.left = 64;
		rc.right = rc.left + 64 * 7 + 1;
		rc.top = 12;
		rc.bottom = rc.top + 64 * 6 + 24 + 1;
		rc.bottom += 24;
		m_wndCalender.Create(m_hWnd, &rc,"", WS_CHILD | WS_VISIBLE);
	}

	if (!m_wndClock.m_hWnd)
	{
		RECT rc = {0};
		rc.left = 64 + 12;
		rc.right = rc.left + 100;
		rc.top = 12;
		rc.bottom = rc.top + 64 * 6 + 24 + 24 + 1;
		rc.top = rc.bottom + 12;
		rc.bottom = rc.top + 100;
		m_wndClock.Create(m_hWnd, &rc,"", WS_CHILD | WS_VISIBLE);
		m_wndClock.SetHourAdjust(0);

		if (!m_strSkin.IsEmpty())
		{
			m_eSkin = GetSkinFromName(m_strSkin);
			SetSkin();
		}

		// start the clock
		m_wndClock.Run();
	}

	if (!m_wndPrjTree.m_hWnd)
	{
		if (!m_imageListTreeView)
		{
			m_imageListTreeView = ::ImageList_Create(16, 16,ILC_COLOR24|ILC_MASK,3,1);
			m_icoNodeClosed = (HICON)::LoadImage(g_hInstance , MAKEINTRESOURCE(IDI_NODECLOSED), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
			m_cioNodeOpen = (HICON)::LoadImage(g_hInstance , MAKEINTRESOURCE(IDI_NODEOPEN), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
			m_icoAttrib = (HICON)::LoadImage(g_hInstance , MAKEINTRESOURCE(IDI_ATTRIB), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
			ImageList_AddIcon(m_imageListTreeView,m_icoNodeClosed);
			ImageList_AddIcon(m_imageListTreeView, m_cioNodeOpen);
			ImageList_AddIcon(m_imageListTreeView, m_icoAttrib);
		}

		RECT rc = {0};
		rc.left = 64 * 8 + 12;
		rc.right = rc.left + 64 * 4;
		rc.top = 12;
		rc.bottom = rc.top + 64 * 6 + 24 + 1;
		rc.bottom += 24;
		m_wndPrjTree.Create(WC_TREEVIEWA,m_hWnd, &rc,"prjview", WS_CHILD | WS_VISIBLE | WS_BORDER | WS_TABSTOP
			| TVS_HASBUTTONS | TVS_HASLINES | TVS_LINESATROOT | TVS_INFOTIP |TVS_TRACKSELECT|TVS_SINGLEEXPAND| TVS_DISABLEDRAGDROP);
		//m_wndPrjTree.ModifyStyleEx(0L, WS_EX_NOPARENTNOTIFY | WS_EX_CLIENTEDGE);
		::SendMessage(m_wndPrjTree.m_hWnd, TVM_SETIMAGELIST, (WPARAM)TVSIL_NORMAL, (LPARAM)m_imageListTreeView);
		::SendMessage(m_wndPrjTree.m_hWnd, TVM_SETBKCOLOR, 0, (LPARAM)RGB(224, 255, 224));
		m_xmlDoc.Load("F:\\XmlView\\UpgradeLog.XML");
		ParseNode(m_xmlDoc.AsNode(),TVI_ROOT);
	}

	if (m_hWnd && !bShow && IsWindow())
		ShowWindow(SW_HIDE);

	return (m_hWnd != NULL);
}