Project Lessons

// RootNode 
 
// include the files we need
#include "Node.h"
#include "Config.h"
#include "MenuScreen.h" 
#include "SimpleButton.h" 
 
class RootNode : public Node // publicly inherits from Node
{
public:
    // Constructor                                            // initializer list
    RootNode(SDL_Renderer* renderer_in, Node* parentNode_in): Node(renderer_in, parentNode_in)
    {
 
        // first create screens for the node
        MenuScreen* screen1 = createMenuScreen();
        MenuScreen* screen2 = createMenuScreen();
 
        // create images and text to put on the screen using an ArcadeTexture object
        ArcadeTexture* screen1Background = createImage(renderer_in, "rootNodeImages/rootNodeScreenBackground.png", true);
        ArcadeTexture* screen2Background = createImage(renderer_in, "rootNodeImages/rootNodeScreenBackground.png", true);

        ArcadeTexture* screen1Text = createSimpleText(renderer_in, "fonts/retro/italic.ttf", 100, "screen 1", 255, 255, 0);
        screen1Text->setPosition(windowWidth / 2 - screen1Text->getWidth() / 2, 25);

        ArcadeTexture* screen2Text = createSimpleText(renderer_in, "fonts/retro/italic.ttf", 100, "screen 2", 255, 255, 0);
        screen2Text->setPosition(windowWidth / 2 - screen2Text->getWidth() / 2, 25);

        // add the images and text to the screen after creating them
        screen1->addTextureToScreen(screen1Background);
        screen1->addTextureToScreen(screen1Text);

        screen2->addTextureToScreen(screen2Background);
        screen2->addTextureToScreen(screen2Text);
 
        // make a text button to put on the screen1
        SimpleButton* button1 = createSimpleTextButton(renderer_in, "fonts/pixel/classic.ttf", 30, "gotoscreen2", 255, 0, 0);
        button1->setButtonPosition(windowWidth / 2 - button1->getWidth() / 2, screen1Text->getY() + screen1Text->getHeight() + 50);

        // give this button an action
        button1->setButtonAction(createAction(MOVE_SCREENS, screen2));
       
        // make a text button to put on the screen2
        SimpleButton* button2 = createSimpleTextButton(renderer_in, "fonts/pixel/classic.ttf", 30, "gotoscreen1", 255, 0, 0);
        button2->setButtonPosition(windowWidth / 2 - button2->getWidth() / 2, screen2Text->getY() + screen2Text->getHeight() + 50);
       
        // give this button an action       
        button2->setButtonAction(createAction(MOVE_SCREENS, screen1));

        // add the buttons to their screens
        screen1->addButtonToScreen(button1);
        screen2->addButtonToScreen(button2);
 
        // add the screens to the node
        this->addScreen(screen1);
        this->addScreen(screen2);

        // tell the node the current screen
        this->setCurrentScreen(screen1);
    }
};

// main.cpp
#include "SDL.h"
#include "SDL_mixer.h"
#include "SDL_ttf.h"
#include "SDL_image.h"
#include "Config.h"
#include <stdio.h>
#include "RootNode.h"

// declaring pointer to objects that main needs, initialize to null
// these objects are created in main because they are needed for the outermost loop
SDL_Window* arcadeSystemWindow = nullptr;
SDL_Renderer* arcadeSystemRenderer = nullptr;
TTF_Font* font = nullptr;

// initialization function, initializes above objects and calls some SDL initialization functions
bool init()
{
	// Initialization flag
	bool success = true;

	// Initialize SDL
	if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0)
	{
		printf("SDL could not initialize! SDL Error: %s\n", SDL_GetError());
		success = false;
	}
	else
	{
		// Create window in the center of the screen
		arcadeSystemWindow = SDL_CreateWindow("Arcade System", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, windowWidth, windowHeight, SDL_WINDOW_SHOWN);
		if (arcadeSystemWindow == NULL)	
		{
			printf("Window could not be created! SDL Error: %s\n", SDL_GetError());
			success = false;
		}
		else
		{
			// initialize renderer, set the background as white for the wwindow, sync the renderer with the monitor refresh rate
			arcadeSystemRenderer = SDL_CreateRenderer(arcadeSystemWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
			SDL_SetRenderDrawColor(arcadeSystemRenderer, 0xFF, 0xFF, 0xFF, 0xFF);
		}
		// Initialize SDL_mixer
		if (Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 2048) < 0)
		{
			printf("SDL_mixer could not initialize! SDL_mixer Error: %s\n", Mix_GetError());
			success = false;
		}
		// initialize true type font 
		if (TTF_Init() == -1)
		{
			printf("SDL_ttf could not initialize! SDL_ttf Error: %s\n", TTF_GetError());
			success = false;
		}

	}
	return success;
}

int main(int argc, char* argv[])
{	
	// first call initialization
	if (!init())
	{
		printf("Failed to initialize!\n");
	}
	// if initializes successfully then continue
	else
	{
		bool quit = false;
		RootNode currentNode(arcadeSystemRenderer, nullptr);
		while (!quit)
		{	
			// handle events on queue until empty
			SDL_Event e;
			while (SDL_PollEvent(&e) != 0)
			{
				currentNode.update(&e);
				// user requests quit by clicking window X
				if (e.type == SDL_QUIT)
				{
					quit = true;
				}
			}
			currentNode.update(nullptr);
			currentNode.render(arcadeSystemRenderer);
			SDL_RenderPresent(arcadeSystemRenderer);
		}
	}
	
	return 0;
}

// main.cpp
#include "SDL.h"
#include "SDL_mixer.h"
#include "SDL_ttf.h"
#include "SDL_image.h"
#include "Config.h"
#include <stdio.h>
#include "RootNode.h"

// declaring pointer to objects that main needs, initialize to null
	// these objects are created in main because they are needed for the outermost loop
	SDL_Window* arcadeSystemWindow = nullptr;
	SDL_Renderer* arcadeSystemRenderer = nullptr;
	TTF_Font* font = nullptr;
	
	// initialization function, initializes above objects and calls some SDL initialization functions
	bool init()
	{
		// Initialization flag
		bool success = true;
	
		// Initialize SDL
		if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0)
		{
			printf("SDL could not initialize! SDL Error: %s\n", SDL_GetError());
			success = false;
		}
		else
		{
			// Create window in the center of the screen
			arcadeSystemWindow = SDL_CreateWindow("Arcade System", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, windowWidth, windowHeight, SDL_WINDOW_SHOWN);
			if (arcadeSystemWindow == NULL)	
			{
				printf("Window could not be created! SDL Error: %s\n", SDL_GetError());
				success = false;
			}
			else
			{
				// initialize renderer, set the background as white for the wwindow, sync the renderer with the monitor refresh rate
				arcadeSystemRenderer = SDL_CreateRenderer(arcadeSystemWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
				SDL_SetRenderDrawColor(arcadeSystemRenderer, 0xFF, 0xFF, 0xFF, 0xFF);
			}
			// Initialize SDL_mixer
			if (Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 2048) < 0)
			{
				printf("SDL_mixer could not initialize! SDL_mixer Error: %s\n", Mix_GetError());
				success = false;
			}
			// initialize true type font 
			if (TTF_Init() == -1)
			{
				printf("SDL_ttf could not initialize! SDL_ttf Error: %s\n", TTF_GetError());
				success = false;
			}
	
		}
		return success;
	}
	

int main(int argc, char* argv[])
{	
	// first call initialization
	if (!init())
	{
		printf("Failed to initialize!\n");
	}
	// if initializes successfully then continue
	else
	{
		bool quit = false;
		RootNode currentNode(arcadeSystemRenderer, nullptr);
		while (!quit)
		{	
			// handle events on queue until empty
			SDL_Event e;
			while (SDL_PollEvent(&e) != 0)
			{
				currentNode.update(&e);
				// user requests quit by clicking window X
				if (e.type == SDL_QUIT)
				{
					quit = true;
				}
			}
			currentNode.update(nullptr);
			currentNode.render(arcadeSystemRenderer);
			SDL_RenderPresent(arcadeSystemRenderer);
		}
	}
	
	return 0;
}

// first call initialization
	if (!init())
	{
		printf("Failed to initialize!\n");
	}

else
	{
		bool quit = false;
		RootNode currentNode(arcadeSystemRenderer, nullptr);
		while (!quit)
		{	
			// handle events on queue until empty
			SDL_Event e;
			while (SDL_PollEvent(&e) != 0)
			{
				currentNode.update(&e);
				// user requests quit by clicking window X
				if (e.type == SDL_QUIT)
				{
					quit = true;
				}
			}
			currentNode.update(nullptr);
			currentNode.render(arcadeSystemRenderer);
			SDL_RenderPresent(arcadeSystemRenderer);
		}
	}

// RootNode 
 
// include the files we need
#include "Node.h"
#include "Config.h"
#include "MenuScreen.h" 
#include "SimpleButton.h" 

class RootNode : public Node // publicly inherits from Node
	{
		public:
			// Constructor                                            // initializer list
			RootNode(SDL_Renderer* renderer_in, Node* parentNode_in): Node(renderer_in, parentNode_in)
			{
		

// first create screens for the node
	MenuScreen* screen1 = createMenuScreen();
	MenuScreen* screen2 = createMenuScreen();

// create images and text to put on the screen using an ArcadeTexture object
	ArcadeTexture* screen1Background = createImage(renderer_in, "rootNodeImages/rootNodeScreenBackground.png", true);
	ArcadeTexture* screen2Background = createImage(renderer_in, "rootNodeImages/rootNodeScreenBackground.png", true);

	ArcadeTexture* screen1Text = createSimpleText(renderer_in, "fonts/retro/italic.ttf", 100, "screen 1", 255, 255, 0);
	screen1Text->setPosition(windowWidth / 2 - screen1Text->getWidth() / 2, 25);

	ArcadeTexture* screen2Text = createSimpleText(renderer_in, "fonts/retro/italic.ttf", 100, "screen 2", 255, 255, 0);
	screen2Text->setPosition(windowWidth / 2 - screen2Text->getWidth() / 2, 25);

// add the images and text to the screen after creating them
	screen1->addTextureToScreen(screen1Background);
	screen1->addTextureToScreen(screen1Text);

	screen2->addTextureToScreen(screen2Background);
	screen2->addTextureToScreen(screen2Text);

// make a text button to put on screen1
	SimpleButton* button1 = createSimpleTextButton(renderer_in, "fonts/pixel/classic.ttf", 30, "gotoscreen2", 255, 0, 0);
	button1->setButtonPosition(windowWidth / 2 - button1->getWidth() / 2, screen1Text->getY() + screen1Text->getHeight() + 50);

	// make a text button to put on screen2
	SimpleButton* button2 = createSimpleTextButton(renderer_in, "fonts/pixel/classic.ttf", 30, "gotoscreen1", 255, 0, 0);
	button2->setButtonPosition(windowWidth / 2 - button2->getWidth() / 2, screen2Text->getY() + screen2Text->getHeight() + 50);

 // give this button an action
	button1->setButtonAction(createAction(MOVE_SCREENS, screen2));
       
	// give this button an action       
	button2->setButtonAction(createAction(MOVE_SCREENS, screen1));

// add the buttons to their screens
	screen1->addButtonToScreen(button1);
	screen2->addButtonToScreen(button2);

	// add the screens to the node
	this->addScreen(screen1);
	this->addScreen(screen2);

	// tell the node the current screen
	this->setCurrentScreen(screen1);
}
};

// main.cpp
#include "SDL.h"
#include "SDL_mixer.h"
#include "SDL_ttf.h"
#include "SDL_image.h"
#include "Config.h"
#include <stdio.h>
#include "GameNode.h"

// declaring pointer to objects that main needs, initialize to null
// these objects are created in main because they are needed for the outermost loop
SDL_Window* arcadeSystemWindow = nullptr;
SDL_Renderer* arcadeSystemRenderer = nullptr;
TTF_Font* font = nullptr;

// initialization function, initializes above objects and calls some SDL initialization functions
bool init()
{
	// Initialization flag
	bool success = true;

	// Initialize SDL
	if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0)
	{
		printf("SDL could not initialize! SDL Error: %s\n", SDL_GetError());
		success = false;
	}
	else
	{
		// Create window in the center of the screen
		arcadeSystemWindow = SDL_CreateWindow("Arcade System", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, windowWidth, windowHeight, SDL_WINDOW_SHOWN);
		if (arcadeSystemWindow == NULL)	
		{
			printf("Window could not be created! SDL Error: %s\n", SDL_GetError());
			success = false;
		}
		else
		{
			// initialize renderer, set the background as white for the wwindow, sync the renderer with the monitor refresh rate
			arcadeSystemRenderer = SDL_CreateRenderer(arcadeSystemWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
			SDL_SetRenderDrawColor(arcadeSystemRenderer, 0xFF, 0xFF, 0xFF, 0xFF);
		}
		// Initialize SDL_mixer
		if (Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 2048) < 0)
		{
			printf("SDL_mixer could not initialize! SDL_mixer Error: %s\n", Mix_GetError());
			success = false;
		}
		// initialize true type font 
		if (TTF_Init() == -1)
		{
			printf("SDL_ttf could not initialize! SDL_ttf Error: %s\n", TTF_GetError());
			success = false;
		}

	}
	return success;
}

int main(int argc, char* argv[])
{	
	// first call initialization
	if (!init())
	{
		printf("Failed to initialize!\n");
	}
	// if initializes successfully then continue
	else
	{
		bool quit = false;
		GameNode currentNode(arcadeSystemRenderer, nullptr);
		while (!quit)
		{	
			// handle events on queue until empty
			SDL_Event e;
			while (SDL_PollEvent(&e) != 0)
			{
				currentNode.update(&e);
				// user requests quit by clicking window X
				if (e.type == SDL_QUIT)
				{
					quit = true;
				}
			}
			currentNode.update(nullptr);
			currentNode.render(arcadeSystemRenderer);
			SDL_RenderPresent(arcadeSystemRenderer);
		}
	}
	
	return 0;
}

// Paddle.h

#ifndef PADDLE_H
#define PADDLE_H

#include "Entity.h"

class Paddle : public Entity
{
public:
	Paddle();
	void update(SDL_Event* event);
};

#endif

// Paddle.cpp

	#include "Paddle.h"

	Paddle::Paddle()
	{
		setXPos(0);
		setYPos(0);
		setXVelocity(0);
		setYVelocity(0);
	}
	
	void Paddle::update(SDL_Event* event)
	{
		if ((event) && ((*event).type == SDL_KEYDOWN) && (*event).key.repeat == 0)
		{
			switch ((*event).key.keysym.sym)
			{
			case SDLK_RIGHT:
			{
				printf("\nRIGHT\n");
				setXVelocity(getXVelocity() + 8);
				break;
			}
			case SDLK_LEFT:
			{
				printf("\nLEFT\n");
				setXVelocity(getXVelocity() - 8);
				break;
			}
			}
		}
		else if ((event != nullptr) && (*event).type == SDL_KEYUP && (*event).key.repeat == 0)
		{
			switch ((*event).key.keysym.sym)
			{
			case SDLK_RIGHT:
			{
				setXVelocity(getXVelocity()-8);
				break;
			}
			case SDLK_LEFT:
			{
				setXVelocity(getXVelocity()+8);
				break;
			}
			}
		}
		if (!event)
		{
			setXPos(getXPos() + getXVelocity());
		}
	}
	

void Paddle::update(SDL_Event* event)
{
	if ((event) && ((*event).type == SDL_KEYDOWN) && (*event).key.repeat == 0)
	{
		switch ((*event).key.keysym.sym)
		{
		case SDLK_RIGHT:
		{
			printf("\nRIGHT\n");
			setXVelocity(getXVelocity() + 8);
			break;
		}
		case SDLK_LEFT:
		{
			printf("\nLEFT\n");
			setXVelocity(getXVelocity() - 8);
			break;
		}
		}
	}

else if ((event) && (*event).type == SDL_KEYUP && (*event).key.repeat == 0)
	{
		switch ((*event).key.keysym.sym)
		{
		case SDLK_RIGHT:
		{
			setXVelocity(getXVelocity()-8);
			break;
		}
		case SDLK_LEFT:
		{
			setXVelocity(getXVelocity()+8);
			break;
		}
		}
	}

if (!event)
	{
		setXPos(getXPos() + getXVelocity());
	}
	

// SimpleGame.h

#ifndef SIMPLE_GAME_H
#define SIMPLE_GAME_H

#include "GameScreen.h"
#include "Ball.h"
#include "Config.h"

// need to include the paddle class
#include "Paddle.h"

class SimpleGame : public GameScreen
{
    public:
        SimpleGame();
        Action update(SDL_Event* event);
        void logic();

        void newGame();

        void setBall(Ball* ball_in) {ball = ball_in;}
        Ball* getBall() {return ball;}
        
        // accessor and mutator methods
        void setPaddle(Paddle* paddle_in) {paddle = paddle_in;}
        Paddle* getPaddle() {return paddle;}
    private:
        Ball* ball;
        // add paddle as an attribute of the game
        Paddle* paddle;
};

#endif

void SimpleGame::newGame()
	{
		setGameState(true);
		ball->setXPos(0);
		ball->setYPos(0);
		ball->setXVelocity(2);
		ball->setYVelocity(5);
		paddle->setXPos(0);
		paddle->setYPos(windowHeight-paddle->getHeight());
		paddle->setXVelocity(0);
		setisNewGame(false);
	}
	

void SimpleGame::logic()
	{
		// ball hits left side of screen
		if(getBall()->getXPos() < 0)
		{
			getBall()->setXPos(0);
			getBall()->setXVelocity(-(getBall()->getXVelocity()));
		}
	
		// ball hits top of screen
		else if(getBall()->getYPos() < 0)
		{
			getBall()->setYPos(0);
			getBall()->setYVelocity(-(getBall()->getYVelocity()));
		}
	
		// ball hits right side of screen
		else if(getBall()->getXPos() + getBall()->getWidth() > windowWidth)
		{
			getBall()->setXPos(windowWidth - getBall()->getWidth());
			getBall()->setXVelocity(-(getBall()->getXVelocity()));
		}
	
		// ball hits bottom of screen
		else if(getBall()->getYPos() + getBall()->getHeight() > windowHeight)
		{
			// getBall()->setYPos(windowHeight - getBall()->getHeight());
			// getBall()->setYVelocity(-(getBall()->getYVelocity()));
			setGameState(false);
		}
	
		// -----------------------------------------------------------
	
		// paddle collisions
		SDL_Rect ballRegion = getBall()->getGameObjectTexture()->getImageDestination();
		SDL_Rect paddleRegion = getPaddle()->getGameObjectTexture()->getImageDestination();
	
		if (SDL_HasIntersection(&ballRegion, &paddleRegion))
		{
			getBall()->setYPos(480 - getBall()->getHeight() - getPaddle()->getHeight());
			getBall()->setYVelocity(-(getBall()->getYVelocity()));
	
			int ratio = (getBall()->getXPos() + getBall()->getWidth() / 2) - (getPaddle()->getXPos() + getPaddle()->getWidth() / 2);
			ball->setXVelocity(ratio / 4);
		}
	
		if(paddle->getXPos() < 0)
		{
			paddle->setXPos(0);
		}
		if(paddle ->getXPos() + paddle->getWidth() > windowWidth)
		{
			paddle->setXPos(windowWidth-paddle->getWidth());
		}
	}
	

// ball hits bottom of screen
		else if(getBall()->getYPos() + getBall()->getHeight() > windowHeight)
		{
			// getBall()->setYPos(windowHeight - getBall()->getHeight());
			// getBall()->setYVelocity(-(getBall()->getYVelocity()));
			setGameState(false);
		}
	

// paddle collisions
    SDL_Rect ballRegion = getBall()->getGameObjectTexture()->getImageDestination();
	SDL_Rect paddleRegion = getPaddle()->getGameObjectTexture()->getImageDestination();

	if (SDL_HasIntersection(&ballRegion, &paddleRegion))
	{
		getBall()->setYPos(480 - getBall()->getHeight() - getPaddle()->getHeight());
		getBall()->setYVelocity(-(getBall()->getYVelocity()));

		int ratio = (getBall()->getXPos() + getBall()->getWidth() / 2) - (getPaddle()->getXPos() + getPaddle()->getWidth() / 2);
		ball->setXVelocity(ratio / 4);
	}

    if(paddle->getXPos() < 0)
    {
        paddle->setXPos(0);
    }
    if(paddle ->getXPos() + paddle->getWidth() > windowWidth)
    {
        paddle->setXPos(windowWidth-paddle->getWidth());
    }

// GameNode.h

	#include "Node.h"
	#include "Config.h"
	#include "SimpleGame.h"
	
	
	class GameNode : public Node
	{
		public: 
			GameNode(SDL_Renderer* renderer_in, Node* parentNode_in): Node(renderer_in, parentNode_in)
			{
				SimpleGame* game = new SimpleGame;
				game->addTextureToScreen(createImage(renderer_in, "brickBreakerNodeImages/brickBreakerScreen.png", true));
	
				Ball* ball = new Ball;
				ArcadeTexture* ballTexture = createImage(renderer_in, "brickBreakerNodeImages/ballTexture.png");
	
				ball->setGameObjectTexture(ballTexture);
				ball->setState(true);
	
				game->addEntity(ball);
				game->addMovingEntity(ball);
				game->setBall(ball);
	
				Paddle* paddle = new Paddle;
				ArcadeTexture* paddleTexture = createImage(renderer_in, "brickBreakerNodeImages/paddleTexture.png");
				
				paddle->setState(true);
				paddle->setGameObjectTexture(paddleTexture);
				
				game->addEntity(paddle);
				game->addMovingEntity(paddle);
				game->setPaddle(paddle);
	
				game->setisNewGame(true);
				game->setGameState(true);
	
				MenuScreen* gameOverScreen = createMenuScreen();
				gameOverScreen->addTextureToScreen(createImage(renderer_in, "brickBreakerNodeImages/pauseScreenBackgroundTexture.png", true));
				ArcadeTexture* gameOverText = createSimpleText(renderer_in, "fonts/retro/italic.ttf", 100, "GAME OVER", 255, 255, 0);
				gameOverText->setPosition(windowWidth / 2 - gameOverText->getWidth() / 2, 25);
				gameOverScreen->addTextureToScreen(gameOverText);
	
				SimpleButton* mainMenuButton2 = createSimpleTextButton(renderer_in, "fonts/pixel/classic.ttf", 30,"GAME MENU", 255, 0, 0);
				mainMenuButton2->setButtonPosition(windowWidth / 2 - mainMenuButton2->getWidth() / 2, 200);
				mainMenuButton2->setButtonAction(createAction(MOVE_NODES, getParentNode()));
				gameOverScreen->addButtonToScreen(mainMenuButton2);
	
				SimpleButton* newGameButton = createSimpleTextButton(renderer_in, "fonts/pixel/classic.ttf", 30, "NEW GAME", 255, 0, 0);
				newGameButton->setButtonPosition(windowWidth / 2 - newGameButton->getWidth() / 2, 270);
				newGameButton->setButtonAction(createAction(MOVE_SCREENS, game));
				
				gameOverScreen->addButtonToScreen(newGameButton);
				game->setGameOverScreen(gameOverScreen);
				
	//////////////////////////////////////////////////////////////////////////////
				MenuScreen* pauseScreen = createMenuScreen();
				pauseScreen->addTextureToScreen(createImage(renderer_in, "brickBreakerNodeImages/pauseScreenBackgroundTexture.png"));
				ArcadeTexture* pauseText = createSimpleText(renderer_in, "fonts/retro/italic.ttf", 100,"PAUSE", 255, 255, 0);
				pauseText->setPosition(windowWidth / 2 - pauseText->getWidth() / 2, 25);
				pauseScreen->addTextureToScreen(pauseText);
	
	
				SimpleButton* resumeButton = createSimpleTextButton(renderer_in, "fonts/pixel/classic.ttf", 30,"RESUME", 255, 0, 0);
				resumeButton->setButtonPosition(windowWidth / 2 - resumeButton->getWidth() / 2, 270);
				resumeButton->setButtonAction(createAction(MOVE_SCREENS, game));
			   
				pauseScreen->addButtonToScreen(resumeButton);
				game->setPauseScreen(pauseScreen);
				
	
				this->addScreen(game);
				this->addScreen(pauseScreen);
				this->addScreen(gameOverScreen);
	
				this->setCurrentScreen(game);
			}
	
			void enter()
			{
				setCurrentScreen(getScreenList()[0]);
			}
	};
	

            Paddle* paddle = new Paddle;
	ArcadeTexture* paddleTexture = createImage(renderer_in, "brickBreakerNodeImages/paddleTexture.png");
            
	paddle->setState(true);
	paddle->setGameObjectTexture(paddleTexture);
	
	game->addEntity(paddle);
	game->addMovingEntity(paddle);
	game->setPaddle(paddle);

            MenuScreen* gameOverScreen = createMenuScreen();
	gameOverScreen->addTextureToScreen(createImage(renderer_in, "brickBreakerNodeImages/pauseScreenBackgroundTexture.png", true));
	ArcadeTexture* gameOverText = createSimpleText(renderer_in, "fonts/retro/italic.ttf", 100, "GAME OVER", 255, 255, 0);
	gameOverText->setPosition(windowWidth / 2 - gameOverText->getWidth() / 2, 25);
	gameOverScreen->addTextureToScreen(gameOverText);

	SimpleButton* mainMenuButton2 = createSimpleTextButton(renderer_in, "fonts/pixel/classic.ttf", 30,"GAME MENU", 255, 0, 0);
	mainMenuButton2->setButtonPosition(windowWidth / 2 - mainMenuButton2->getWidth() / 2, 200);
	mainMenuButton2->setButtonAction(createAction(MOVE_NODES, getParentNode()));
	gameOverScreen->addButtonToScreen(mainMenuButton2);

	SimpleButton* newGameButton = createSimpleTextButton(renderer_in, "fonts/pixel/classic.ttf", 30, "NEW GAME", 255, 0, 0);
	newGameButton->setButtonPosition(windowWidth / 2 - newGameButton->getWidth() / 2, 270);
	newGameButton->setButtonAction(createAction(MOVE_SCREENS, game));
	
	gameOverScreen->addButtonToScreen(newGameButton);
	game->setGameOverScreen(gameOverScreen);

            MenuScreen* pauseScreen = createMenuScreen();
	pauseScreen->addTextureToScreen(createImage(renderer_in, "brickBreakerNodeImages/pauseScreenBackgroundTexture.png"));
	ArcadeTexture* pauseText = createSimpleText(renderer_in, "fonts/retro/italic.ttf", 100,"PAUSE", 255, 255, 0);
	pauseText->setPosition(windowWidth / 2 - pauseText->getWidth() / 2, 25);
	pauseScreen->addTextureToScreen(pauseText);


	SimpleButton* resumeButton = createSimpleTextButton(renderer_in, "fonts/pixel/classic.ttf", 30,"RESUME", 255, 0, 0);
	resumeButton->setButtonPosition(windowWidth / 2 - resumeButton->getWidth() / 2, 270);
	resumeButton->setButtonAction(createAction(MOVE_SCREENS, game));
   
	pauseScreen->addButtonToScreen(resumeButton);
	game->setPauseScreen(pauseScreen);

this->addScreen(game);
	this->addScreen(pauseScreen);
	this->addScreen(gameOverScreen);
	

void enter()
{
		setCurrentScreen(getScreenList()[0]);
}

// RootNode 
 
	// include the files we need
	#include "Node.h"
	#include "Config.h"
	#include "MenuScreen.h" 
	#include "SimpleButton.h" 
	#include "GameNode.h"
	 
	class RootNode : public Node // publicly inherits from Node
	{
	private:
	GameNode* gameNode;
	
	public:
		// Constructor                                            // initializer list
		RootNode(SDL_Renderer* renderer_in, Node* parentNode_in): Node(renderer_in, parentNode_in)
		{
			gameNode = new GameNode(getRenderer(), this);
			children.push_back(gameNode);
			// first create screens for the node
			MenuScreen* screen1 = createMenuScreen();
	 
			// create images and text to put on the screen using an ArcadeTexture object
			ArcadeTexture* screen1Background = createImage(renderer_in, "rootNodeImages/rootNodeScreenBackground.png", true);
	
			ArcadeTexture* screen1Text = createSimpleText(renderer_in, "fonts/retro/italic.ttf", 100, "MAIN MENU", 255, 255, 0);
			screen1Text->setPosition(windowWidth / 2 - screen1Text->getWidth() / 2, 25);
	
			// add the images and text to the screen after creating them
			screen1->addTextureToScreen(screen1Background);
			screen1->addTextureToScreen(screen1Text);
	 
			// make a text button to put on the screen1
			SimpleButton* button1 = createSimpleTextButton(renderer_in, "fonts/pixel/classic.ttf", 30, "PLAY SIMPLE GAME", 255, 0, 0);
			button1->setButtonPosition(windowWidth / 2 - button1->getWidth() / 2, screen1Text->getY() + screen1Text->getHeight() + 50);
	
			// give this button an action
			button1->setButtonAction(createAction(MOVE_NODES, gameNode));
		   
			// add the buttons to their screens
			screen1->addButtonToScreen(button1);
	 
			// add the screens to the node
			this->addScreen(screen1);
	
			// tell the node the current screen
			this->setCurrentScreen(screen1);
		}
	};
	

// main.cpp
	#include "SDL.h"
	#include "SDL_mixer.h"
	#include "SDL_ttf.h"
	#include "SDL_image.h"
	#include "Config.h"
	#include <stdio.h>
	#include "RootNode.h"
	
	// declaring pointer to objects that main needs, initialize to null
	// these objects are created in main because they are needed for the outermost loop
	SDL_Window* arcadeSystemWindow = nullptr;
	SDL_Renderer* arcadeSystemRenderer = nullptr;
	TTF_Font* font = nullptr;
	
	// initialization function, initializes above objects and calls some SDL initialization functions
	bool init()
	{
		// Initialization flag
		bool success = true;
	
		// Initialize SDL
		if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0)
		{
			printf("SDL could not initialize! SDL Error: %s\n", SDL_GetError());
			success = false;
		}
		else
		{
			// Create window in the center of the screen
			arcadeSystemWindow = SDL_CreateWindow("Arcade System", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, windowWidth, windowHeight, SDL_WINDOW_SHOWN);
			if (arcadeSystemWindow == NULL)	
			{
				printf("Window could not be created! SDL Error: %s\n", SDL_GetError());
				success = false;
			}
			else
			{
				// initialize renderer, set the background as white for the wwindow, sync the renderer with the monitor refresh rate
				arcadeSystemRenderer = SDL_CreateRenderer(arcadeSystemWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
				SDL_SetRenderDrawColor(arcadeSystemRenderer, 0xFF, 0xFF, 0xFF, 0xFF);
			}
			// Initialize SDL_mixer
			if (Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 2048) < 0)
			{
				printf("SDL_mixer could not initialize! SDL_mixer Error: %s\n", Mix_GetError());
				success = false;
			}
			// initialize true type font 
			if (TTF_Init() == -1)
			{
				printf("SDL_ttf could not initialize! SDL_ttf Error: %s\n", TTF_GetError());
				success = false;
			}
	
		}
		return success;
	}
	
	int main(int argc, char* argv[])
	{	
		// first call initialization
		if (!init())
		{
			printf("Failed to initialize!\n");
		}
		// if initializes successfully then continue
		else
		{
			bool quit = false;
			RootNode rootNode(arcadeSystemRenderer, nullptr);
			Node* currentNode = &rootNode;
			while (!quit)
			{	
				// handle events on queue until empty
				SDL_Event e;
				while (SDL_PollEvent(&e) != 0)
				{
					Action newAction = currentNode->update(&e);
					// user requests quit by clicking window X
					if (e.type == SDL_QUIT)
					{
						quit = true;
					}
	
					if(newAction.actionName == MOVE_NODES)
					{
						currentNode->exitNode();
						currentNode = (Node*)(newAction.actionParameter);
						currentNode->enter();
					}
				}
				currentNode->update(nullptr);
				currentNode->render(arcadeSystemRenderer);
				SDL_RenderPresent(arcadeSystemRenderer);
			}
		}
		
		return 0;
	}
	

int main(int argc, char* argv[])
	{	
		// first call initialization
		if (!init())
		{
			printf("Failed to initialize!\n");
		}
		// if initializes successfully then continue
		else
		{
			bool quit = false;
			RootNode rootNode(arcadeSystemRenderer, nullptr); // create a RootNode object
			Node* currentNode = &rootNode; // set the current node pointer to the address of the rootNode
			while (!quit)
			{	
				// handle events on queue until empty
				SDL_Event e;
				while (SDL_PollEvent(&e) != 0)
				{
					Action newAction = currentNode->update(&e); // store the action that is returned by the currentNode's update
					// user requests quit by clicking window X
					if (e.type == SDL_QUIT)
					{
						quit = true;
					}
	
	// check if the action is to move node
				if(newAction.actionName == MOVE_NODES)
					{
						currentNode->exitNode();
						currentNode = (Node*)(newAction.actionParameter);
						currentNode->enter();
					}
				}
				currentNode->update(nullptr);
				currentNode->render(arcadeSystemRenderer);
				SDL_RenderPresent(arcadeSystemRenderer);
			}
		}
		
		return 0;
	}
	

// TetrisGame.h

#ifndef TETRIS_GAME_H
#define TETRIS_GAME_H

// resources
#include "GameScreen.h"
#include "Map.h"

class TetrisGame : public GameScreen
{
    public:
    Action update(SDL_Event* event);
    void logic();
    void setMap(Map* m);
    void addPiece(std::string path, point tlc, std::vector<std::vector<int> > piece);
    void newGame();
    bool moveLeft(std::vector<Entity*>& piece);
    bool moveRight(std::vector<Entity*>& piece);
    bool moveUp(std::vector<Entity*>& piece);
    bool moveDown(std::vector<Entity*>& piece);
    void rotatePiece(std::vector<Entity*>& piece, point rot_in); // NEW LINE
    std::vector<std::vector<std::vector<int> > > pieces;

    private:
    Map* m;

    point rot; // NEW LINE
    bool hasRotated = false; // NEW LINE
};

#endif

void TetrisGame::rotatePiece(std::vector<Entity*>& piece_in, point rot_in)
{
	// x and y start as the top left corner the first time we rotate
	int x = piece_in[0]->getXPos();
	int y = piece_in[0]->getYPos();
	
	// a and b are the pivot coordinates and are some distance away from the TLC
	int a = x + rot_in.x;
	int b = y + rot_in.y;

	// if this is the first rotation then the pivot is just (a,b)
	if(!hasRotated)
	{
		rot = {a,b};
		hasRotated = true;
	}
	else // if this is not the first time, then the pivot is the current rot which gets updated with movement
	{
		a = rot.x;
		b = rot.y;
	}
	
	// for every block, the new TLC is rotated accordingly
	for(int i = 0; i < piece_in.size(); i++)
	{
		x = piece_in[i]->getXPos();
		y = piece_in[i]->getYPos();
		int newX = (y-b)+a;
		int newY = -(x-a)+b-30;
		// check if this new TLC is valid, if off the screen deal with it later
		if(newX > 0 && newY > 0 && newX < (m->getxDim())*(m->getSideSize()) && newY < (m->getyDim())*(m->getSideSize()))
		{
			// if on the screen but over another piece then don't rotate
			if(m->getTiles()[newY/(m->getSideSize())][newX/(m->getSideSize())]->getState() == true)
			{
				return;
			}
		}
	}
	// valid rotation so we adjust each pieces position
	for(int i = 0; i < piece_in.size(); i++)
	{
		x = piece_in[i]->getXPos();
		y = piece_in[i]->getYPos();
		int newX = (y-b)+a;
		int newY = -(x-a)+b-30;
		
		piece_in[i]->setXPos(newX);
		piece_in[i]->setYPos(newY);
	}
	
	// for pieces that were rotated off screen, adjust their position
	for(int i = 0; i < piece_in.size(); i++)
	{
			x = piece_in[i]->getXPos();
			y = piece_in[i]->getYPos();
		while(x < 0)
		{
			x+=m->getSideSize();
			moveRight(getMovingEntities());
		}
		while(x > (m->getxDim()-1)*(m->getSideSize()))
		{
			x-=m->getSideSize();
			moveLeft(getMovingEntities());
		}
		while(y < 0)
		{
			y+=m->getSideSize();
			moveDown(getMovingEntities());
		}
		while(y >= (m->getyDim()-1)*m->getSideSize())
		{
			y-=m->getSideSize();
			moveUp(getMovingEntities());
		}
	}
}
	

// x and y start as the top left corner the first time we rotate
    int x = piece_in[0]->getXPos();
    int y = piece_in[0]->getYPos();
    
    // a and b are the pivot coordinates and are some distance away from the TLC
    int a = x + rot_in.x;
    int b = y + rot_in.y;

    // if this is the first rotation then the pivot is just (a,b)
    if(!hasRotated)
    {
        rot = {a,b};
        hasRotated = true;
    }
    else // if this is not the first time, then the pivot is the current rot which gets updated with movement
    {
        a = rot.x;
        b = rot.y;
    }

// for every block, the new TLC is rotated accordingly
    for(int i = 0; i < piece_in.size(); i++)
    {
        x = piece_in[i]->getXPos();
        y = piece_in[i]->getYPos();
        int newX = (y-b)+a;
        int newY = -(x-a)+b-30;
        // check if this new TLC is valid, if off the screen deal with it later
        if(newX > 0 && newY > 0 && newX < (m->getxDim())*(m->getSideSize()) && newY < (m->getyDim())*(m->getSideSize()))
        {
            // if on the screen but over another piece then don't rotate
            if(m->getTiles()[newY/(m->getSideSize())][newX/(m->getSideSize())]->getState() == true)
            {
                return;
            }
        }
    }

int newX = (y-b)+a;
int newY = -(x-a)+b-30;

 for(int i = 0; i < piece_in.size(); i++)
{
	x = piece_in[i]->getXPos();
	y = piece_in[i]->getYPos();
	int newX = (y-b)+a;
	int newY = -(x-a)+b-30;
	
	piece_in[i]->setXPos(newX);
	piece_in[i]->setYPos(newY);
}

for(int i = 0; i < piece_in.size(); i++)
    {
	   x = piece_in[i]->getXPos();
	   y = piece_in[i]->getYPos();
	   while(x < 0)
	   {
		   x+=m->getSideSize();
		   moveRight(getMovingEntities());
	   }
	   while(x > (m->getxDim()-1)*(m->getSideSize()))
	   {
		   x-=m->getSideSize();
		   moveLeft(getMovingEntities());
	   }
	   while(y < 0)
	   {
		   y+=m->getSideSize();
		   moveDown(getMovingEntities());
	   }
	   while(y >= (m->getyDim()-1)*m->getSideSize())
	   {
		   y-=m->getSideSize();
		   moveUp(getMovingEntities());
	   }
   }

if(event)
	{
		if((*event).type == SDL_KEYDOWN && (*event).key.keysym.sym == SDLK_DOWN)
		{
			moveDown(getMovingEntities());
			rot.y += getMovingEntities()[0]->getHeight(); // NEW LINE
		}
		else if((*event).type == SDL_KEYDOWN && (*event).key.keysym.sym == SDLK_UP)
		{
			rotatePiece(getMovingEntities(), {30,30}); // NEW LINE
		}
		else if((*event).type == SDL_KEYDOWN && (*event).key.keysym.sym == SDLK_LEFT)
		{
			moveLeft(getMovingEntities());
			rot.x -= getMovingEntities()[0]->getWidth(); // NEW LINE
		}
		else if((*event).type == SDL_KEYDOWN && (*event).key.keysym.sym == SDLK_RIGHT)
		{
			moveRight(getMovingEntities());
			rot.x += getMovingEntities()[0]->getWidth(); // NEW LINE
		}
	}
	

bool getNextPiece; 
	int pieceIndex = 0; 
	int count = 0;
	

 count++;
    if(count == 60)
    {
        // first check if you can move the piece by checking conditions for each block
        for (int i = 0; i < getMovingEntities().size(); i++)
        {
            // get the x and y coords of the entity
            int x = getMovingEntities()[i]->getXPos();
            int y = getMovingEntities()[i]->getYPos();

            int nextRow = (getMovingEntities()[i]->getHeight()+y)/(m->getSideSize());
            int nextCol = x/(m->getSideSize()); 
            // if the next position is the bottom or another piece, get another piece
            
            if(
                (nextRow == m->getyDim())
                    ||
                ((m->getTiles()[nextRow][nextCol]->getState() == true)) // hit a non moving block because a moving piece can have a tile above another moving tile which is valid
            )
                {
                    printf("\ncan't move so--new piece\n");
                    getNextPiece = true;
                }
            printf("\n\n");
        }
        // if all blocks can move then move them
        if(!getNextPiece)
        {
            moveDown(getMovingEntities());
            rot.y += getMovingEntities()[0]->getHeight();
        }
        else
        {
            // otherwise set all blocks to the map
            for (int i = 0; i < getMovingEntities().size(); i++)
            {
                //printf("placing block %i", i);
                // get the x and y coords of the entity
                int x = getMovingEntities()[i]->getXPos();
                int y = getMovingEntities()[i]->getYPos();

                m->getTiles()[y/(m->getSideSize())][x/(m->getSideSize())] = (Tile*)(getMovingEntities()[i]);
                m->getTiles()[y/(m->getSideSize())][x/(m->getSideSize())]->setState(true);
            }
            count = 0;
            return newAction;
        }
        count = 0;
    }
    logic();
    return newAction;

count++;
if(count == 60)
{
	// first check if you can move the piece by checking conditions for each block
	for (int i = 0; i < getMovingEntities().size(); i++)
	{
		// get the x and y coords of the entity
		int x = getMovingEntities()[i]->getXPos();
		int y = getMovingEntities()[i]->getYPos();

		int nextRow = (getMovingEntities()[i]->getHeight()+y)/(m->getSideSize());
		int nextCol = x/(m->getSideSize()); 
		// if the next position is the bottom or another piece, get another piece
		
		if(
			(nextRow == m->getyDim())
				||
			((m->getTiles()[nextRow][nextCol]->getState() == true)) // hit a non moving block because a moving piece can have a tile above another moving tile which is valid
		)
			{
				printf("\ncan't move so--new piece\n");
				getNextPiece = true;
			}
		printf("\n\n");
	}

// if all blocks can move then move them
	if(!getNextPiece)
	{
		moveDown(getMovingEntities());
		rot.y += getMovingEntities()[0]->getHeight();
	}
	else
	{
		// otherwise set all blocks to the map
		for (int i = 0; i < getMovingEntities().size(); i++)
		{
			//printf("placing block %i", i);
			// get the x and y coords of the entity
			int x = getMovingEntities()[i]->getXPos();
			int y = getMovingEntities()[i]->getYPos();

			m->getTiles()[y/(m->getSideSize())][x/(m->getSideSize())] = (Tile*)(getMovingEntities()[i]);
			m->getTiles()[y/(m->getSideSize())][x/(m->getSideSize())]->setState(true);
		}
		count = 0;
		return newAction;
	}
	count = 0;
}
logic();
return newAction;

void TetrisGame::newGame()
{
	//addPiece("brickBreakerNodeImages/yellowBrickTexture.png", {0,0}, pieces.at(0));
	setisNewGame(false);
	getNextPiece = true;
}

void TetrisGame::logic()
{
	if(getNextPiece)
	{
		if(pieceIndex == pieces.size())
		{
			pieceIndex = 0;
		}
		point p1 = {0,0};
		switch(pieceIndex)
		{
			case(0):
			{
				addPiece("brickBreakerNodeImages/yellowBrickTexture.png", p1, pieces.at(pieceIndex));
				break;
			}
			case(1):
			{
				addPiece("brickBreakerNodeImages/blueBrickTexture.png", p1, pieces.at(pieceIndex));
				break;
			}
			case(2):
			{
				addPiece("brickBreakerNodeImages/redBrickTexture.png", p1, pieces.at(pieceIndex));
				break;
			}
			case(3):
			{
				addPiece("brickBreakerNodeImages/redBrickTexture.png", p1, pieces.at(pieceIndex));
				break;
			}
			case(4):
			{
				addPiece("brickBreakerNodeImages/purpleBrickTexture.png", p1, pieces.at(pieceIndex));
				break;
			}
			case(5):
			{
				addPiece("brickBreakerNodeImages/greenBrickTexture.png", p1, pieces.at(pieceIndex));
				break;
			}
			case(6):
			{
				addPiece("brickBreakerNodeImages/greenBrickTexture.png", p1, pieces.at(pieceIndex));
				break;
			}
		}
		
		pieceIndex++;
		getNextPiece = false;
		hasRotated = false;
	}
}
	

if((*event).type == SDL_KEYDOWN && (*event).key.keysym.sym == SDLK_DOWN)
{
	//moveDown(getMovingEntities());
	
	//rot.y += getMovingEntities()[0]->getHeight();

	count=59;
}

std::vector<std::vector<int> > longPiece =
	{
		{ 1,0,0,0 },
		{ 1,0,0,0 },
		{ 1,0,0,0 },
		{ 1,0,0,0 }
	};
	std::vector<std::vector<int> > squarePiece =
	{
		{ 1,1 },
		{ 1,1 }
	};
	std::vector<std::vector<int> > TPiece =
	{
		{ 1,0,0 },
		{ 1,1,0 },
		{ 1,0,0 }
	};
	std::vector<std::vector<int> > LPiece =
	{
		{ 1,0,0 },
		{ 1,0,0 },
		{ 1,1,0 }
	};
	std::vector<std::vector<int> > L2Piece =
	{
		{ 0,1,0 },
		{ 0,1,0 },
		{ 1,1,0 }

	};
	std::vector<std::vector<int> > zigZagPiece =
	{
		{ 1,0,0 },
		{ 1,1,0 },
		{ 0,1,0 }
	};
	std::vector<std::vector<int> > zigZag2Piece =
	{
		{ 0,1,0 },
		{ 1,1,0 },
		{ 1,0,0 }
	};
	game->pieces = {squarePiece, longPiece, LPiece, L2Piece, TPiece,zigZagPiece, zigZag2Piece};

#ifndef BRICK_H
#define BRICK_H
#include "Entity.h"
class Brick : public Entity
{
public:
	Brick();
	void update(SDL_Event* event);
};
#endif

#include "Brick.h"

Brick::Brick(){}
void Brick::update(SDL_Event* event) {}

// SimpleGame.h

	#ifndef SIMPLE_GAME_H
	#define SIMPLE_GAME_H
	
	#include "GameScreen.h"
	#include "Ball.h"
	#include "Paddle.h"
	#include "Brick.h"
	#include "Config.h"
	
	class SimpleGame : public GameScreen
	{
		public:
			SimpleGame();
			Action update(SDL_Event* event);
			void logic();
	
			void newGame();
	
			void setBall(Ball* ball_in) {ball = ball_in;}
			Ball* getBall() {return ball;}
	
			void setPaddle(Paddle* paddle_in) {paddle = paddle_in;}
			Paddle* getPaddle() {return paddle;}
	
		private:
			Ball* ball;
			Paddle* paddle;
	};
	
	#endif
	

	bool ccw(point A, point B, point C)
	{
		return ((B.y - A.y) * (C.x - B.x) - (A.x - B.x) * (B.y - C.y)) > 0;
	}
	
	bool intersect(point A, point B, point C, point D)
	{
		return ccw(A, C, D) != ccw(B, C, D) && ccw(A, B, C) != ccw(A, B, D);
	}
	

// code inserted at the bottom of SimpleGame::logic 

	int maxCollisionArea = 0;
	int maxIndex = -1;
	int w_max = 0;
	int h_max = 0;
	int j;
	int numFalse = 0;

	// find the brick with the largest collision area
	for (j = 2; j < getEntities()->size(); j++)
	{
        // if collided then state should be false, keep track so know when game over
		if (getEntities()[j]->getState() == false)
		{
			numFalse += 1;
			continue;
		}

		SDL_Rect ballRegion = ball->getGameObjectTexture()->getImageDestination();
		SDL_Rect brickRegion = getEntities()[j]->getGameObjectTexture()->getImageDestination();

		if (SDL_HasIntersection(&ballRegion, &brickRegion))
		{
			SDL_Rect collisionRect;
			SDL_IntersectRect(&ballRegion, &brickRegion, &collisionRect);
			int w = collisionRect.w;
			int h = collisionRect.h;
			if (h * w > maxCollisionArea)
			{
				maxCollisionArea = h * w;
				maxIndex = j;
				w_max = w;
				h_max = h;
			}

		}
	}
	j = maxIndex;

    // if set ball position
	bool hasMoved = false;

	// for that brick with the largest collision area do the following:
	if (j >= 2)
	{
        Brick* currentBrick = (Brick*)(getEntities())[j];
		// first find the corner of the ball that collided
		int xCorner = 0;
		int yCorner = 0;
		currentBrick->setState(false);

		//BRC:  
		if (ball->getXPos() < currentBrick->getXPos() && // 1. ball left side is to the left of the brick left side
			ball->getXPos() + ball->getWidth() > currentBrick->getXPos() &&  // 2. ball right side is to the right of the brick left side
			ball->getYPos() < currentBrick->getYPos() && // 3. ball top side is above brick top side,
			ball->getYPos() + ball->getHeight() > currentBrick->getYPos()) // 4. ball bottom side is below the brick top side
		{
			xCorner = ball->getXPos() + ball->getWidth();
			yCorner = ball->getYPos() + ball->getHeight();
		}

		//TRC:
		else if (ball->getXPos() < currentBrick->getXPos() && // 1. ball left side is to the left of the brick left side
			ball->getXPos() + ball->getWidth() > currentBrick->getXPos() &&  // 2. ball right side is to the right of the brick left side
			ball->getYPos() < currentBrick->getYPos() + currentBrick->getHeight() && // 3. ball top side is above the brick bottom side
			ball->getYPos() + ball->getHeight() > currentBrick->getYPos() + currentBrick->getHeight()) // 4. ball bottom side is below brick bottom side
		{
			xCorner = ball->getXPos() + ball->getWidth();
			yCorner = ball->getYPos();
		}

		// BLC:
		else if (ball->getXPos() < currentBrick->getXPos() + currentBrick->getWidth() && // 1. ball left side is to the left of the brick right side
			ball->getXPos() + ball->getWidth() > currentBrick->getXPos() + currentBrick->getWidth() && // 2. ball right side is to the right of the brick right side
			ball->getYPos() < currentBrick->getYPos() && // 3. ball top side is above brick top side,
			ball->getYPos() + ball->getHeight() > currentBrick->getYPos()) // 4. ball bottom side is below the brick top side
		{
			xCorner = ball->getXPos();
			yCorner = ball->getYPos() + ball->getHeight();
		}

		// TLC:
		else if (ball->getXPos() < currentBrick->getXPos() + currentBrick->getWidth() && // 1. ball left side is to the left of the brick right side
			ball->getXPos() + ball->getWidth() > currentBrick->getXPos() + currentBrick->getWidth() && // 2. ball right side is to the right of the brick right side
			ball->getYPos() < currentBrick->getYPos() + currentBrick->getHeight() && // 3. ball top side is above the brick bottom side
			ball->getYPos() + ball->getHeight() > currentBrick->getYPos() + currentBrick->getHeight()) // 4. ball bottom side is below brick bottom side
		{
			xCorner = ball->getXPos();
			yCorner = ball->getYPos();
		}
		//---------------------------

		// if two corners collide then one of the following is true
		else if (ball->getXPos() + ball->getWidth() > currentBrick->getXPos() && // ball right side right of brick left side
			ball->getXPos() < currentBrick->getXPos()) // ball left side left of brick left side
		{
			ball->setXPos(ball->getXPos() - w_max);
			ball->setXVelocity(-(ball->getXVelocity()));
			hasMoved = true;
		}
		else if (ball->getXPos() + ball->getWidth() > currentBrick->getXPos() + currentBrick->getWidth() && // ball right side right of brick right side
			ball->getXPos() < currentBrick->getXPos() + currentBrick->getWidth()) // ball left side left of brick right side
		{
			ball->setXPos(ball->getXPos() + w_max);
			ball->setXVelocity(-(ball->getXVelocity()));
			hasMoved = true;
		}
		else if (ball->getYPos() + ball->getHeight() > currentBrick->getYPos() && // ball bottom side is below brick top side
			ball->getYPos() < currentBrick->getYPos()) // ball top side above brick top side
		{
			ball->setYPos(ball->getYPos() - h_max);
			ball->setYVelocity(-(ball->getYVelocity()));
			hasMoved = true;
		}
		else if (ball->getYPos() + ball->getHeight() > currentBrick->getYPos() + currentBrick->getHeight() && // ball bottom side is below brick bottom side
			ball->getYPos() < currentBrick->getYPos() + currentBrick->getHeight()) // ball top side is above brick bottom side
		{
			ball->setYPos(ball->getYPos() + h_max);
			ball->setYVelocity(-(ball->getYVelocity()));
			hasMoved = true;
		}

        // prior position
		int xPosTemp = xCorner - ball->getXVelocity();
		int yPosTemp = yCorner - ball->getYVelocity();

        // is right on the line
		if (yPosTemp == currentBrick->getYPos() && !hasMoved)
		{
			ball->setYPos(ball->getYPos() - h_max);
			ball->setYVelocity(-(ball->getYVelocity()));
			hasMoved = true;
		}
		else if (yPosTemp == currentBrick->getYPos() + currentBrick->getHeight() && !hasMoved)
		{
			printf("on the line: \n");
			ball->setYPos(ball->getYPos() + h_max);
			ball->setYVelocity(-(ball->getYVelocity()));
			hasMoved = true;
		}
		else if (xPosTemp == currentBrick->getXPos() + currentBrick->getWidth() && !hasMoved)
		{
			printf("on the line: \n");
			ball->setXPos(ball->getXPos() + w_max);
			ball->setXVelocity(-(ball->getXVelocity()));
			hasMoved = true;
		}
		else if (xPosTemp == currentBrick->getXPos() && !hasMoved)
		{
			printf("on the line: \n");
			ball->setXPos(ball->getXPos() - w_max);
			ball->setXVelocity(-(ball->getXVelocity()));
			hasMoved = true;
		}

		point ball_init = { xPosTemp, yPosTemp };
		point ball_final = { xCorner, yCorner };

		point R_TLC = { currentBrick->getXPos(), currentBrick->getYPos() };
		point R_TRC = { currentBrick->getXPos() + currentBrick->getWidth(), currentBrick->getYPos() };
		point R_BLC = { currentBrick->getXPos(), currentBrick->getYPos() + currentBrick->getHeight() };
		point R_BRC = { currentBrick->getXPos() + currentBrick->getWidth(), currentBrick->getYPos() + currentBrick->getHeight() };

		// intersects top
		if (!hasMoved && intersect(ball_init, ball_final, R_TLC, R_TRC))
		{
			ball->setYPos(ball->getYPos() - h_max);
			ball->setYVelocity(-(ball->getYVelocity()));
		}

		// intersects bottom
		else if (!hasMoved && intersect(ball_init, ball_final, R_BLC, R_BRC))
		{
			ball->setYPos(ball->getYPos() + h_max);
			ball->setYVelocity(-(ball->getYVelocity()));
		}

		// intersects left
		else if (!hasMoved && intersect(ball_init, ball_final, R_TLC, R_BLC))
		{
			ball->setXPos(ball->getXPos() - w_max);
			ball->setXVelocity(-(ball->getXVelocity()));
		}

		// intersects right
		else if (!hasMoved && intersect(ball_init, ball_final, R_TRC, R_BRC))
		{
			ball->setXPos(ball->getXPos() + w_max);
			ball->setXVelocity(-(ball->getXVelocity()));
		}
		else if (h_max == w_max)
		{
			ball->setXPos(ball->getXPos() - ball->getXVelocity());
			ball->setYPos(ball->getYPos() - ball->getYVelocity());
			ball->setXVelocity(-(ball->getXVelocity()));
			ball->setYVelocity(-(ball->getYVelocity()));
		}
	}

		int maxCollisionArea = 0;
		int maxIndex = -1;
		int w_max = 0;
		int h_max = 0;
		int j;
		int numFalse = 0;
	
		// find the brick with the largest collision area
		for (j = 2; j < getEntities()->size(); j++)
		{
			// if collided then state should be false, keep track so know when game over
			if (getEntities()[j]->getState() == false)
			{
				numFalse += 1;
				continue;
			}
	
			SDL_Rect ballRegion = ball->getGameObjectTexture()->getImageDestination();
			SDL_Rect brickRegion = getEntities()[j]->getGameObjectTexture()->getImageDestination();
	
			if (SDL_HasIntersection(&ballRegion, &brickRegion))
			{
				SDL_Rect collisionRect;
				SDL_IntersectRect(&ballRegion, &brickRegion, &collisionRect);
				int w = collisionRect.w;
				int h = collisionRect.h;
				if (h * w > maxCollisionArea)
				{
					maxCollisionArea = h * w;
					maxIndex = j;
					w_max = w;
					h_max = h;
				}
	
			}
		}
		j = maxIndex;
	

        // if have adjusted ball position
		bool hasMoved = false;

		// for that brick with the largest collision area do the following:
		if (j >= 2)
		{
			Brick* currentBrick = (Brick*)(getEntities())[j];
			// first find the corner of the ball that collided
			int xCorner = 0;
			int yCorner = 0;
			currentBrick->setState(false);
	
			// Ball bottom right corner:  
			if (ball->getXPos() < currentBrick->getXPos() && // 1. ball left side is to the left of the brick left side
				ball->getXPos() + ball->getWidth() > currentBrick->getXPos() &&  // 2. ball right side is to the right of the brick left side
				ball->getYPos() < currentBrick->getYPos() && // 3. ball top side is above brick top side,
				ball->getYPos() + ball->getHeight() > currentBrick->getYPos()) // 4. ball bottom side is below the brick top side
			{
				xCorner = ball->getXPos() + ball->getWidth();
				yCorner = ball->getYPos() + ball->getHeight();
			}
	
			// Ball top right corner:
			else if (ball->getXPos() < currentBrick->getXPos() && // 1. ball left side is to the left of the brick left side
				ball->getXPos() + ball->getWidth() > currentBrick->getXPos() &&  // 2. ball right side is to the right of the brick left side
				ball->getYPos() < currentBrick->getYPos() + currentBrick->getHeight() && // 3. ball top side is above the brick bottom side
				ball->getYPos() + ball->getHeight() > currentBrick->getYPos() + currentBrick->getHeight()) // 4. ball bottom side is below brick bottom side
			{
				xCorner = ball->getXPos() + ball->getWidth();
				yCorner = ball->getYPos();
			}
	
			// Ball bottom left corner:
			else if (ball->getXPos() < currentBrick->getXPos() + currentBrick->getWidth() && // 1. ball left side is to the left of the brick right side
				ball->getXPos() + ball->getWidth() > currentBrick->getXPos() + currentBrick->getWidth() && // 2. ball right side is to the right of the brick right side
				ball->getYPos() < currentBrick->getYPos() && // 3. ball top side is above brick top side,
				ball->getYPos() + ball->getHeight() > currentBrick->getYPos()) // 4. ball bottom side is below the brick top side
			{
				xCorner = ball->getXPos();
				yCorner = ball->getYPos() + ball->getHeight();
			}
	
			// Ball top left corner:
			else if (ball->getXPos() < currentBrick->getXPos() + currentBrick->getWidth() && // 1. ball left side is to the left of the brick right side
				ball->getXPos() + ball->getWidth() > currentBrick->getXPos() + currentBrick->getWidth() && // 2. ball right side is to the right of the brick right side
				ball->getYPos() < currentBrick->getYPos() + currentBrick->getHeight() && // 3. ball top side is above the brick bottom side
				ball->getYPos() + ball->getHeight() > currentBrick->getYPos() + currentBrick->getHeight()) // 4. ball bottom side is below brick bottom side
			{
				xCorner = ball->getXPos();
				yCorner = ball->getYPos();
			}
			//---------------------------
	
			// if two corners collide then one of the following is true
			else if (ball->getXPos() + ball->getWidth() > currentBrick->getXPos() && // ball right side right of brick left side
				ball->getXPos() < currentBrick->getXPos()) // ball left side left of brick left side
			{
				ball->setXPos(ball->getXPos() - w_max);
				ball->setXVelocity(-(ball->getXVelocity()));
				hasMoved = true;
			}
			else if (ball->getXPos() + ball->getWidth() > currentBrick->getXPos() + currentBrick->getWidth() && // ball right side right of brick right side
				ball->getXPos() < currentBrick->getXPos() + currentBrick->getWidth()) // ball left side left of brick right side
			{
				ball->setXPos(ball->getXPos() + w_max);
				ball->setXVelocity(-(ball->getXVelocity()));
				hasMoved = true;
			}
			else if (ball->getYPos() + ball->getHeight() > currentBrick->getYPos() && // ball bottom side is below brick top side
				ball->getYPos() < currentBrick->getYPos()) // ball top side above brick top side
			{
				ball->setYPos(ball->getYPos() - h_max);
				ball->setYVelocity(-(ball->getYVelocity()));
				hasMoved = true;
			}
			else if (ball->getYPos() + ball->getHeight() > currentBrick->getYPos() + currentBrick->getHeight() && // ball bottom side is below brick bottom side
				ball->getYPos() < currentBrick->getYPos() + currentBrick->getHeight()) // ball top side is above brick bottom side
			{
				ball->setYPos(ball->getYPos() + h_max);
				ball->setYVelocity(-(ball->getYVelocity()));
				hasMoved = true;
			}
	
			// prior position
			int xPosTemp = xCorner - ball->getXVelocity();
			int yPosTemp = yCorner - ball->getYVelocity();
	
			// is right on the line
			if (yPosTemp == currentBrick->getYPos() && !hasMoved)
			{
				ball->setYPos(ball->getYPos() - h_max);
				ball->setYVelocity(-(ball->getYVelocity()));
				hasMoved = true;
			}
			else if (yPosTemp == currentBrick->getYPos() + currentBrick->getHeight() && !hasMoved)
			{
				printf("on the line: \n");
				ball->setYPos(ball->getYPos() + h_max);
				ball->setYVelocity(-(ball->getYVelocity()));
				hasMoved = true;
			}
			else if (xPosTemp == currentBrick->getXPos() + currentBrick->getWidth() && !hasMoved)
			{
				printf("on the line: \n");
				ball->setXPos(ball->getXPos() + w_max);
				ball->setXVelocity(-(ball->getXVelocity()));
				hasMoved = true;
			}
			else if (xPosTemp == currentBrick->getXPos() && !hasMoved)
			{
				printf("on the line: \n");
				ball->setXPos(ball->getXPos() - w_max);
				ball->setXVelocity(-(ball->getXVelocity()));
				hasMoved = true;
			}
	
			point ball_init = { xPosTemp, yPosTemp };
			point ball_final = { xCorner, yCorner };
	
			point R_TLC = { currentBrick->getXPos(), currentBrick->getYPos() };
			point R_TRC = { currentBrick->getXPos() + currentBrick->getWidth(), currentBrick->getYPos() };
			point R_BLC = { currentBrick->getXPos(), currentBrick->getYPos() + currentBrick->getHeight() };
			point R_BRC = { currentBrick->getXPos() + currentBrick->getWidth(), currentBrick->getYPos() + currentBrick->getHeight() };
	
			// intersects top
			if (!hasMoved && intersect(ball_init, ball_final, R_TLC, R_TRC))
			{
				ball->setYPos(ball->getYPos() - h_max);
				ball->setYVelocity(-(ball->getYVelocity()));
			}
	
			// intersects bottom
			else if (!hasMoved && intersect(ball_init, ball_final, R_BLC, R_BRC))
			{
				ball->setYPos(ball->getYPos() + h_max);
				ball->setYVelocity(-(ball->getYVelocity()));
			}
	
			// intersects left
			else if (!hasMoved && intersect(ball_init, ball_final, R_TLC, R_BLC))
			{
				ball->setXPos(ball->getXPos() - w_max);
				ball->setXVelocity(-(ball->getXVelocity()));
			}
	
			// intersects right
			else if (!hasMoved && intersect(ball_init, ball_final, R_TRC, R_BRC))
			{
				ball->setXPos(ball->getXPos() + w_max);
				ball->setXVelocity(-(ball->getXVelocity()));
			}
			else if (h_max == w_max)
			{
				ball->setXPos(ball->getXPos() - ball->getXVelocity());
				ball->setYPos(ball->getYPos() - ball->getYVelocity());
				ball->setXVelocity(-(ball->getXVelocity()));
				ball->setYVelocity(-(ball->getYVelocity()));
			}
	

                // if have adjusted ball position
		bool hasMoved = false;

		// for that brick with the largest collision area do the following:
		if (j >= 2)
		{
			Brick* currentBrick = (Brick*)(getEntities())[j];
			// first find the corner of the ball that collided
			int xCorner = 0;
			int yCorner = 0;
			currentBrick->setState(false);

                        
// Ball bottom right corner:  
if (ball->getXPos() < currentBrick->getXPos() && // 1. ball left side is to the left of the brick left side
	ball->getXPos() + ball->getWidth() > currentBrick->getXPos() &&  // 2. ball right side is to the right of the brick left side
	ball->getYPos() < currentBrick->getYPos() && // 3. ball top side is above brick top side,
	ball->getYPos() + ball->getHeight() > currentBrick->getYPos()) // 4. ball bottom side is below the brick top side
{
	xCorner = ball->getXPos() + ball->getWidth();
	yCorner = ball->getYPos() + ball->getHeight();
}

// Ball top right corner:
else if (ball->getXPos() < currentBrick->getXPos() && // 1. ball left side is to the left of the brick left side
	ball->getXPos() + ball->getWidth() > currentBrick->getXPos() &&  // 2. ball right side is to the right of the brick left side
	ball->getYPos() < currentBrick->getYPos() + currentBrick->getHeight() && // 3. ball top side is above the brick bottom side
	ball->getYPos() + ball->getHeight() > currentBrick->getYPos() + currentBrick->getHeight()) // 4. ball bottom side is below brick bottom side
{
	xCorner = ball->getXPos() + ball->getWidth();
	yCorner = ball->getYPos();
}

// Ball bottom left corner:
else if (ball->getXPos() < currentBrick->getXPos() + currentBrick->getWidth() && // 1. ball left side is to the left of the brick right side
	ball->getXPos() + ball->getWidth() > currentBrick->getXPos() + currentBrick->getWidth() && // 2. ball right side is to the right of the brick right side
	ball->getYPos() < currentBrick->getYPos() && // 3. ball top side is above brick top side,
	ball->getYPos() + ball->getHeight() > currentBrick->getYPos()) // 4. ball bottom side is below the brick top side
{
	xCorner = ball->getXPos();
	yCorner = ball->getYPos() + ball->getHeight();
}

// Ball top left corner:
else if (ball->getXPos() < currentBrick->getXPos() + currentBrick->getWidth() && // 1. ball left side is to the left of the brick right side
	ball->getXPos() + ball->getWidth() > currentBrick->getXPos() + currentBrick->getWidth() && // 2. ball right side is to the right of the brick right side
	ball->getYPos() < currentBrick->getYPos() + currentBrick->getHeight() && // 3. ball top side is above the brick bottom side
	ball->getYPos() + ball->getHeight() > currentBrick->getYPos() + currentBrick->getHeight()) // 4. ball bottom side is below brick bottom side
{
	xCorner = ball->getXPos();
	yCorner = ball->getYPos();
}

// if two corners collide then one of the following is true
	// Ball right side collides
	else if (ball->getXPos() + ball->getWidth() > currentBrick->getXPos() && // ball right side right of brick left side
		ball->getXPos() < currentBrick->getXPos()) // ball left side left of brick left side
	{
		ball->setXPos(ball->getXPos() - w_max);
		ball->setXVelocity(-(ball->getXVelocity()));
		hasMoved = true;
	}
	// ball left side collides
	else if (ball->getXPos() + ball->getWidth() > currentBrick->getXPos() + currentBrick->getWidth() && // ball right side right of brick right side
		ball->getXPos() < currentBrick->getXPos() + currentBrick->getWidth()) // ball left side left of brick right side
	{
		ball->setXPos(ball->getXPos() + w_max);
		ball->setXVelocity(-(ball->getXVelocity()));
		hasMoved = true;
	}
	// ball bottom side collides
	else if (ball->getYPos() + ball->getHeight() > currentBrick->getYPos() && // ball bottom side is below brick top side
		ball->getYPos() < currentBrick->getYPos()) // ball top side above brick top side
	{
		ball->setYPos(ball->getYPos() - h_max);
		ball->setYVelocity(-(ball->getYVelocity()));
		hasMoved = true;
	}
	// ball top side collides
	else if (ball->getYPos() + ball->getHeight() > currentBrick->getYPos() + currentBrick->getHeight() && // ball bottom side is below brick bottom side
		ball->getYPos() < currentBrick->getYPos() + currentBrick->getHeight()) // ball top side is above brick bottom side
	{
		ball->setYPos(ball->getYPos() + h_max);
		ball->setYVelocity(-(ball->getYVelocity()));
		hasMoved = true;
	}
	

// is right on the top line
	if (yPosTemp == currentBrick->getYPos() && !hasMoved)
	{
		ball->setYPos(ball->getYPos() - h_max);
		ball->setYVelocity(-(ball->getYVelocity()));
		hasMoved = true;
	}
// is right on the bottom line
	else if (yPosTemp == currentBrick->getYPos() + currentBrick->getHeight() && !hasMoved)
	{
		printf("on the line: \n");
		ball->setYPos(ball->getYPos() + h_max);
		ball->setYVelocity(-(ball->getYVelocity()));
		hasMoved = true;
	}
// is right on the right line
	else if (xPosTemp == currentBrick->getXPos() + currentBrick->getWidth() && !hasMoved)
	{
		printf("on the line: \n");
		ball->setXPos(ball->getXPos() + w_max);
		ball->setXVelocity(-(ball->getXVelocity()));
		hasMoved = true;
// is right on the left line
	else if (xPosTemp == currentBrick->getXPos() && !hasMoved)
	{
		printf("on the line: \n");
		ball->setXPos(ball->getXPos() - w_max);
		ball->setXVelocity(-(ball->getXVelocity()));
		hasMoved = true;
	}

for (int row = 0; row < 5; row++)
	{
		for (int col = 0; col < 10; col++)
		{
			if (row == 0)
			{
				Brick* newYellowBrick = new Brick;
				ArcadeTexture* yellowBrickTexture = createImage(renderer_in, "brickBreakerNodeImages/yellowBrickTexture.png");
				yellowBrickTexture->setPosition(70 + col * 50, 50 + row * 20);
				newYellowBrick->setGameObjectTexture(yellowBrickTexture);
				game->addEntity(newYellowBrick);
			}
			else if (row == 1)
			{
				Brick* newBlueBrick = new Brick;
				ArcadeTexture* blueBrickTexture = createImage(renderer_in, "brickBreakerNodeImages/blueBrickTexture.png");
				blueBrickTexture->setPosition(70 + col * 50, 50 + row * 20);
				newBlueBrick->setGameObjectTexture(blueBrickTexture);
				game->addEntity(newBlueBrick);
			}
			else if (row == 2)
			{
				Brick* newRedBrick = new Brick;
				ArcadeTexture* redBrickTexture = createImage(renderer_in, "brickBreakerNodeImages/redBrickTexture.png");
				redBrickTexture->setPosition(70 + col * 50, 50 + row * 20);
				newRedBrick->setGameObjectTexture(redBrickTexture);
				game->addEntity(newRedBrick);
			}
			else if (row == 3)
			{
				Brick* newGreenBrick = new Brick;
				ArcadeTexture* greenBrickTexture = createImage(renderer_in, "brickBreakerNodeImages/greenBrickTexture.png");
				greenBrickTexture->setPosition(70 + col * 50, 50 + row * 20);
				newGreenBrick->setGameObjectTexture(greenBrickTexture);
				game->addEntity(newGreenBrick);
			}
			else if (row == 4)
			{
				Brick* newYellowBrick = new Brick;
				ArcadeTexture* yellowBrickTexture = createImage(renderer_in, "brickBreakerNodeImages/yellowBrickTexture.png");
				yellowBrickTexture->setPosition(70 + col * 50, 50 + row * 20);
				newYellowBrick->setGameObjectTexture(yellowBrickTexture);
				game->addEntity(newYellowBrick);
			}
		}
	}

void SimpleGame::newGame()
	{
		setGameState(true);
		ball->setXPos(0);
		ball->setYPos(0);
		ball->setXVelocity(2);
		ball->setYVelocity(5);
		paddle->setXPos(0);
		paddle->setYPos(windowHeight-paddle->getHeight());
		paddle->setXVelocity(0);
		setisNewGame(false);
		for (int j = 0; j < getEntities().size(); j++)
		{
			getEntities()[j]->setState(true);
		}
	}
	

• © Untitled
• Design: HTML5 UP