/**
* Test maPimItemRemoveValue syscall.
*/
void AppMoblet::testMaPimItemRemoveValue()
{
printf("\n=========Test maPimItemRemoveValue syscall=======");
MAHandle list = maPimListOpen(MA_PIM_CONTACTS);
printResultCode(list);
MAHandle item = maPimItemCreate(list);
printResultCode(item);
PIMContact* contact = new PIMContact(item);
printf("\nTest syscalls with invalid item handle");
printResultCode(maPimItemRemoveValue(555, 0, 0));
printf("\nTest syscalls with invalid field id");
printResultCode(maPimItemRemoveValue(item, 19191, 0));
printf("\nTest syscall with unsupported field id");
printResultCode(maPimItemRemoveValue(item, MA_PIM_FIELD_CONTACT_CLASS, 0));
printf("\nTest syscall with invalid value index - empty field");
printResultCode(maPimItemRemoveValue(item, MA_PIM_FIELD_CONTACT_ADDR, 0));
waitForClick();
printf("\nTest syscall with invalid value index - field not empty");
contact->addAddress();
printResultCode(maPimItemRemoveValue(item, MA_PIM_FIELD_CONTACT_ADDR, 100));
waitForClick();
printf("\nTest syscall with valid parameters");
printResultCode(maPimItemRemoveValue(item, MA_PIM_FIELD_CONTACT_ADDR, 1));
delete contact;
maPimItemRemove(list, item);
maPimListClose(list);
waitForClick();
}
/**
* Test maPimItemGetValue syscall.
*/
void AppMoblet::testMaPimItemGetValue()
{
printf("\n=========Test maPimItemGetValue syscall=======");
MAHandle list = maPimListOpen(MA_PIM_CONTACTS);
printResultCode(list);
MAHandle item = maPimItemCreate(list);
printResultCode(item);
PIMContact* contact = new PIMContact(item);
MA_PIM_ARGS args;
char buf[1024];
args.buf = buf;
args.bufSize = 1024;
printf("\nTest syscalls with invalid item handle");
args.item = 1234;
printResultCode(maPimItemGetValue(&args, 0));
printf("\nTest syscalls with invalid field id");
args.item = item;
args.field = 696;
printResultCode(maPimItemGetValue(&args, 0));
printf("\nTest syscall with unsupported field id");
args.field = MA_PIM_FIELD_CONTACT_CLASS;
printResultCode(maPimItemGetValue(&args, 0));
printf("\nTest syscall with invalid value index - empty field");
args.field = MA_PIM_FIELD_CONTACT_ADDR;
printResultCode(maPimItemGetValue(&args, 0));
waitForClick();
printf("\nTest syscall with invalid value index - field not empty");
contact->addAddress();
printResultCode(maPimItemGetValue(&args, 15));
waitForClick();
printf("\nTest syscall for a write only field");
args.field = MA_PIM_FIELD_CONTACT_PHOTO_URL;
printResultCode(maPimItemGetValue(&args, 0));
waitForClick();
printf("\nTest syscall with invalid buf size.");
args.field = MA_PIM_FIELD_CONTACT_ADDR;
args.bufSize = 20;
printResultCode(maPimItemGetValue(&args, 0));
printf("\nTest syscall with valid parameters.");
args.bufSize = 1024;
printResultCode(maPimItemGetValue(&args, 0));
delete contact;
maPimItemRemove(list, item);
maPimListClose(list);
waitForClick();
}
/**
* Test maPimItemSetLabel syscall.
*/
void AppMoblet::testMaPimItemSetLabel()
{
printf("\n===========Test maPimItemSetLabel syscall===========");
MAHandle list = maPimListOpen(MA_PIM_CONTACTS);
printResultCode(list);
MAHandle item = maPimItemCreate(list);
printResultCode(item);
MA_PIM_ARGS args;
char buf[1024];
args.buf = buf;
args.bufSize = 1024;
printf("\nTest with invalid item handle");
args.item = 323;
printResultCode(maPimItemSetLabel(&args, 1));
printf("\nTest with invalid field");
args.item = item;
args.field = 12333;
printResultCode(maPimItemSetLabel(&args, 1));
printf("\nTest with unsupported field");
args.field = MA_PIM_FIELD_CONTACT_CLASS;
printResultCode(maPimItemSetLabel(&args, 1));
printf("\nTest with invalid value index and empty field");
args.field = MA_PIM_FIELD_CONTACT_ADDR;
printResultCode(maPimItemSetLabel(&args, 1));
waitForClick();
printf("\nTest with invalid value index and field is not empty");
PIMContact* contact = new PIMContact(item);
contact->addAddress();
printResultCode(maPimItemSetLabel(&args, 5));
waitForClick();
printf("\nTest with a valid field, but value's attribute is not custom");
printResultCode(maPimItemSetLabel(&args, 0));
printf("\nTest with a valid field and value's attribute is custom");
// Write value to buffer.
args.bufSize = writeWCharArraysToBuf(args.buf, sAddressHome,
COUNT_ADDRESS_INDICES);
int index = maPimItemAddValue(&args, MA_PIM_ATTR_ADDR_CUSTOM);
args.bufSize = copyWCharArray(args.buf, L"My label");
printResultCode(maPimItemSetLabel(&args, index));
maPimItemRemove(list, item);
maPimListClose(list);
waitForClick();
}
/**
* Modify the first value of the address field.
* Set a custom label for that value.
*/
void PIMContact::modifyAddressField()
{
printf("==============Modify address field=============\n\n");
mArgs.field = MA_PIM_FIELD_CONTACT_ADDR;
// Print new value on the screen.
for (int i = 0; i < COUNT_ADDRESS_INDICES; i++)
{
MAUtil::String addressValueIndex = getAddressIndexString(i);
const wchar* addressValue = sAddressModified[i];
printf("%s %S", addressValueIndex.c_str(), addressValue);
}
printf("\n");
// Write the address into the buffer.
mArgs.bufSize = writeWCharArraysToBuf(
mArgs.buf,
sAddressModified,
COUNT_ADDRESS_INDICES);
// Set the value for the address field at position 0.
// Use MA_PIM_ATTR_ADDR_CUSTOM so we can set the label later.
checkResultCode(maPimItemSetValue(&mArgs, 0, MA_PIM_ATTR_ADDR_CUSTOM));
// Set custom attribute(label) for the above address.
printf("\n Set label for the this address.");
printf("Label: %S", sAddressLabel);
// Write label value into buffer.
mArgs.bufSize = copyWCharArray(mArgs.buf, sAddressLabel);
// Set label value for address field at position 0.
checkResultCode(maPimItemSetLabel(&mArgs, 0));
waitForClick();
}
int main() {
GWindow gw;
GArc pacman;
int angle, sign;
double limit;
gw = newGWindow(600, 400);
pacman = newGArc(0, (getHeight(gw) - PACMAN_SIZE) / 2,
PACMAN_SIZE, PACMAN_SIZE, 45, 270);
setFilled(pacman, true);
setFillColor(pacman, "YELLOW");
add(gw, pacman);
waitForClick();
angle = 45;
sign = -1;
limit = getWidth(gw) - PACMAN_SIZE;
while (getX(pacman) < limit) {
move(pacman, DELTA_X, 0);
angle += sign * DELTA_THETA;
if (angle == 0 || angle == 45) sign = -sign;
setStartAngle(pacman, angle);
setSweepAngle(pacman, 360 - 2 * angle);
pause(PAUSE_TIME);
}
return 0;
}
/**
* Remove a specified field value.
* @param fieldID One of the MA_PIM_FIELD_CONTACT constants.
* @param index Value's index in the given field.
*/
void PIMContact::removeFieldValue(const int fieldID, const int index)
{
checkResultCode(maPimItemRemoveValue(
mItemHandle,
fieldID,
index));
waitForClick();
}
/**
* Test maPimItemAddValue syscall.
*/
void AppMoblet::testMaPimItemAddValue()
{
printf("\n=========Test maPimItemAddValue syscall=======");
MAHandle list = maPimListOpen(MA_PIM_CONTACTS);
printResultCode(list);
MAHandle item = maPimItemCreate(list);
printResultCode(item);
MA_PIM_ARGS args;
char buf[1024];
args.buf = buf;
args.bufSize = 1024;
printf("\nTest syscall with invalid item handle");
args.item = 1234;
printResultCode(maPimItemAddValue(&args, 0));
printf("\nTest syscall with invalid field id");
args.item = item;
args.field = 696;
printResultCode(maPimItemAddValue(&args, 0));
printf("\nTest syscall with unsupported field id");
args.field = MA_PIM_FIELD_CONTACT_CLASS;
printResultCode(maPimItemAddValue(&args, 0));
printf("\nTest syscall for a read only field");
args.field = MA_PIM_FIELD_CONTACT_REVISION;
printResultCode(maPimItemAddValue(&args, MA_PIM_ATTR_ADDR_WORK));
printf("\nTest syscall with invalid attribute");
args.field = MA_PIM_FIELD_CONTACT_ADDR;
writeWCharArraysToBuf(args.buf, sAddressHome, 8);
printResultCode(maPimItemAddValue(&args, 9099));
printf("\nTest syscall with attribute from another field");
printResultCode(maPimItemAddValue(&args, MA_PIM_ATTR_RELATION_BROTHER));
printf("\nTest syscall with invalid buffer size");
writeWCharArraysToBuf(args.buf, sAddressHome, 8);
args.bufSize = 10;
printResultCode(maPimItemAddValue(&args, MA_PIM_ATTR_ADDR_HOME));
printf("\nTest syscall with valid parameters.");
args.bufSize = writeWCharArraysToBuf(args.buf, sAddressHome, 8);
printResultCode(maPimItemAddValue(&args, MA_PIM_ATTR_ADDR_WORK));
maPimItemRemove(list, item);
maPimListClose(list);
waitForClick();
}
void showRules(int mode, GWindow window)
{
GLabel labelW = newGLabel("Hello World!!");
setFont(labelW, "SansSerif-26");
setLabel(labelW, "Player one starts first with X");
add(window, labelW);
double x = WIDTH/2 - getWidth(labelW)/2;
double y = HEIGHT/2;
setLocation(labelW, x, y);
// Wait for Click
waitForClick();
// Remove Welcome Message
removeGWindow(window, labelW);
}
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 welcome(GWindow window)
{
GRect rectW = newGRect(0, 0, WIDTH, HEIGHT);
setFilled(rectW, true);
setColor(rectW, "#008080");
add(window, rectW);
GLabel labelW = newGLabel("Hello World!!");
setFont(labelW, "SansSerif-32");
setLabel(labelW, "Tic-Tac-Toe");
add(window, labelW);
double x = WIDTH/2 - getWidth(labelW)/2;
double y = HEIGHT/2;
setLocation(labelW, x, y);
// Wait for Click
waitForClick();
// Remove Welcome Message
removeGWindow(window, labelW);
}
void Game::loop()
{
switch (_gameState)
{
case Game::ShowingSplash:
{
showSplashScreen();
break;
}
case Game::ShowingMenu:
{
showMenu();
break;
}
case Game::ShowingOptions:
{
//showOptions();
break;
}
case Game::Playing:
{
sf::Event currentEvent;
while (_mainWindow.pollEvent(currentEvent))
{
_mainWindow.clear(sf::Color(0,0,0));
_gameObjectManager.drawAll(_mainWindow);
_mainWindow.display();
//add a loop here that waits for a click
//then launch the handle click function
waitForClick(currentEvent);
}
break;
}
}
}
/**
* Test maPimItemRemove syscall.
*/
void AppMoblet::testMaPimItemRemove()
{
printf("\n===========Test maPimItemRemove syscall===========");
printf("\nTest with invalid list handle");
printResultCode(maPimItemRemove(5, 1));
printf("\nTest with valid list handle and invalid item handle");
MAHandle list = maPimListOpen(MA_PIM_CONTACTS);
printResultCode(list);
printResultCode(maPimItemRemove(list, 7));
printf("\nTest with valid list handle and valid item handle");
MAHandle newItem = maPimItemCreate(list);
printResultCode(maPimItemRemove(list, newItem));
printf("\nTest with a removed item");
printResultCode(maPimItemRemove(list, newItem));
maPimItemRemove(list, newItem);
maPimListClose(list);
waitForClick();
}
/**
* Test maPimItemClose syscall.
*/
void AppMoblet::testMaPimItemClose()
{
printf("\n===========Test maPimItemClose syscall===========");
printf("\nTest with invalid item handle");
printResultCode(maPimItemClose(500));
printf("\nTest with valid item handle, but list is closed");
MAHandle list = maPimListOpen(MA_PIM_CONTACTS);
printResultCode(list);
MAHandle newItem = maPimItemCreate(list);
maPimListClose(list);
printResultCode(maPimItemClose(newItem));
printf("\nTest with valid item handle and list is opened");
list = maPimListOpen(MA_PIM_CONTACTS);
printResultCode(list);
newItem = maPimItemCreate(list);
printResultCode(newItem);
printResultCode(maPimItemClose(newItem));
maPimListClose(list);
waitForClick();
}
int main(void)
{
/* Welcome Message*/
GWindow window = newGWindow(WIDTH, HEIGHT); // instantiates a window
setWindowTitle(window, "Tic-Tac-Toe");
welcome(window);
/* Mode Selection */
int mode = selectMode(window);
/* Show Rules */
showRules(mode, window);
/* Play Game */
play(mode, window);
/* End Message */
endMessage(window);
waitForClick();
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 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(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;
// 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);
// 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 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);
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;
// 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;
}
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)
{
// 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(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;
}
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 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);
// 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 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;
}