//--------------------------------------------------------------
// initialize application
void DontHitMe::appInit()
{
// get the important directories
mgString shaderDir;
m_options.getFileName("shaderDir", m_options.m_sourceFileName, "docs/shaders", shaderDir);
mgString uiDir;
m_options.getFileName("uiDir", m_options.m_sourceFileName, "docs/ui", uiDir);
mgString fontDir;
m_options.getFileName("fontDir", m_options.m_sourceFileName, "docs/fonts", fontDir);
mgInitDisplayServices(shaderDir, fontDir);
mgDisplay->setFOV(m_options.getDouble("FOV", 60.0));
mgDisplay->setDPI(m_options.getInteger("DPI", 0));
// load cursor pattern
loadCursor();
setDeskMode(true);
initMovement();
// load the shaders we might use
mgVertex::loadShader("litTexture");
mgVertex::loadShader("unlitTexture");
mgVertex::loadShader("litTextureCube");
mgVertex::loadShader("unlitTextureCube");
mgVertexTA::loadShader("litTextureArray");
mgVertexTA::loadShader("unlitTextureArray");
m_sky = new StarrySky(m_options);
m_sky->enableSkyBox(true);
m_sky->enableStars(true);
m_sky->enableSun(true);
mgPoint3 lightDir(0, 1, 1);
lightDir.normalize();
m_sky->setSunDir(lightDir);
mgDisplay->setLightDir(lightDir);
m_saucer = new Saucer(m_options);
m_planet = new Planet(m_options);
m_wreck = new Wreck(m_options);
m_tower1 = new Tower(m_options, false);
m_tower2 = new Tower(m_options, false);
mgString fileName;
m_options.getFileName("tube", m_options.m_sourceFileName, "tube.jpg", fileName);
m_tubeTexture = mgDisplay->loadTexture(fileName);
initTrack();
initBall();
updateBallPt();
m_intro = new Intro(m_options, m_ballOrigin);
m_showingIntro = false;
m_lastAnimate = mgOSGetTime(); // now!
}
void MainScene::onEnterTransitionDidFinish() {
Layer::onEnterTransitionDidFinish();
initBlocks(); // ブロックを配置する関数の呼び出し
initCollisionSprite(); // コリジョンスプライトの作成
initScoreLabel(); // スコアラベルの作成
createMyUnit(); // MyUnitの生成
initBall();
}
int main(int argc,char **argv){
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGBA);
glutInitWindowSize(800,600);
glutInitWindowPosition(0,0);
glutCreateWindow("Ball");
initBall();
glutDisplayFunc(display);
glutTimerFunc(UPDATE_TIME, update, 0);
glutMainLoop();
return 0;
}
void runAStep(struct Ball* ball, int posYJ1, int posYJ2, struct Score* score)
{
if(colideRWall(*ball) == 1)
{
if (colideRaquette(posYJ1, *ball))
{
changeDirection(ball);
ball->varY = ((ball->coord.y - posYJ1) - 20)/2.3;
mouve(ball);
}
else
{
score->J2++;
displayScore(*score);
initBall(ball);
}
}
else if(colideRWall(*ball) == 2)
{
if (colideRaquette(posYJ2, *ball))
{
changeDirection(ball);
ball->varY = ((ball->coord.y - posYJ2) - 20)/2.3;
mouve(ball);
}
else
{
score->J1++;
displayScore(*score);
initBall(ball);
}
}
else
{
if (colideWall(*ball) > 0)
ball->varY = - ball->varY;
mouve(ball);
}
}
/// class MatchReplayScene
MatchReplayScene::MatchReplayScene(MatchRecording *const &recording, QObject *const &parent) :
QGraphicsScene(parent),
recording(recording),
controller(recording),
projection(computeProjection(1000, 700)) {
initPitch();
initScoreboard();
initBall();
initPlayers();
connect(&controller, SIGNAL(frameChanged(MatchSnapshot *const &)),
this, SLOT(changeFrame(MatchSnapshot *const &)));
}
// Suppose there is a hyper-shell of unknown shape and unknown size that encloses the
// origin. The shell is defined by a function that returns true for all points within
// the shell and false for all points without the shell. Suppose you wish to sample
// the space within the shell. This class tries to produce pseudo-random points
// inside the shell by firing virtual accelerating rubber-balls in random directions
// from the origin. These balls decelerate and pick a new random direction when they
// hit the inner surface of the shell. (Unfortunately, this doesn't do a good job
// with narrow alleys)
GRubberBallSwarm::GRubberBallSwarm(int dims, int ballCount, GRand* pRand)
: m_balls(0, 3 * dims + NUMBER_OF_DOUBLES_TO_CONTAIN_STATS), m_pRand(pRand), m_dims(dims), m_currentBall(0), m_compareBall(0), m_condemnedBall(0)
{
m_balls.reserve(ballCount);
m_condemnedDistance = 1e200;
m_wallPrecisionIters = 16;
m_acceleration = 1.15;
m_deceleration = 0.6;
m_learningRate = 0.1;
int i;
for(i = 0; i < ballCount; i++)
initBall(m_balls.newRow(), 1);
m_pTemp = new double[2 * dims];
m_pNormal = m_pTemp + dims;
}
int main(void)
{
// seed pseudorandom number generator
srand48(time(NULL));
// instantiate window
GWindow window = newGWindow(WIDTH, HEIGHT);
// instantiate bricks
initBricks(window);
// instantiate ball, centered in middle of window
GOval ball = initBall(window);
// instantiate paddle, centered at bottom of window
GRect paddle = initPaddle(window);
// instantiate scoreboard, centered in middle of window, just above ball
GLabel label = initScoreboard(window);
// number of bricks initially
int bricks = COLS * ROWS;
// number of lives initially
int lives = LIVES;
// number of points initially
int points = 0;
// keep playing until game over
while (lives > 0 && bricks > 0)
{
// TODO
}
// wait for click before exiting
waitForClick();
// game over
closeGWindow(window);
return 0;
}
void PushBallScene::initUI()
{
m_pBG = Sprite::create("images/select/bg_choose.jpg");
kAdapterScreen->setExactPosition(m_pBG, 320, 480);
this->addToBGLayer(m_pBG);
auto borderUpper = PhysicsBody::createEdgeChain(bgLine,2,PHYSICSBODY_MATERIAL_DEFAULT,10);
m_pBG->setPhysicsBody(borderUpper);
ui_button = cocostudio::GUIReader::getInstance()->widgetFromJsonFile("cocos_studio/choose_flavors.json");
this->addToUILayer(ui_button,10);
ui_next = ui::Helper::seekWidgetByName(ui_button, "btn_next");
ui_next->setTag(100);
ui_next->setVisible(false);
ui_next ->addTouchEventListener(CC_CALLBACK_2(PushBallScene::touchEvent, this));
ui_coin = ui::Helper::seekWidgetByName(ui_button, "btn_coin");
ui_coin->setTag(200);
ui_coin->setOpacity(0);
// ui_coin->setVisible(false);
ui_coin ->addTouchEventListener(CC_CALLBACK_2(PushBallScene::touchEvent, this));
//根据选择界面，获取需要的水果,赋值到数组
// m_iFriutNum = (int)g_vChooseTaste.size();
for (int i = 0; i<g_vChooseTaste.size(); i++) {
ballStr[i] = g_vChooseTaste.at(i);
}
initMac();
initBall();
pushBall();
}
int main(int argc, char *argv[])
{
SDL_Init(SDL_INIT_VIDEO);
displayWindow = SDL_CreateWindow("Simon Project 1", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 800, 600, SDL_WINDOW_OPENGL); // SDL Window, title, position,position,width,height, type of graphics?
SDL_GLContext context = SDL_GL_CreateContext(displayWindow);
SDL_GL_MakeCurrent(displayWindow, context);
glClearColor(0.5, 0.5, 0.0, .9);//Green-color
//Setup
glViewport(0, 0, 800, 600);
glMatrixMode(GL_PROJECTION);
glOrtho(-1.33, 1.33, -1.0, 1.0, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glOrtho(-1.33, 1.33, -1.0, 1.0, -1.0, 1.0);
//LoadTextures
GLuint paddleID = LoadTexture("pngs/paddle.png");
GLuint ballID = LoadTexture("pngs/ball.png");
GLuint leftwinID = LoadTexture24("pngs/leftwin.png");
GLuint rightwinID = LoadTexture24("pngs/rightwin.png");
//Init Entities
initBall(ballID);
initPaddleLeft(paddleID);
initPaddleRight(paddleID);
initRightwin(rightwinID);
initLeftwin(leftwinID);
//Time
float lastFrameTicks = 0.0;
SDL_Event event;
bool done = false;
while (!done) {
glClear(GL_COLOR_BUFFER_BIT);
float ticks = (float)SDL_GetTicks() / 1000.0f;
float elapsed = ticks - lastFrameTicks;
lastFrameTicks = ticks;
//Read Input and Update World
while (SDL_PollEvent(&event)) { // a lot of events could cue up, no?, could also get all keyboard states and check for those. I think I like that better. - specially for pong
if (event.type == SDL_QUIT || event.type == SDL_WINDOWEVENT_CLOSE) {
done = true;
}
}
const Uint8 *keys = SDL_GetKeyboardState(NULL);
if (keys[SDL_SCANCODE_UP]) {
paddleright.y += elapsed*paddleright.velocity_y;
if (paddleright.y > (1 - .2)){ paddleright.y = 1 - .2; }
}
else if (keys[SDL_SCANCODE_DOWN]) {
paddleright.y -= elapsed*paddleright.velocity_y;
if (paddleright.y < (-1 + .2)){ paddleright.y = -1 + .2; }
}
if (keys[SDL_SCANCODE_W]) {
paddleleft.y += elapsed*paddleleft.velocity_y;
if (paddleleft.y >(1 - .2)){ paddleleft.y = 1 - .2; }
}
else if (keys[SDL_SCANCODE_S]) {
paddleleft.y -= elapsed*paddleleft.velocity_y;
if (paddleleft.y < (-1 + .2)){ paddleleft.y = -1 + .2; }
}
updateBall(elapsed);
isWin();
//Render World
ball.Draw();
paddleleft.Draw();
paddleright.Draw();
if (rightwin)
{
endGame();
rightwinE.Draw();
}
if (leftwin)
{
endGame();
leftwinE.Draw();
}
SDL_GL_SwapWindow(displayWindow);//Swaps old modelview with new one?
}
SDL_Quit();
return 0;
}
int main(void)
{
// seed pseudorandom number generator
srand48(time(NULL));
// instantiate window
GWindow window = newGWindow(WIDTH, HEIGHT);
// instantiate bricks
initBricks(window);
// instantiate ball, centered in middle of window
GOval ball = initBall(window);
// instantiate paddle, centered at bottom of window
GRect paddle = initPaddle(window);
// instantiate scoreboard, centered in middle of window, just above ball
GLabel label = initScoreboard(window);
// number of bricks initially
int bricks = COLS * ROWS;
updateScoreboard(window, label, 0);
// number of lives initially
int lives = LIVES;
// number of points initially
int points = 0;
// define ball's velocity
double xvelocity = 2.5 * drand48();
double yvelocity = 2.5;
waitForClick();
// keep playing until game over
while (lives > 0 && bricks > 0)
{
// TODO
//set paddle to follow mouse
GEvent event = getNextEvent(MOUSE_EVENT);
if (event != NULL)
{
if (getEventType(event) == MOUSE_MOVED)
{
double x = getX(event) - 25;
setLocation(paddle, x, 500);
}
}
// move ball
move(ball, xvelocity, yvelocity);
// bounce from side walls
if (getX(ball) + getWidth(ball) >= getWidth(window))
{
xvelocity = -xvelocity;
}
else if (getX(ball) <= 0)
{
xvelocity = -xvelocity;
}
// bounce from ceiling or floor
if (getY(ball) + getHeight(ball) >= getHeight(window))
{
lives--;
removeGWindow(window, ball);
ball = initBall(window);
waitForClick();
continue;
}
else if (getY(ball) <= 0)
{
yvelocity = -yvelocity;
}
// detect collision between objects
GObject object = detectCollision(window, ball);
if (object != NULL)
{
// bounce off paddle
if (object == paddle)
{
if (yvelocity > 0.0)
{
yvelocity = -yvelocity;
}
}
// bounce off and remove block
else if (strcmp(getType(object), "GRect") == 0)
{
yvelocity = -yvelocity;
bricks--;
updateScoreboard(window, label, 50 - bricks);
removeGWindow(window, object);
}
}
pause(10);
}
// wait for click before exiting
waitForClick();
// game over
closeGWindow(window);
return 0;
}
int main(void)
{
// seed pseudorandom number generator
srand48(time(NULL));
// instantiate window
GWindow window = newGWindow(WIDTH, HEIGHT);
// instantiate bricks
initBricks(window);
// instantiate ball, centered in middle of window
GOval ball = initBall(window);
// instantiate paddle, centered at bottom of window
GRect paddle = initPaddle(window);
// instantiate scoreboard, centered in middle of window, just above ball
GLabel label = initScoreboard(window);
// number of bricks initially
int bricks = COLS * ROWS;
// number of lives initially
int lives = LIVES;
// number of points initially
int points = 0;
// make the ball’s initial velocity along its (horizontal) x-axis random.
srand48((long int) time(NULL));
double velocityX = -BALL_VELOCITY + 2 * BALL_VELOCITY * drand48();
double velocityY = BALL_VELOCITY;
while (true)
{
GEvent event = getNextEvent(MOUSE_EVENT);
if (event != NULL)
{
if (getEventType(event) == MOUSE_CLICKED)
{
break;
}
}
}
// keep playing until game over
while (lives > 0 && bricks > 0)
{
// TODO
move(ball, velocityX, velocityY);
GEvent event = getNextEvent(MOUSE_EVENT);
if (event != NULL)
{
if (getEventType(event) == MOUSE_MOVED)
{
double x = 0;
if (getX(event) - PADDLE_WIDTH / 2 <= 0)
{
x = 0;
}
else if (getX(event) + PADDLE_WIDTH / 2 >= WIDTH)
{
x = WIDTH - PADDLE_WIDTH;
}
else
{
x = getX(event) - PADDLE_WIDTH / 2;
}
double y = getY(paddle);
setLocation(paddle, x, y);
}
}
if (getX(ball) + 2 * RADIUS >= WIDTH)
{
velocityX = -velocityX;
}
else if (getX(ball) <= 0)
{
velocityX = -velocityX;
}
/*// the bottom edge condition
else if (getY(ball) + 2 * RADIUS >= HEIGHT)
{
velocityY = -velocityY;
}
*/
else if (getY(ball) > getY(paddle) + PADDLE_WIDTH / 2)
{
lives--;
if (lives > 0)
{
while (true)
{
GEvent event = getNextEvent(MOUSE_EVENT);
if (event != NULL)
{
if (getEventType(event) == MOUSE_CLICKED)
{
break;
}
}
}
setLocation(ball, (getWidth(window) - 2 * RADIUS) / 2,
(getHeight(window) - 2 * RADIUS) / 2);
move(ball, velocityX, velocityY);
}
}
else if (getY(ball) <= 0)
{
velocityY = -velocityY;
}
GObject object = detectCollision(window, ball);
if (object != NULL)
{
if (object == paddle)
{
// TODO
velocityY = -velocityY;
}
/*// More generally with the same functionality
if (strcmp(getType(object), "GRect") == 0)
{
// TODO
}
*/
if (strcmp(getType(object), "GLabel") == 0)
{
// TODO
sendToBack(object);
}
if (strcmp(getType(object), "GRect") == 0 && object != paddle)
{
// TODO
bricks--;
removeGWindow(window, object);
updateScoreboard(window, label, ++points);
velocityY = -velocityY;
}
}
pause(8);
}
// wait for click before exiting
waitForClick();
// game over
closeGWindow(window);
return 0;
}
int main(void)
{
// seed pseudorandom number generator
srand48(time(NULL));
// instantiate window
GWindow window = newGWindow(WIDTH, HEIGHT);
// instantiate bricks
initBricks(window);
// instantiate ball, centered in middle of window
GOval ball = initBall(window);
sendForward(ball); //send ball forword.
// instantiate paddle, centered at bottom of window
GRect paddle = initPaddle(window);
// instantiate scoreboard, centered in middle of window, just above ball
GLabel label = initScoreboard(window);
sendBackward(label); //send label backwords
// number of bricks initially
int bricks = COLS * ROWS;
// number of lives initially
int lives = LIVES;
// number of points initially
int points = 0;
//velocity constants for x and y directions for velocity of ball
double velocityX = 0.029;
double velocityY = 0.043;
//wait for click before starting
waitForClick();
// keep playing until game over
while (lives > 0 && bricks > 0)
{
//moving paddle with mouse movement in x direction only.
// check for mouse event
GEvent Mevent = getNextEvent(MOUSE_EVENT);
// if we heard one
if (Mevent != NULL)
{
// if the Mevent was a mouse movement
if (getEventType(Mevent) == MOUSE_MOVED)
{
// moves paddle only in x direction with movement of mouse.
double x = getX(Mevent);
if(x > PADDLEW/2 && x < WIDTH-(PADDLEW/2))
{
setLocation(paddle, x-(PADDLEW/2), PADDLEY );
}
}
}
//move ball with given velocity constants.
move(ball, velocityX, velocityY );
// bounce off right edge of window
if (getX(ball) + getWidth(ball) >= getWidth(window))
{
velocityX = -velocityX;
}
// bounce off left edge of window
else if (getX(ball) <= 0)
{
velocityX = -velocityX;
}
//bounce off the top edge of window
else if (getY(ball) <= 0)
{
velocityY = -velocityY;
}
//if ball touch bottom edge decrese a life and reset the ball at center of window and lunnch again after click.
else if(getY(ball) + getHeight(ball) >= getHeight(window))
{
lives = lives-1;
waitForClick();
setLocation(ball, WIDTH/2, HEIGHT/2);
//close window if live finishes.
if(lives == 0){
closeGWindow(window);
}
}
//ball movement, edge bounce , and lives calculation part end here.
//detect collsion of ball with other objects.
//paddlecollde is the object with ball collided.
GObject collide = detectCollision(window ,ball);
if(collide == paddle){
velocityY = -velocityY;
//funkey fun with color
char* colorpaddle = malloc(20*sizeof(char));
colorpaddle = getColorGObject(ball);
setColor(paddle,colorpaddle);
freeGObject(colorpaddle);
}
if(collide == label ){
//funkey fun with color
char* colorlabel = malloc(20*sizeof(char));
colorlabel = getColorGObject(ball);
setColor(label,colorlabel);
freeGObject(colorlabel);
}
//collidedObj is the object with ball collides.
GObject collidedObj = detectCollision(window, ball);
if(collidedObj){
if(collidedObj != paddle && collidedObj != label){
//funkey fun with color
char* colorball = malloc(20*sizeof(char));
colorball = getColorGObject(collidedObj);
setColor(ball,colorball);
freeGObject(colorball);
//if collided object is brick then remove bricks and increse and update score and decrese no of bricks and bounce ball.
removeGWindow(window, collidedObj);
points++;
bricks--;
updateScoreboard(window, label, points);
velocityY = -velocityY;
freeGObject(colorball);
freeGObject(collidedObj);
}
}
}
// wait for click before exiting
waitForClick();
// game over
closeGWindow(window);
freeGObject(paddle);
freeGObject(ball);
freeGObject(label);
return 0;
}
int main(void)
{
// seed pseudorandom number generator
srand48(time(NULL));
// instantiate window
GWindow window = newGWindow(WIDTH, HEIGHT);
// instantiate bricks
initBricks(window);
// instantiate ball, centered in middle of window
GOval ball = initBall(window);
// instantiate paddle, centered at bottom of window
GRect paddle = initPaddle(window);
// instantiate scoreboard, centered in middle of window, just above ball
GLabel label = initScoreboard(window);
// number of bricks initially
int bricks = COLS * ROWS;
// number of lives initially
int lives = LIVES;
// number of points initially
int points = 0;
// wait for click before starting
waitForClick();
// set velocity
double velocity = drand48() * 4.0;
double velocity_y = 5.0;
// keep playing until game over
while (lives > 0 && bricks > 0)
{
// TODO
// Scoreboard
updateScoreboard(window, label, points);
// move ball
move(ball, velocity, velocity_y);
// linger before ball moving again
pause(10);
// check for mouse event
GEvent mouseMove = getNextEvent(MOUSE_EVENT);
// move paddle with cursor
if (mouseMove != NULL)
{
// if the event was movement
if (getEventType(mouseMove) == MOUSE_MOVED)
{
// ensure paddle follows top cursor
double x = getX(mouseMove) - getWidth(paddle) / 2;
double y = 550;
setLocation(paddle, x, y);
}
}
GObject object = detectCollision(window, ball);
if (object != NULL)
{
// If hits the paddle.
if (object == paddle)
{
velocity_y = -velocity_y;
}
// If hits a brickck. Remove brick, add point.
else if (strcmp(getType(object), "GRect") == 0)
{
removeGWindow(window, object);
velocity_y = -velocity_y;
points++;
bricks--;
}
}
// If hits right wall.
if (getX(ball) + getWidth(ball) >= getWidth(window))
{
velocity = -velocity;
}
// If hits left wall.
if (getX(ball) <= 0)
{
velocity = -velocity;
}
// If hits top wall.
if (getY(ball) <= 0)
{
velocity_y = -velocity_y;
}
// If hits bottom, subtract life and start over.
if (getY(ball) + getHeight(ball) >= getHeight(window))
{
int x = (getWidth(window) - 25) / 2;
int y = (getHeight(window) - 25) / 2;
lives--;
// move ball to start
setLocation(ball, x, y);
// move paddle to start
setLocation(paddle, (getWidth(window) - 100) / 2, 550);
waitForClick();
}
}
// You Lose Label Message for kicks.
if (bricks > 0)
{
GLabel game_over = newGLabel("YOU LOSE!");
setFont(game_over, "SansSerif-70");
setColor(game_over, "RED");
add(window, game_over);
setLocation(game_over, 15, 300);
}
// wait for click before exiting
waitForClick();
// game over
closeGWindow(window);
return 0;
}
int main(void)
{
// seed pseudorandom number generator
srand48(time(NULL));
// instantiate window
GWindow window = newGWindow(WIDTH, HEIGHT);
// instantiate bricks
initBricks(window);
// instantiate ball, centered in middle of window
GOval ball = initBall(window);
// instantiate paddle, centered at bottom of window
GRect paddle = initPaddle(window);
// instantiate scoreboard, centered in middle of window, just above ball
GLabel label = initScoreboard(window);
// number of bricks initially
int bricks = COLS * ROWS;
// number of lives initially
int lives = LIVES;
// number of points initially
int points = 0;
// keep playing until game over
double velocity = drand48()*2;
double angle = drand48()*3;
while (lives > 0 && bricks > 0)
{
// check for mouse event
GEvent event = getNextEvent(MOUSE_EVENT);
// if we heard one
if (event != NULL)
{
// if the event was movement
if (getEventType(event) == MOUSE_MOVED)
{
double x = getX(event)-PADDLEW/2;
double y = HEIGHT - PADDLEH;
setLocation(paddle, x, y);
}
}
move(ball, velocity, angle);
GObject object = detectCollision(window, ball);
// bounce off right edge of window
if (getX(ball) + getWidth(ball) > 400)
{
velocity = -velocity;
}
// bounce off left edge of window
else if (getX(ball) <= 0)
{
velocity = -velocity;
}
// Dtects if the ball hit the paddle then reverses angle
else if(object == paddle)
{
angle = -angle;
}
//Detects if it hits the bottom of the screen
else if(getY(ball) + getHeight(ball) > HEIGHT)
{
removeGWindow(window, ball);
waitForClick();
ball = initBall(window);
lives -= 1;
}
else if (getY(ball) <= 0)
{
angle = -angle;
}
else if (strcmp(getType(object), "GRect") == 0)
{
angle = -angle;
removeGWindow(window, object);
initScoreboard(window);
updateScoreboard(window, label, points);
points += 1;
if(points == 50)
{
break;
}
}
// linger before moving again
pause(5);
}
// wait for click before exiting
waitForClick();
// game over
closeGWindow(window);
return 0;
}
int main(void)
{
// seed pseudorandom number generator
srand48(time(NULL));
// instantiate window
GWindow window = newGWindow(WIDTH, HEIGHT);
// instantiate bricks
initBricks(window);
// instantiate ball, centered in middle of window
GOval ball = initBall(window);
// instantiate paddle, centered at bottom of window
GRect paddle = initPaddle(window);
// instantiate scoreboard, centered in middle of window, just above ball
GLabel label = initScoreboard(window);
// number of bricks initially
int bricks = COLS * ROWS;
// number of lives initially
int lives = LIVES;
// number of points initially
int points = 0;
double x = 0.0;
double vx = 2.5;
double vy = 2.5;
waitForClick();
while (lives > 0 && bricks > 0) // keep playing until game over //TODO FUN
{
GEvent event = getNextEvent(MOUSE_EVENT);
if (event != NULL)
{
if (getEventType(event) == MOUSE_MOVED)
{
x = getX(event) -getWidth(paddle)/2;
setLocation(paddle,x,588);
}
}
move(ball,vx,vy);
if ((getX(ball) + getWidth(ball) >= WIDTH) || (getX(ball) <= 0))
{
vx = -vx;
}
else if ((getY(ball) <= 0))
{
vy = -vy;
}
else if (getY(ball) + getHeight(ball) >= HEIGHT)
{
lives--;
pause(250);
setLocation(ball, WIDTH/2, HEIGHT/2);
setLocation(paddle, 165, 588);
}
pause(7);
GObject object = detectCollision( window, ball);
if (object == paddle)
{
vy = -vy;
}
if (object != paddle && strcmp(getType(object),"GRect") == 0)
{
removeGWindow(window,object);
points++;
bricks--;
updateScoreboard(window,label,points);
vy = -vy;
}
}
// wait for click before exiting
// game over
closeGWindow(window);
if (points >= 50)
{
printf("You won, Congrats!!!!!!!!!!\n");
}
else
{
printf("You lose!!!\n");
}
return 0;
}
int main(void)
{
// seed pseudorandom number generator
srand48(time(NULL));
// instantiate window
GWindow window = newGWindow(WIDTH, HEIGHT);
// instantiate bricks
initBricks(window);
// instantiate ball, centered in middle of window
GOval ball = initBall(window);
// instantiate paddle, centered at bottom of window
GRect paddle = initPaddle(window);
// instantiate scoreboard, centered in middle of window, just above ball
GLabel score = initScoreboard(window);
// number of bricks initially
int bricks = COLS * ROWS;
// number of lives initially
int lives = LIVES;
// number of points initially
int points = 0;
// creates invisible rect to detect if ball has gone beyond window
double x = drand48();
if (x < 0.5)
{
x = x * 2;
}
else
{
x = x * 4;
}
double y = drand48();
if (y < 0.5)
{
y = y * 3;
}
else
{
y = y * 6;
}
double velocity_x = x;
double velocity_y = y;
// keep playing until game over
while (lives > 0 && bricks > 0)
{
move(ball, velocity_x, velocity_y);
pause(7.5);
if (getX(ball) + getWidth(ball) >= getWidth(window))
{
velocity_x = -velocity_x;
}
else if (getX(ball) < 0)
{
velocity_x = -velocity_x;
}
else if (getY(ball) <= 0 )
{
velocity_y = -velocity_y;
}
else if (getY(ball) + getHeight(ball) >= getHeight(window))
{
lives = lives - 1;
int velocity_x_end = velocity_x * 0;
int velocity_y_end = velocity_y * 0;
while (getY(ball) + getHeight(ball) >= getHeight(window))
{
move(ball, velocity_x_end, velocity_y_end);
GEvent mouse_clicked = getNextEvent(MOUSE_EVENT);
if (mouse_clicked != NULL)
{
if (getEventType(mouse_clicked) == MOUSE_CLICKED)
{
setLocation(ball,((WIDTH/2)-(30/2)),((HEIGHT/2)+(30/2)));
move(ball, velocity_x, velocity_y);
}
}
}
}
GObject collide = detectCollision(window, ball);
if(collide == paddle)
{
if (velocity_y > 0)
{
velocity_y = -velocity_y;
}
}
else if (strcmp(getType(collide),"GRect") == 0 && collide != paddle)
{
if (velocity_y < 0)
{
velocity_y = -velocity_y;
}
removeGWindow(window, collide);
points = points + 1;
updateScoreboard(window, score, points);
}
GEvent move_paddle = getNextEvent(MOUSE_EVENT);
if (move_paddle != NULL)
{
if (getEventType(move_paddle) == MOUSE_MOVED)
{
double x_paddle = getX(move_paddle);
setLocation(paddle, x_paddle - (P_WIDTH/2), 550);
}
}
if (points == 50)
{
break;
}
}
// wait for click before exiting
waitForClick();
// game over
closeGWindow(window);
return 0;
}
int main(void)
{
// seed pseudorandom number generator
srand48(time(NULL));
// instantiate window
GWindow window = newGWindow(WIDTH, HEIGHT);
// instantiate bricks
initBricks(window);
// instantiate ball, centered in middle of window
GOval ball = initBall(window);
// instantiate paddle, centered at bottom of window
GRect paddle = initPaddle(window);
// instantiate scoreboard, centered in middle of window, just above ball
GLabel label = initScoreboard(window);
// number of bricks initially
int bricks = COLS * ROWS;
// number of lives initially
int lives = LIVES;
// number of points initially
int points = 0;
// keep playing until game over
double velocity_x = drand48() * 3;
double velocity_y = 2.5;
double x = getX(ball);
double y = getY(ball);
waitForClick();
while (lives > 0 && bricks > 0)
{
GEvent event = getNextEvent(MOUSE_EVENT);
if (event != NULL)
if(getEventType(event) == MOUSE_MOVED)
{
double x = getX(event) - getWidth(paddle) / 2;
double y = 500;
setLocation(paddle, x, y);
}
move(ball, velocity_x, velocity_y);
if (getY(ball) + getHeight(ball) > getHeight(window))
{
velocity_y = -velocity_y;
}
else if (getY(ball) <= 0)
{
velocity_y = -velocity_y;
}
else if (getX(ball) + getWidth(ball) > getWidth(window))
{
velocity_x = -velocity_x;
}
else if (getX(ball) <= 0)
{
velocity_x = -velocity_x;
}
GObject object = detectCollision(window, ball);
if (object == paddle)
{
velocity_y = -velocity_y;
}
if ((strcmp(getType(object), "GRect") == 0) && (object != paddle))
{
points = points + 1;
removeGWindow(window, object);
velocity_y = -velocity_y;
char s[12];
sprintf(s, "Score: %i", points);
setLabel(label, s);
}
if (points == 50)
{
char s[12];
sprintf(s, "Well Done!");
setLabel(label, s);
pause(10);
break;
}
if (getY(ball) + 95 >= getHeight(window))
{
lives = lives -1;
removeGWindow(window, ball);
waitForClick();
ball = initBall(window);
char t[12];
sprintf(t, "Lives: %i", lives);
setLabel(label, t);
}
if (lives == 0)
{
char s[12];
sprintf(s, "Score: %i", points);
sprintf(s,"Nice try!");
setLabel(label, s);
pause(20);
break;
}
pause(10);
}
waitForClick();
pause(10);
// game over
closeGWindow(window);
return 0;
}
int main(int argc, string argv[])
{
bool god_mode = false;
if (argc > 1)
{
if (strlen(argv[1]) == 3 && strncmp(argv[1], "GOD", 3) == 0)
// set god mode flag
god_mode = true;
else
{
printf("It seems you don't know the magic word...\n");
return 1;
}
}
// seed pseudorandom number generator
srand48(time(NULL));
// instantiate window
GWindow window = newGWindow(WIDTH, HEIGHT);
// instantiate bricks and return array with brick-Y coordinates for scoring
int *brick_offsets = initBricks(window);
// instantiate ball, centered in middle of window
GOval ball = initBall(window);
add(window, ball);
// instantiate paddle, centered at bottom of window
GRect paddle = initPaddle(window);
add(window, paddle);
// instantiate scoreboard, centered in middle of window, just above ball
GLabel label = initScoreboard(window);
add(window, label);
setLocation(label, WIDTH / 2, HEIGHT / 2);
// number of bricks initially
int bricks = COLS * ROWS;
// number of lives initially
int lives = LIVES;
// number of points initially
int points = 0;
// let scoreboard show up at the beginning of the game
updateScoreboard(window, label, points);
// declare once useful variables for game loop
double mouse_x, paddle_x;
double ball_x, ball_y;
// paddle width is gonna change through the game
double paddle_width = PADDLE_WIDTH;
// start the ball with random x (scaled down by const)
double ball_x_velocity = fmod(drand48() * BALL_VELOCITY_SCALE, BALL_VELOCITY_SCALE);
double ball_y_velocity = 0.1;
// wait for click before entering the game loop
waitForClick();
// keep playing until game over
while (lives > 0 && bricks > 0)
{
// move the ball
move(ball, ball_x_velocity, ball_y_velocity);
// god mode
if (god_mode)
{
if (getX(ball) > 0 && getX(ball) + paddle_width < WIDTH)
setLocation(paddle, getX(ball), PADDLE_BOTTOM_OFFSET);
}
// check user input (mouse movements)
else
{
GEvent event = getNextEvent(MOUSE_EVENT);
if (event != NULL && getEventType(event) == MOUSE_MOVED)
{
// set paddle x to be the paddle center aligned to the x mouse event
// keep paddle y constant (don't move through the y axis)
mouse_x = getX(event);
paddle_x = mouse_x - paddle_width / 2;
// check mouse event x to keep paddle in the canvas
if (mouse_x <= paddle_width / 2)
paddle_x = 0;
else if (mouse_x >= WIDTH - paddle_width / 2)
paddle_x = WIDTH - paddle_width;
// update paddle position
setLocation(paddle, paddle_x, PADDLE_BOTTOM_OFFSET);
}
}
// store x and y for ball and prevent further functions calls
ball_x = getX(ball);
ball_y = getY(ball);
// bouncing checks
// top window bouncing
if (ball_y <= 0)
ball_y_velocity = -ball_y_velocity;
// bottom window bouncing
else if (ball_y + BALL_DIMENSION >= HEIGHT)
{
// spawn ball from the center
setLocation(ball, WIDTH / 2 - BALL_RADIUS, HEIGHT / 2 - BALL_RADIUS);
// center the paddle
setLocation(paddle, WIDTH / 2 - PADDLE_WIDTH / 2,
PADDLE_BOTTOM_OFFSET);
// pause 1 sec, update lives and starting ball velocity to random
pause(1000);
ball_x_velocity = fmod(drand48() * BALL_VELOCITY_SCALE, BALL_VELOCITY_SCALE);
lives -= 1;
}
// left and right bouncing
if (ball_x + BALL_DIMENSION >= WIDTH || ball_x <= 0)
ball_x_velocity = -ball_x_velocity;
// check for collisions
GObject collided_obj = detectCollision(window, ball);
if (collided_obj != NULL)
{
// check for rectangular object type
if (strcmp(getType(collided_obj), "GRect") == 0)
{
// ball hit the paddle
if (collided_obj == paddle)
{
ball_y_velocity = -ball_y_velocity;
// prevent paddle-ball overlapping
setLocation(ball, ball_x,
PADDLE_BOTTOM_OFFSET - BALL_RADIUS * 2);
}
// ball hit a brick
else if (collided_obj != paddle)
{
ball_y_velocity = -ball_y_velocity;
ball_y_velocity += ball_y_velocity * BALL_VELOCITY_FACTOR;
// reduce paddle width on every destroyed brick
paddle_width -= PADDLE_SHRINKING;
setSize(paddle, paddle_width, PADDLE_HEIGHT);
// remove brick and update game status variables
// points get updated properly for bricks on different levels
points += getPoints(brick_offsets, getY(collided_obj));
removeGWindow(window, collided_obj);
bricks -= 1;
updateScoreboard(window, label, points);
}
}
}
}
// wait for click before exiting
waitForClick();
// game over
closeGWindow(window);
// fremem
free(brick_offsets);
return 0;
}
int main(void)
{
// seed pseudorandom number generator
srand48(time(NULL));
// instantiate window
GWindow window = newGWindow(WIDTH, HEIGHT);
// instantiate bricks
initBricks(window);
// instantiate ball, centered in middle of window
GOval ball = initBall(window);
// instantiate paddle, centered at bottom of window
GRect paddle = initPaddle(window);
// instantiate scoreboard, centered in middle of window, just above ball
GLabel label = initScoreboard(window);
// number of lives initially
int lives = LIVES;
// number of points initially
int points = 0;
// number of bricks initially
int bricks = COLS * ROWS - points;
// initial velocity
srand48(time(NULL));
double xvelocity = 2.0;
double yvelocity = (1 + drand48()) * 2;
// keep playing until game over
while (lives > 0 && bricks > 0)
{
// move ball along x & y
move(ball, xvelocity, yvelocity);
// bounce off right edge of window
if (getX(ball) + getWidth(ball) >= getWidth(window))
{
xvelocity = -xvelocity;
}
// bounce off left edge of window
if (getX(ball) <= 0)
{
xvelocity = -xvelocity;
}
// ball out of bounds
if (getY(ball) + getHeight(ball) >= getHeight(window))
{
removeGWindow(window, ball);
lives--;
ball = newGOval(WIDTH / 2 - RADIUS, HEIGHT / 2 - RADIUS,
RADIUS * 2, RADIUS * 2);
setColor(ball, "RED");
setFilled(ball, true);
add(window, ball);
pause(1800);
setColor(ball, "BLACK");
setFilled(ball, true);
}
// bounce off top
if (getY(ball) <= 0)
{
yvelocity = -yvelocity;
}
// linger before moving again
pause (10);
// check for mouse event
GEvent event = getNextEvent(MOUSE_EVENT);
// if we heard event
if (event != NULL)
{
// if the event was a movement
if (getEventType(event) == MOUSE_MOVED)
{
// ensure the paddle follows mouse
double x = getX(event) - getWidth(paddle) / 2;
setLocation(paddle, x, HEIGHT * .92);
}
}
// ball paddle collision
GObject object = detectCollision(window, ball);
if (object == paddle)
{
yvelocity = -yvelocity;
}
else if (object == label)
{
;
}
else if (object != NULL)
{
// xvelocity = -xvelocity;
yvelocity = -yvelocity;
removeGWindow(window, object);
points++;
updateScoreboard(window, label, points);
}
}
// wait for click before exiting
waitForClick();
// game over
closeGWindow(window);
return 0;
}
int main(void)
{
// seed pseudorandom number generator
srand48(time(NULL));
// instantiate window
GWindow window = newGWindow(WIDTH, HEIGHT);
// instantiate bricks
initBricks(window);
// instantiate ball, centered in middle of window
GOval ball = initBall(window);
// randomize x velocity of ball
double xvelocity = drand48()/50 + 0.05;
double yvelocity = 0.1;
// instantiate paddle, centered at bottom of window
GRect paddle = initPaddle(window);
// instantiate scoreboard, centered in middle of window, just above ball
GLabel label = initScoreboard(window);
// number of bricks initially
int bricks = COLS * ROWS;
// number of lives initially
int lives = LIVES;
// number of points initially
int points = 0;
while (lives > 0 && bricks > 0)
{
GEvent event = getNextEvent(MOUSE_EVENT);
// if we heard one
if (event != NULL)
{
// if the event was movement
if (getEventType(event) == MOUSE_MOVED)
{
// ensure paddle follows mouse
double x = getX(event) - WIDTHPADDLE/2;
// makes sure paddle stays within screen
if (x >= 0 || x <= WIDTH)
{
setLocation(paddle, x, 9*HEIGHT/10);
}
if (x < 0)
{
setLocation(paddle, 0, 9*HEIGHT/10);
}
if (x > WIDTH - WIDTHPADDLE)
{
setLocation(paddle, WIDTH - WIDTHPADDLE, 9*HEIGHT/10);
}
}
}
// compels ball to move
move(ball, xvelocity, yvelocity);
// bounce off edge of window
if (getX(ball) + getWidth(ball) >= WIDTH || getX(ball) <= 0)
{
xvelocity = -xvelocity;
}
// bouce off top edge of window
if (getY(ball) <= 0)
{
yvelocity = -yvelocity;
}
// detect collision
GObject object = detectCollision(window, ball);
// bounce off paddle
if (object == paddle)
{
yvelocity = -yvelocity;
}
// bounce off brick
else if (object != NULL)
{
if (strcmp(getType(object), "GRect") == 0)
{
yvelocity = -yvelocity;
bricks--;
removeGWindow(window, object);
points++;
}
}
// update scoreboard
updateScoreboard(window, label, points);
// ball at bottom edge of window
if (getY(ball) + 2*RADIUS >= HEIGHT)
{
lives--;
if (lives >= 1)
{
waitForClick();
}
setLocation(ball, WIDTH/2 - RADIUS, HEIGHT/2 - RADIUS);
}
}
// wait for click before exiting
waitForClick();
// game over
closeGWindow(window);
return 0;
}
int main(void)
{
// seed pseudorandom number generator
srand48(time(NULL));
// instantiate window
GWindow window = newGWindow(WIDTH, HEIGHT);
// instantiate bricks
initBricks(window);
// instantiate ball, centered in middle of window
GOval ball = initBall(window);
// instantiate paddle, centered at bottom of window
GRect paddle = initPaddle(window);
// instantiate scoreboard, centered in middle of window, just above ball
GLabel label = initScoreboard(window);
// number of bricks initially
int bricks = COLS * ROWS;
// number of lives initially
int lives = LIVES;
// number of points initially
int points = 0;
// initial velocity
double standardReduction = 0.07;
double velocity = drand48() - standardReduction;
double velocityY = 2;
waitForClick();
// keep playing until game over
while (lives > 0 && bricks > 0)
{
// Get the next mouse event
GEvent event = getNextEvent(MOUSE_EVENT);
// If some move
if (event != NULL)
{
if (getEventType(event) == MOUSE_MOVED)
{
double x = getX(event) - (PADDLE_WIDTH / 2);
double y = 500;
setLocation(paddle, x, y);
}
}
move(ball, velocity, velocityY);
// bounce off right edge of window
if (getX(ball) + RADIUS >= WIDTH)
{
velocity = -velocity;
}
// bounce off left edge of window
else if (getX(ball) <= 0)
{
velocity = -velocity;
}
// bounce off top edge
else if (getY(ball) <= 0)
{
velocityY = -velocityY;
}
// bottom edge
else if (getY(ball) + RADIUS >= HEIGHT)
{
velocityY = 0;
velocity = 0;
lives--;
removeGWindow(window, ball);
removeGWindow(window, paddle);
ball = initBall(window);
paddle = initPaddle(window);
velocity = drand48() - standardReduction;
velocityY = 2;
waitForClick();
}
GObject obj = detectCollision(window, ball);
if (obj != NULL)
{
if (obj == paddle)
{
velocityY = -velocityY;
}
else if (strcmp(getType(obj), "GRect") == 0)
{
removeGWindow(window, obj);
bricks--;
points++;
updateScoreboard(window, label, points);
velocityY = -velocityY;
}
}
pause(3);
}
if (bricks == 0)
{
updateScoreboard(window, label, 51);
}
else
{
updateScoreboard(window, label, 0);
}
// wait for click before exiting
waitForClick();
// game over
closeGWindow(window);
return 0;
}
int main(void)
{
// seed pseudorandom number generator
srand48(time(NULL));
// instantiate window
GWindow window = newGWindow(WIDTH, HEIGHT);
// instantiate bricks
initBricks(window);
// instantiate ball, centered in middle of window
GOval ball = initBall(window);
// instantiate paddle, centered at bottom of window
GRect paddle = initPaddle(window);
// instantiate scoreboard, centered in middle of window, just above ball
GLabel label = initScoreboard(window);
// number of bricks initially
int bricks = COLS * ROWS;
// number of lives initially
int lives = LIVES;
// number of points initially
int points = 0;
// need to get velocity of paddle
double t_paddle = 0.0;
// keep playing until game over
while (lives > 0 && bricks > 0)
{
// Win condition
if (points == bricks) {
setLabel(scoreboard, "You WIN!");
break;
}
// Lose life condition
if (getHeight(ball) == HEIGHT) {
lives--;
break;
}
// Dictate Paddle movement
// Test to see if you can move off screen
// if left and right cursors move at an accelrated pace, time based
GKeyEvent e = waitForEvent(KEY_EVENT);
if (getEventType(e) == LEFT_ARROW_KEY) {
//KEY_PRESSED
// KEY_RELEASED
t_paddle = e.getEventTime();
move(paddle, -1, 0);
}
else if (getEventType(e) == LEFT_ARROW_KEY) {
t_paddle = e.getEventTime();
move(paddle, 1, 0);
}
printf("time of event: %d", t_paddle);
// If ball hits brick
// Test if top or side of ball hits a brick, does it still detect
GObject hitBrick = detectCollision(window, ball);
if(hitBrick != NULL) {
remove(window, hitBrick);
points++;
updateScoreboard(window, scoreboard, points);
//call ball bounce logic;
}
// Ball bouncing logic
int ballX = getX(ball);
int ballY = getY(ball);
int paddleX = getX(paddle);
if (ballX == 0 || ballX + getWidth(ball) == WIDTH) {
setLocation(ball, -ballX, y);
}
else if (ballY == 0) {
setLocation(ball, x, -ballY);
}
// Hit paddle and within the width of paddle, do complicated bouncing
else if (ballY + getHieght(ball) == getY(paddle) &&
ballX >= paddleX &&
ballX + getWidth(ball) <= paddleX + getWidth(paddle)) {
//bounce logic
}
}
// wait for click before exiting
waitForClick();
// game over
closeGWindow(window);
return 0;
}
int main(void)
{
// seed pseudorandom number generator
srand48(time(NULL));
// instantiate window
GWindow window = newGWindow(WIDTH, HEIGHT);
// instantiate bricks
initBricks(window);
// instantiate life counter
GOval lifeball1 = newGOval(WIDTH - 30, 20, DIAMETER, DIAMETER);
setFilled(lifeball1, true);
setColor(lifeball1, "#000000");
add(window, lifeball1);
GOval lifeball2 = newGOval(WIDTH - 50, 20, DIAMETER, DIAMETER);
setFilled(lifeball2, true);
setColor(lifeball2, "#000000");
add(window, lifeball2);
// instantiate ball, centered in middle of window
GOval ball = initBall(window);
// instantiate paddle, centered at bottom of window
GRect paddle = initPaddle(window);
// instantiate scoreboard, centered in middle of window, just above ball
GLabel scoreboard = initScoreboard(window);
// number of bricks initially
int bricks = COLS * ROWS;
// number of lives initially
int lives = LIVES;
// number of points initially
int points = 0;
//initialize ball velocities
double xvelocity = drand48();
double yvelocity = 2.0;
// keep playing until game over
if (lives > 0)
{
waitForClick();
}
while (lives > 0 && bricks > 0)
{
// compel paddle to follow mouse along x-axis by listening for mouse_event
GEvent paddlemove = getNextEvent(MOUSE_EVENT);
// if there was an event
if (paddlemove != NULL)
{
// if the event was movement
if (getEventType(paddlemove) == MOUSE_MOVED)
{
// make paddle follow mouse pointer's motion along the x axis only
double paddlex = getX(paddlemove) - getWidth(paddle) / 2;
double paddley = 565;
setLocation(paddle, paddlex, paddley);
}
}
// move ball along both x and y
move(ball, xvelocity, yvelocity);
GObject collided = detectCollision(window, ball);
// Correct code to make ball bounce - this does not work, despite working exactly as so in bounce.c
//perhaps a switch is in order using detect collision for bouncing
if (getX(ball) + DIAMETER >= WIDTH)
{
xvelocity = -xvelocity;
}
// bounce off left edge of window
else if (getX(ball) <= 0)
{
xvelocity = -xvelocity;
}
else if (getY(ball) <= 0)
{
yvelocity = -yvelocity;
}
else if (collided == paddle)
{
yvelocity = -yvelocity;
xvelocity = xvelocity + (drand48() - drand48());
}
else if ((((collided != NULL) && (collided != paddle))
&& (collided != scoreboard)) && (strcmp(getType(collided), "GOval") != 0))
{
yvelocity = -yvelocity;
xvelocity = xvelocity + (drand48() - drand48());
removeGWindow(window, collided);
points++;
bricks = bricks - 1;
updateScoreboard(window, scoreboard, points);
}
else if (getY(ball) + DIAMETER >= HEIGHT)
{
yvelocity = 2.0;
xvelocity = drand48();
lives = lives - 1;
if (lives == 2)
{
removeGWindow(window, lifeball2);
}
else if (lives == 1)
{
removeGWindow(window, lifeball1);
}
setLocation(ball, (WIDTH / 2) - (DIAMETER / 2), (HEIGHT / 2) - (DIAMETER / 2));
setLocation(paddle, (WIDTH / 2) - (PADDLEWIDTH / 2), HEIGHT - 35);
if (lives > 0)
{
waitForClick();
}
}
// linger before moving again
pause(10);
}
// game over
if (lives > 0 && bricks == 0)
{
GLabel winner = newGLabel("YOU WON!");
setFont(winner, "SansSerif-22");
double x = (WIDTH / 2) - (getWidth(winner) / 2);
double y = HEIGHT - 250;
setLocation(winner, x, y);
setColor(winner, "#0033FF");
add(window, winner);
}
else
{
GLabel gameover = newGLabel("GAME OVER");
setFont(gameover, "SansSerif-22");
double x = (WIDTH / 2) - (getWidth(gameover) / 2);
double y = HEIGHT - 250;
setLocation(gameover, x, y);
setColor(gameover, "#990000");
add(window, gameover);
}
waitForClick();
return 0;
}
int main(int argc, string argv[])
{
bool god = false;
if (argc == 2 && (strcmp(argv[1], "GOD") == 0))
{
god = true;
}
// seed pseudorandom number generator
srand48(time(NULL));
// instantiate window
GWindow window = newGWindow(WIDTH, HEIGHT);
// instantiate bricks
initBricks(window);
// instantiate ball, centered in middle of window
GOval ball = initBall(window);
// instantiate paddle, centered at bottom of window
GRect paddle = initPaddle(window);
// instantiate scoreboard, centered in middle of window, just above ball
GLabel label = initScoreboard(window);
// number of bricks initially
int bricks = COLS * ROWS;
// number of lives initially
int lives = LIVES;
// number of points initially
int points = 0;
// velocity of ball
double x_velocity = 2 * (drand48() + 1);
double y_velocity = 2 * (drand48() + 1);
// keep playing until game over
while (lives > 0 && bricks > 0)
{
// regular non god mode play
if (!god)
{
GEvent event = getNextEvent(MOUSE_EVENT);
// if we heard one
if (event != NULL)
{
// if the event was movement
if (getEventType(event) == MOUSE_MOVED)
{
// ensure paddle follows the x of the mouse
double x = getX(event) - getWidth(paddle) / 2;
double y = getY(paddle);
setLocation(paddle, x, y);
}
}
}
// god mode, set as X of ball
else if (god)
{
double x = getX(ball);
double y = getY(paddle);
setLocation(paddle, x, y);
}
// Ball moves
// move circle along x-axis
move(ball, x_velocity, y_velocity);
// bounce off right edge of window
if (getX(ball) + getWidth(ball) >= getWidth(window))
{
x_velocity *= -1;
}
// bounce off left edge of window
else if (getX(ball) <= 0)
{
x_velocity *= -1;
}
if (getY(ball) + getHeight(ball) >= getHeight(window))
{
lives -= 1;
points -= 1;
removeGWindow(window, ball);
ball = initBall(window);
waitForClick();
}
// bounce off top edge of window
else if (getY(ball) < 0)
{
y_velocity *= -1;
}
// goes off bottom edge of window
GObject object = detectCollision(window, ball);
// sees if any collisions
if (object != NULL)
{
// avoids segmentation errors
const char *daType = getType(object);
int daMatch = strcmp(daType, "GRect");
// if hit paddle, bounce
if (object == paddle)
{
y_velocity *= -1;
}
else if (daMatch == 0)
{
// ran into the bricks
for (int i = 0; i < ROWS; i++)
{
for (int j = 0; j < COLS; j++)
{
if (object == brickz[i][j])
{
/** leftover code
int daWidth = getWidth(brickz[i][j]);
int daX = getX(brickz[i][j]);
int daHeight = getHeight(brickz[i][j]);
int daY = getY(brickz[i][j]);
int collisionX = getX(ball) + RADIUS / 2;
//if (collisionX >= daX && collisionX <= daX + daWidth)
//{
//if (getY(ball) == daY + daHeight)
//{
*/
y_velocity *= -1;
bricks -= 1;
points += 50 / (i + 1) + 30 / (bricks + 1);
removeGWindow(window, brickz[i][j]);
// changes direction, subtracts bricks by 1
// increases points depending on row of brick
// and depending on how many bricks left
// removes away the bricks
// }
// }
}
}
}
// y_velocity *= -1;
}
/*
else if (strcmp(getType(object), "GLabel") == 0)
{
// do nothing
}
*/
}
/*
char s[8];
sprintf(s, "%i", points);
setLabel(label, s);
*/
updateScoreboard(window, label, points);
// updates scoreboard
// linger before moving again
pause(10);
}
/** useless leftover code
string overmessage = "Game Over. Click to Close";
char g[100];
sprintf(g, "%s", overmessage);
setLabel(label, g);
*/
// wait for click before exiting
waitForClick();
// game over
closeGWindow(window);
return 0;
}
int main(int argv, string args[] )
{
int isGod= -1;
if (argv ==2)
{
if (strcmp(args[1] ,"GOD")==0)
{
isGod = 1;; //printf("args %s \n",args[1]);
}
}
// seed pseudorandom number generator
srand48(time(NULL));
// instantiate window
GWindow window = newGWindow(WIDTH, HEIGHT);
// instantiate bricks
initBricks(window);
// instantiate ball, centered in middle of window
GOval ball = initBall(window);
// instantiate paddle, centered at bottom of window
GRect paddle = initPaddle(window);
// instantiate scoreboard, centered in middle of window, just above ball
GLabel label = initScoreboard(window);
// number of bricks initially
int bricks = COLS * ROWS;
// number of lives initially
int lives = LIVES;
// number of points initially
int points = 0;
// Variable declation for whiel
double velocityX = drand48()+5;
double velocityY = drand48()+1;
// keep playing until game over
while (lives > 0 && bricks > 0)
{
// ball beyond paddle
if( (getY(ball) + getWidth(ball)) > getHeight(window) )
{
lives--;
removeGWindow(window, ball);
freeGObject(ball);
if(lives <= 0)
{
break;
}
initBall(window);
}
waitForClick();
// paddle moment
if (isGod == -1)
{
GEvent event = getNextEvent(MOUSE_EVENT);
if(event !=NULL)
{
//printf("before MOUSE_MOVED event\n");
if(getEventType(event) == MOUSE_MOVED)
{
double x = getX(event);
// repositioning paddle from going beyond the window's width
if(x + getWidth(paddle) > getWidth(window))
{
x = getWidth(window) - getWidth(paddle);
}
double y = getHeight(window)-SPACE - getHeight(paddle);
setLocation(paddle, x , y );
}
//printf("After MOUSE_MOVED event\n");
}
}
else if(isGod == 1)//Its GOD mode
{
double ballX = getX(ball);
double ballY = getX(ball);
double x = ballX;
if(x + getWidth(paddle) > getWidth(window))
{
x = getWidth(window) - getWidth(paddle);
}
double y = getHeight(window)-SPACE - getHeight(paddle);
setLocation(paddle, x , y );
}
// Accelerate x cordinates of the ball i.e. left and right
if( getX(ball) + getWidth(ball) > getWidth(window) )
{
velocityX = - velocityX ;
}
else if( getX(ball) <= 0)
{
velocityX = - velocityX;
}
// Acceleration control check for top of the window
if( getY(ball) < 0)
{
velocityY = - velocityY;
}
// Acceleration control if ball collided with paddle or brick
GObject object = detectCollision(window,ball);
if( object != NULL)
{
// Acceleration control if ball collided with paddle
if( object == paddle)
{
velocityY = - velocityY;
//move(ball, velocityX, velocityY);
}
// Ignore collision
if (strcmp(getType(object), "GLabel") == 0)
{
//do nothing
}
// Acceleration, ScoreBoard, brick control if ball collided with brick
if( (strcmp(getType(object), "GRect") == 0) && getY(ball) < HEIGHT / 2)
{
velocityY = - velocityY;
//update points
string colorB = getColorGObject(object);
// return type is "#rrggbb"
if(strcmp(colorB,"RED")==0 )
{
points = points+5;
}
else if(strcmp(colorB,"ORANGE")==0)
{
points = points+4;
}
else if(strcmp(colorB,"YELLOW")==0 )
{
points = points+3;
}
else if(strcmp(colorB,"GREEN")==0)
{
points = points+2;
}
else if(strcmp(colorB,"CYAN")==0)
{
points++;
}
// shrink bat with points increased
if( points % 10 == 0 )
{
double x = getX(paddle);
double y = getY(paddle);
paddleL -= 5;
removeGWindow(window, paddle);
paddle = newGRect(x, y, paddleL, paddleH);
setFilled(paddle, true);
setColor(paddle,"BLACK");
add(window,paddle);
//paddle = initPaddle(window)
}
//update Scoreboard
updateScoreboard(window, label, points);
//brick
removeGWindow(window, object);
bricks--;
if(bricks < 0)
{
break;
}
}
}
// move ball
move(ball, velocityX, velocityY);
pause(10);
}
// wait for click before exiting
waitForClick();
// game over
closeGWindow(window);
return 0;
}
int main(void)
{
// seed pseudorandom number generator
srand48(time(NULL));
// instantiate window
GWindow window = newGWindow(WIDTH, HEIGHT);
// instantiate bricks
initBricks(window);
// instantiate ball, centered in middle of window
GOval ball = initBall(window);
// instantiate paddle, centered at bottom of window
GRect paddle = initPaddle(window);
// instantiate scoreboard, centered in middle of window, just above ball
GLabel label = initScoreboard(window);
// number of bricks initially
int bricks = COLS * ROWS;
// number of lives initially
int lives = LIVES;
// number of points initially
int points = 0;
//initialize ball velocity
double v_x = drand48() * LIMIT;
double v_y = 2.0;
// keep playing until game over
while (lives > 0 && bricks > 0)
{
// check for mouse event
GEvent event = getNextEvent(MOUSE_EVENT);
// if we heard one
if (event != NULL)
{
// if the event was movement, ensure paddle follows cursor and doesn't go beyond window
if (getEventType(event) == MOUSE_MOVED)
{
double x = getX(event) - P_WIDTH / 2;
double y = HEIGHT - (2*P_HEIGHT);
if (x < 0 )
setLocation(paddle, 0, y);
else if (x > WIDTH - P_WIDTH)
setLocation(paddle, WIDTH - P_WIDTH, y);
else
setLocation(paddle, x, y);
}
}
// move ball
move(ball, v_x, v_y);
// bounce off top edge of window
if (getY(ball) < 0)
{
v_y = -v_y;
}
// bounce off left and right edge of window
if (getX(ball) < 0 || getX(ball) > WIDTH - (2*RADIUS) )
{
v_x = -v_x;
}
// bounce off collision object
if (detectCollision(window, ball)!=NULL)
{
GObject collide = detectCollision(window, ball);
//bounce off paddle
if(collide == paddle)
{
v_y = -v_y;
}
//bounce off brick, removing brick from window and updating score
else if (strcmp(getType(collide), "GRect")==0)
{
v_y = -v_y;
removeGWindow(window, collide);
bricks--;
points++;
updateScoreboard(window, label, points);
}
}
// linger before moving again
pause(5);
//pause game and decrease lives if ball goes past bottom of window
if (getY(ball) > HEIGHT)
{
lives--;
waitForClick();
//reinitalializes ball at centre of window when game resumes
if(lives > 0)
{
setLocation(ball, WIDTH/2, HEIGHT/2);
pause(1000);
}
}
}
// wait for click before exiting
waitForClick();
// game over
closeGWindow(window);
return 0;
}
int main(void)
{
// instantiate window
GWindow window = newGWindow(WIDTH, HEIGHT);
// instantiate bricks
initBricks(window);
// instantiate ball, centered in middle of window
GOval ball = initBall(window);
// instantiate paddle, centered at bottom of window
GRect paddle = initPaddle(window);
// instantiate scoreboard, centered in middle of window, just above ball
GLabel label = initScoreboard(window);
// number of bricks initially
int bricks = COLS * ROWS;
// number of lives initially
int lives = LIVES;
// number of points initially
int points = 0;
// wait for click before starting
waitForClick();
velocityX = 1.0;
velocityY = 2.5;
// keep playing until game over
while (lives > 0 && bricks > 0)
{
// Scoreboard
updateScoreboard(window, label, points);
// move ball
move(ball, velocityX, velocityY);
pause(10);
// check for mouse event.
GEvent event = getNextEvent(MOUSE_EVENT);
// Lock the paddle X to the cursor.
if (event != NULL)
{
// if the event was movement
if (getEventType(event) == MOUSE_MOVED)
{
// ensure paddle follows top cursor
double x = getX(event) - getWidth(paddle) / 2;
double y = 500;
setLocation(paddle, x, y);
}
}
GObject object = detectCollision(window, ball);
if (object != NULL)
{
// If the ball hits the paddle.
if (object == paddle)
{
velocityY = -velocityY;
}
// If the ball hits a block. Remove block, add a point, decrement count and bounce.
else if (strcmp(getType(object), "GRect") == 0)
{
removeGWindow(window, object);
velocityY = -velocityY;
points++;
bricks--;
}
}
// If the ball hits the right wall.
if (getX(ball) + getWidth(ball) >= getWidth(window))
{
velocityX = -velocityX;
}
// If the ball hits the left wall.
if (getX(ball) <= 0)
{
velocityX = -velocityX;
}
// If the ball hits the top wall.
if (getY(ball) <= 0)
{
velocityY = -velocityY;
}
// Remove a life. Start over.
if (getY(ball) + getHeight(ball) >= getHeight(window))
{
lives--;
//move ball to start
setLocation(ball, 190, 200);
//move paddle to start
setLocation(paddle, 160, 500);
waitForClick();
}
}
// You Lose Label Message for kicks.
if (bricks > 0)
{
GLabel game_over = newGLabel("YOU LOSE!");
setFont(game_over, "SansSerif-70");
setColor(game_over, "RED");
add(window, game_over);
setLocation(game_over, 15, 300);
}
else
{
GLabel game_over = newGLabel("YOU WIN!");
setFont(game_over, "SansSerif-70");
setColor(game_over, "GREEN");
add(window, game_over);
setLocation(game_over, 15, 300);
}
// wait for click before exiting
waitForClick();
// game over
closeGWindow(window);
return 0;
}
Ball::Ball(QGraphicsItem *parent) : QGraphicsObject(parent)
{
initBall();
}
int main(void)
{
// seed pseudorandom number generator
srand48(time(NULL));
// instantiate window
GWindow window = newGWindow(WIDTH, HEIGHT);
// instantiate bricks
initBricks(window);
// instantiate ball, centered in middle of window
GOval ball = initBall(window);
// instantiate paddle, centered at bottom of window
GRect paddle = initPaddle(window);
// instantiate scoreboard, centered in middle of window, just above ball
GLabel label = initScoreboard(window);
// number of bricks initially
int bricks = COLS * ROWS;
// number of lives initially
int lives = LIVES;
// number of points initially
int points = 0;
// initial velocity
double Xvelocity = drand48();
double Yvelocity = 2.0;
// keep playing until game over
while (lives > 0 && bricks > 0)
{
// move circle along y-axis
move(ball, Xvelocity, Yvelocity);
// bounce off top edge of window
if (getY(ball) <= 0)
{
Yvelocity = -Yvelocity;
}
// ball hits bottom edge, lose life
if (getY(ball) + getHeight(ball) >= getHeight(window))
{
lives = lives - 1;
removeGWindow(window, ball);
waitForClick();
ball = initBall(window);
pause(20);
Yvelocity = -Yvelocity;
}
// bounce off right edge of window
if (getX(ball) + getWidth(ball) >= getWidth(window))
{
Xvelocity = -Xvelocity;
}
// bounce off left edge of window
if (getX(ball) <= 0)
{
Xvelocity = -Xvelocity;
}
// linger before moving again
pause(10);
// check for mouse event
GEvent event = getNextEvent(MOUSE_EVENT);
// if we heard one
if (event != NULL)
{
// if the event was movement
if (getEventType(event) == MOUSE_MOVED)
{
// ensure grect follows top cursor
double x = getX(event) - pWIDTH / 2;
double y = 500;
setLocation(paddle, x, y);
}
}
//check for ball collision
GObject object = detectCollision(window, ball);
//if there was a collision
if (object != NULL)
{
//if it collided with the paddle
if (object == paddle)
{
Yvelocity = -Yvelocity;
}
//removes brick, updates scores
else if (strcmp(getType(object), "GRect") == 0)
{
Yvelocity = -Yvelocity;
removeGWindow(window, object);
points = points + 1;
updateScoreboard(window, label, points);
}
//Do not detect scoreboard
if (strcmp(getType(object), "GLabel") == 0)
{
return 0;
}
}
}
// wait for click before exiting
waitForClick();
// game over
closeGWindow(window);
return 0;
}
int main(void)
{
// seed pseudorandom number generator
srand48(time(NULL));
// instantiate window
GWindow window = newGWindow(WIDTH, HEIGHT);
// instantiate bricks
initBricks(window);
// instantiate ball, centered in middle of window
GOval ball = initBall(window);
// instantiate paddle, centered at bottom of window
GRect paddle = initPaddle(window);
// instantiate scoreboard, centered in middle of window, just above ball
GLabel label = initScoreboard(window);
// number of bricks initially
int bricks = COLS * ROWS;
// number of lives initially
int lives = LIVES;
// number of points initially
int points = 0;
// initial y-axis velocity
double y_velocity = 2.0;
// initial x-axis velocity
double x_velocity = drand48() + LIMIT;
//mouse click to start
waitForClick();
// keep playing until game over
while (lives > 0 && bricks > 0)
{
GEvent event = getNextEvent(MOUSE_EVENT);
if (event != NULL)
{
// paddle movement
if(getEventType(event) == MOUSE_MOVED)
{
double x = getX(event) - P_WIDTH / 2;
double y = 550;
setLocation(paddle, x, y);
// prevent paddle from leaving screen
if (getX(paddle) + getWidth(paddle) >= getWidth(window))
{
x = getWidth(window) - getWidth(paddle);
setLocation(paddle, x, y);
}
else if (getX(paddle) <= 0)
{
x = 0;
setLocation(paddle, x, y);
}
}
}
// bouncing ball
move(ball, x_velocity, y_velocity);
/* not sure my x and y axis are coded correctly, may be backwards*/
//bounce off bottom of window
if (getY(ball) + getWidth(ball) >= getHeight(window))
{
lives--;
setLocation(ball, 190, 350);
// game pause until mouse click
waitForClick();
}
// bounce off top of window
else if (getY(ball) <= 0)
{
y_velocity = - y_velocity;
}
// bounce off right edge of window
else if (getX(ball) + getWidth(ball) >= getWidth(window))
{
x_velocity = -x_velocity;
}
// bounce off left edge of window
else if (getX(ball) <= 1)
{
x_velocity = -x_velocity;
}
// make sure ball doesn't move too fast
pause (20);
//detect collisions between the ball and objects in window
GObject object = detectCollision(window, ball);
if (object != NULL)
{
// bounce off paddle
if (object == paddle)
{
y_velocity = - (drand48() + LIMIT);
}
// bounce off bricks
if ((strcmp(getType(object), "GRect") == 0) && (object != paddle))
{
//x_velocity = -x_velocity;
y_velocity = - y_velocity;
// remove brick when hit
removeGWindow(window, object);
points++;
updateScoreboard(window, label, points);
}
}
}
// wait for click before exiting
waitForClick();
// game over
closeGWindow(window);
return 0;
}