Updated indentation
This commit is contained in:
commit
7a60ab9f17
21
LICENSE
Normal file
21
LICENSE
Normal file
@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2020 Logan Hunt
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
2
README.md
Normal file
2
README.md
Normal file
@ -0,0 +1,2 @@
|
||||
# Asteroids-CPP
|
||||
The game asteroids in c++ using the simplified drawing library provided by my school.
|
29
bullet.cpp
Normal file
29
bullet.cpp
Normal file
@ -0,0 +1,29 @@
|
||||
#include "bullet.h"
|
||||
#include "ship.h"
|
||||
#include <cmath>
|
||||
|
||||
#define M_PI 3.14159265
|
||||
|
||||
// Bullet non-default constructor
|
||||
Bullet :: Bullet( const Point &point ) : FlyingObject() , framesAlive( 0 )
|
||||
{
|
||||
setPoint ( point );
|
||||
}
|
||||
|
||||
// Fire Bullet
|
||||
void Bullet :: fire ( const Velocity &vel , const float angle )
|
||||
{
|
||||
velocity.setDx ( BULLET_SPEED * ( -cos ( M_PI / 180 * angle ) ) );
|
||||
velocity.setDy ( BULLET_SPEED * ( sin ( M_PI / 180 * angle ) ) );
|
||||
}
|
||||
|
||||
// Advance Bullet
|
||||
void Bullet :: advance ()
|
||||
{
|
||||
framesAlive++;
|
||||
if ( framesAlive >= 40 )
|
||||
{
|
||||
kill();
|
||||
}
|
||||
FlyingObject :: advance();
|
||||
}
|
24
bullet.h
Normal file
24
bullet.h
Normal file
@ -0,0 +1,24 @@
|
||||
#ifndef bullet_h
|
||||
#define bullet_h
|
||||
|
||||
#define BULLET_SPEED 10
|
||||
#define BULLET_LIFE 40
|
||||
|
||||
#include "point.h"
|
||||
#include "velocity.h"
|
||||
#include "flyingObject.h"
|
||||
|
||||
class Bullet : public FlyingObject
|
||||
{
|
||||
private:
|
||||
int framesAlive;
|
||||
|
||||
public:
|
||||
Bullet( const Point &point );
|
||||
int getFramesAlive() const { return framesAlive; };
|
||||
void fire( const Velocity &velocity , const float angle );
|
||||
void advance();
|
||||
};
|
||||
|
||||
|
||||
#endif /* bullet_h */
|
45
driver.cpp
Normal file
45
driver.cpp
Normal file
@ -0,0 +1,45 @@
|
||||
/*****************************************************
|
||||
* File: Driver.cpp
|
||||
* Author: Br. Burton
|
||||
*
|
||||
* Description: This file contains the main function
|
||||
* that starts the game and the callback function
|
||||
* that specifies what methods of the game class are
|
||||
* called each time through the game loop.
|
||||
******************************************************/
|
||||
#include "game.h"
|
||||
#include "uiInteract.h"
|
||||
|
||||
/*************************************
|
||||
* All the interesting work happens here, when
|
||||
* I get called back from OpenGL to draw a frame.
|
||||
* When I am finished drawing, then the graphics
|
||||
* engine will wait until the proper amount of
|
||||
* time has passed and put the drawing on the screen.
|
||||
**************************************/
|
||||
void callBack(const Interface *pUI, void *p)
|
||||
{
|
||||
Game *pGame = (Game *)p;
|
||||
|
||||
pGame->advance();
|
||||
pGame->draw(*pUI);
|
||||
pGame->handleInput(*pUI);
|
||||
}
|
||||
|
||||
|
||||
/*********************************
|
||||
* Main is pretty sparse. Just initialize
|
||||
* the game and call the display engine.
|
||||
* That is all!
|
||||
*********************************/
|
||||
int main(int argc, char ** argv)
|
||||
{
|
||||
Point topLeft(-200, 200);
|
||||
Point bottomRight(200, -200);
|
||||
|
||||
Interface ui(argc, argv, "Asteroids", topLeft, bottomRight);
|
||||
Game game(topLeft, bottomRight);
|
||||
ui.run(callBack, &game);
|
||||
|
||||
return 0;
|
||||
}
|
20
flyingObject.cpp
Normal file
20
flyingObject.cpp
Normal file
@ -0,0 +1,20 @@
|
||||
#include "flyingObject.h"
|
||||
#include <iostream>
|
||||
|
||||
// Advance flyingobjects
|
||||
void FlyingObject::advance()
|
||||
{
|
||||
point.addX( getVelocity().getDx() );
|
||||
point.addY( getVelocity().getDy() );
|
||||
|
||||
if ( point.getX() > 200 )
|
||||
point.setX( -200 );
|
||||
else if ( point.getX() < -200 )
|
||||
point.setX( 200 );
|
||||
|
||||
if ( point.getY() > 200 )
|
||||
point.setY( -200 );
|
||||
else if ( point.getY() < -200 )
|
||||
point.setY( 200 );
|
||||
|
||||
}
|
28
flyingObject.h
Normal file
28
flyingObject.h
Normal file
@ -0,0 +1,28 @@
|
||||
#ifndef flyingObject_h
|
||||
#define flyingObject_h
|
||||
|
||||
#include "point.h"
|
||||
#include "velocity.h"
|
||||
#include "uiDraw.h"
|
||||
|
||||
class FlyingObject
|
||||
{
|
||||
protected:
|
||||
Point point;
|
||||
Velocity velocity
|
||||
bool alive;
|
||||
public:
|
||||
FlyingObject() : point( Point() ) , velocity( Velocity() ) , alive( true ) {}
|
||||
Point getPoint() const { return this->point; }
|
||||
void setPoint( const Point &point ) { this->point = point; }
|
||||
Velocity getVelocity() const { return this->velocity; }
|
||||
void setVelocity( const Velocity &velocity) { this->velocity = velocity; }
|
||||
bool isAlive() { return this->alive; }
|
||||
void kill() { alive = false; };
|
||||
virtual void draw() { drawDot( point ); };
|
||||
virtual void advance();
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif /* flyingObject_h */
|
278
game.cpp
Normal file
278
game.cpp
Normal file
@ -0,0 +1,278 @@
|
||||
/*********************************************************************
|
||||
* File: game.cpp
|
||||
* Description: Contains the implementaiton of the game class
|
||||
* methods.
|
||||
*
|
||||
*********************************************************************/
|
||||
|
||||
#include "game.h"
|
||||
#include "uiDraw.h"
|
||||
#include "bullet.h"
|
||||
// These are needed for the getClosestDistance function...
|
||||
#include <limits>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#define CLOSE_ENOUGH 15
|
||||
using namespace std;
|
||||
|
||||
// Game non-default constructor
|
||||
Game :: Game ( const Point &tl , const Point &br ) : topLeft ( tl ) , bottomRight ( br )
|
||||
{
|
||||
rocks = createRocks();
|
||||
ship = new Ship ( Point() );
|
||||
}
|
||||
|
||||
// Create rocks for the game
|
||||
vector<Rock *> Game :: createRocks()
|
||||
{
|
||||
vector<Rock *> initRocks;
|
||||
for ( int i = 0; i < random ( 5 , 8 ); i++ )
|
||||
{
|
||||
Point rockPoint = Point ( random( -190 , 190 ) , random ( -190 , 190 ) );
|
||||
Velocity velocity;
|
||||
velocity.setDx ( random ( -3.0 , 3.0 ) );
|
||||
velocity.setDy ( random ( -2.0 , 2.0 ) );
|
||||
// Make sure spawn is safe on start by calculating if
|
||||
// The rock is on a trajectory to the ship
|
||||
float m = velocity.getDy() / velocity.getDx();
|
||||
|
||||
if ( fabs ( rockPoint.getY() - m * rockPoint.getX() ) >= 50 )
|
||||
{
|
||||
switch ( random( 1 , 5 ) ) {
|
||||
case 1:
|
||||
case 2:
|
||||
case 3:
|
||||
initRocks.push_back ( new BigRock ( rockPoint , velocity ) );
|
||||
break;
|
||||
case 4:
|
||||
initRocks.push_back ( new MediumRock ( rockPoint , velocity ) );
|
||||
break;
|
||||
case 5:
|
||||
initRocks.push_back ( new SmallRock ( rockPoint , velocity ) );
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return initRocks;
|
||||
}
|
||||
|
||||
// Get closest distance between two flying objects
|
||||
float Game :: getClosestDistance(const FlyingObject &obj1, const FlyingObject &obj2) const
|
||||
{
|
||||
// find the maximum distance traveled
|
||||
float dMax = max(abs(obj1.getVelocity().getDx()), abs(obj1.getVelocity().getDy()));
|
||||
dMax = max(dMax, abs(obj2.getVelocity().getDx()));
|
||||
dMax = max(dMax, abs(obj2.getVelocity().getDy()));
|
||||
dMax = max(dMax, 0.1f); // when dx and dy are 0.0. Go through the loop once.
|
||||
|
||||
float distMin = std::numeric_limits<float>::max();
|
||||
for (float i = 0.0; i <= dMax; i++)
|
||||
{
|
||||
Point point1(obj1.getPoint().getX() + (obj1.getVelocity().getDx() * i / dMax),
|
||||
obj1.getPoint().getY() + (obj1.getVelocity().getDy() * i / dMax));
|
||||
Point point2(obj2.getPoint().getX() + (obj2.getVelocity().getDx() * i / dMax),
|
||||
obj2.getPoint().getY() + (obj2.getVelocity().getDy() * i / dMax));
|
||||
|
||||
float xDiff = point1.getX() - point2.getX();
|
||||
float yDiff = point1.getY() - point2.getY();
|
||||
|
||||
float distSquared = (xDiff * xDiff) +(yDiff * yDiff);
|
||||
|
||||
distMin = min(distMin, distSquared);
|
||||
}
|
||||
|
||||
return sqrt(distMin);
|
||||
}
|
||||
|
||||
// Advance everything in the game
|
||||
void Game :: advance()
|
||||
{
|
||||
cleanUpZombies();
|
||||
advanceShip();
|
||||
advanceBullets();
|
||||
advanceAsteroids();
|
||||
|
||||
handleCollisions();
|
||||
}
|
||||
|
||||
// Advance all asteroids in game
|
||||
void Game :: advanceAsteroids()
|
||||
{
|
||||
for ( int i = 0; i < rocks.size(); i++ )
|
||||
{
|
||||
rocks[i]->advance();
|
||||
}
|
||||
}
|
||||
|
||||
// Advance all the bullets
|
||||
void Game :: advanceBullets()
|
||||
{
|
||||
for ( int i = 0; i < bullets.size(); i++ )
|
||||
{
|
||||
bullets[i]->advance();
|
||||
}
|
||||
}
|
||||
|
||||
// Advance the ship
|
||||
void Game :: advanceShip()
|
||||
{
|
||||
if ( ship->isAlive() && ship->getFuel() >= 0 )
|
||||
{
|
||||
ship->advance();
|
||||
}
|
||||
}
|
||||
|
||||
// Clean up memory
|
||||
void Game :: cleanUpZombies()
|
||||
{
|
||||
for ( int i = 0; i < bullets.size(); i++ )
|
||||
{
|
||||
if ( !bullets[i]->isAlive() )
|
||||
{
|
||||
delete bullets[i];
|
||||
bullets[i] = NULL;
|
||||
bullets.erase( bullets.begin() + i );
|
||||
}
|
||||
}
|
||||
for ( int i = 0; i < rocks.size(); i++ )
|
||||
{
|
||||
if ( !rocks[i]->isAlive() )
|
||||
{
|
||||
delete rocks[i];
|
||||
rocks[i] = NULL;
|
||||
rocks.erase( rocks.begin() + i );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Handle all collisions
|
||||
void Game :: handleCollisions()
|
||||
{
|
||||
// Handle bullet collisions
|
||||
for ( int i = 0; i < rocks.size(); i++ )
|
||||
{
|
||||
Rock * rock = rocks[i];
|
||||
if ( rock->isAlive() )
|
||||
{
|
||||
for ( int j = 0; j < bullets.size(); j++ )
|
||||
{
|
||||
Bullet * bullet = bullets[j];
|
||||
if ( bullet->isAlive() )
|
||||
{
|
||||
float allowedRange = rock->getSize() + CLOSE_ENOUGH;
|
||||
if ( fabs( getClosestDistance( *bullet , *rock ) ) < allowedRange
|
||||
|| bullet->getPoint().inRange( rock->getPoint() , allowedRange ) )
|
||||
{
|
||||
vector<Rock *> newRocks = rock->destroy();
|
||||
for ( int i = 0; i < newRocks.size(); i++ )
|
||||
{
|
||||
rocks.push_back ( newRocks[i] );
|
||||
}
|
||||
rock->kill();
|
||||
bullet->kill();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Handle ship collisions
|
||||
for ( int i = 0; i < rocks.size(); i++ )
|
||||
{
|
||||
Rock * rock = rocks[i];
|
||||
if ( rock->isAlive() && ship->isAlive() )
|
||||
{
|
||||
float allowedRange = rock->getSize() + CLOSE_ENOUGH;
|
||||
if ( fabs( getClosestDistance( *ship , *rock ) ) < allowedRange
|
||||
|| ship->getPoint().inRange( rock->getPoint() , allowedRange ) )
|
||||
{
|
||||
vector<Rock *> newRocks = rock->destroy();
|
||||
for ( int i = 0; i < newRocks.size(); i++ )
|
||||
{
|
||||
rocks.push_back ( newRocks[i] );
|
||||
}
|
||||
rock->kill();
|
||||
ship->kill();
|
||||
}
|
||||
}
|
||||
}
|
||||
cleanUpZombies();
|
||||
}
|
||||
|
||||
// Draw everything
|
||||
void Game :: draw ( const Interface &ui )
|
||||
{
|
||||
drawRocks();
|
||||
drawShip();
|
||||
drawBullets();
|
||||
drawNumber ( Point ( -170 , 170 ) , (int) ship->getFuel() );
|
||||
drawText ( Point ( -170 , 180 ) , "FUEL:" );
|
||||
}
|
||||
|
||||
// Draw rocks
|
||||
void Game :: drawRocks()
|
||||
{
|
||||
for ( int i = 0; i < rocks.size(); i++ )
|
||||
{
|
||||
rocks[i]->draw();
|
||||
}
|
||||
}
|
||||
|
||||
// Draw ship
|
||||
void Game :: drawShip()
|
||||
{
|
||||
if ( ship->isAlive() )
|
||||
{
|
||||
ship->draw();
|
||||
}
|
||||
}
|
||||
|
||||
// Draw bullets
|
||||
void Game :: drawBullets()
|
||||
{
|
||||
for ( int i = 0; i < bullets.size(); i++ )
|
||||
{
|
||||
bullets[i]->draw();
|
||||
}
|
||||
}
|
||||
|
||||
// Handle in-game input
|
||||
void Game::handleInput(const Interface & ui)
|
||||
{
|
||||
if ( ship->isAlive() )
|
||||
{
|
||||
if ( ui.isUp() )
|
||||
{
|
||||
ship->setThrusting ( true );
|
||||
ship->thrust( true );
|
||||
}
|
||||
if ( ui.isDown() )
|
||||
{
|
||||
ship->setThrusting ( true );
|
||||
ship->thrust( false );
|
||||
}
|
||||
if ( ui.isLeft() )
|
||||
{
|
||||
ship->setThrusting ( true );
|
||||
ship->rotate( true );
|
||||
}
|
||||
if ( ui.isRight() )
|
||||
{
|
||||
ship->setThrusting ( true );
|
||||
ship->rotate( false );
|
||||
}
|
||||
if ( ui.isSpace() )
|
||||
{
|
||||
Bullet * newBullet = new Bullet( ship->getPoint() );
|
||||
newBullet->fire( ship->getVelocity(), ship->getAngle() );
|
||||
bullets.push_back( newBullet );
|
||||
}
|
||||
if ( !ui.isRight() && !ui.isUp() && !ui.isDown() && !ui.isLeft() )
|
||||
{
|
||||
ship->setThrusting ( false );
|
||||
}
|
||||
}
|
||||
|
||||
}
|
53
game.h
Normal file
53
game.h
Normal file
@ -0,0 +1,53 @@
|
||||
/*********************************************************************
|
||||
* File: game.h
|
||||
* Description: Defines the game class for Asteroids
|
||||
*
|
||||
*********************************************************************/
|
||||
|
||||
#ifndef GAME_H
|
||||
#define GAME_H
|
||||
|
||||
#include <vector>
|
||||
#include "bullet.h"
|
||||
#include "ship.h"
|
||||
#include "rocks.h"
|
||||
#include "uiDraw.h"
|
||||
#include "uiInteract.h"
|
||||
|
||||
#define CLOSE_ENOUGH 15
|
||||
|
||||
using namespace std;
|
||||
|
||||
class Game
|
||||
{
|
||||
private:
|
||||
Point topLeft;
|
||||
Point bottomRight;
|
||||
vector<Rock *> rocks;
|
||||
vector<Bullet *> bullets;
|
||||
Ship* ship;
|
||||
|
||||
float getClosestDistance( const FlyingObject &obj1 , const FlyingObject &obj2 ) const;
|
||||
|
||||
vector<Rock *> createRocks();
|
||||
|
||||
void advanceBullets();
|
||||
void advanceAsteroids();
|
||||
void advanceShip();
|
||||
|
||||
void cleanUpZombies();
|
||||
|
||||
void handleCollisions();
|
||||
|
||||
void drawBullets();
|
||||
void drawRocks();
|
||||
void drawShip();
|
||||
public:
|
||||
Game ( const Point &tl , const Point &br );
|
||||
void handleInput ( const Interface &ui );
|
||||
void draw ( const Interface &ui );
|
||||
void advance();
|
||||
};
|
||||
|
||||
|
||||
#endif /* GAME_H */
|
71
makefile
Normal file
71
makefile
Normal file
@ -0,0 +1,71 @@
|
||||
# Author:
|
||||
# Logan Hunt
|
||||
# Summary:
|
||||
# Play the game asteroids
|
||||
# Above and Beyond
|
||||
# Changed colors
|
||||
# Added fuel
|
||||
# rotation: -1 units/frame
|
||||
# movement: -3 units/frame
|
||||
# Made sure that initially, trajectories of rocks will
|
||||
# not hit ship
|
||||
# There's a chance of medium asteroids spawning at the start
|
||||
# The initial amount of large rocks is random
|
||||
###############################################################
|
||||
|
||||
|
||||
LFLAGS = -lglut -lGLU -lGL
|
||||
|
||||
###############################################################
|
||||
# Build the main game
|
||||
###############################################################
|
||||
a.out: driver.o game.o uiInteract.o uiDraw.o point.o velocity.o flyingObject.o ship.o bullet.o rocks.o
|
||||
g++ driver.o game.o uiInteract.o uiDraw.o point.o velocity.o flyingObject.o ship.o bullet.o rocks.o $(LFLAGS)
|
||||
|
||||
###############################################################
|
||||
# Individual files
|
||||
# uiDraw.o Draw polygons on the screen and do all OpenGL graphics
|
||||
# uiInteract.o Handles input events
|
||||
# point.o The position on the screen
|
||||
# game.o Handles the game interaction
|
||||
# velocity.o Velocity (speed and direction)
|
||||
# flyingObject.o Base class for all flying objects
|
||||
# ship.o The player's ship
|
||||
# bullet.o The bullets fired from the ship
|
||||
# rocks.o Contains all of the Rock classes
|
||||
###############################################################
|
||||
uiDraw.o: uiDraw.cpp uiDraw.h
|
||||
g++ -c uiDraw.cpp
|
||||
|
||||
uiInteract.o: uiInteract.cpp uiInteract.h
|
||||
g++ -c uiInteract.cpp
|
||||
|
||||
point.o: point.cpp point.h
|
||||
g++ -c point.cpp
|
||||
|
||||
driver.o: driver.cpp game.h
|
||||
g++ -c driver.cpp
|
||||
|
||||
game.o: game.cpp game.h uiDraw.h uiInteract.h point.h velocity.h flyingObject.h bullet.h rocks.h ship.h
|
||||
g++ -c game.cpp
|
||||
|
||||
velocity.o: velocity.cpp velocity.h point.h
|
||||
g++ -c velocity.cpp
|
||||
|
||||
flyingObject.o: flyingObject.cpp flyingObject.h point.h velocity.h uiDraw.h
|
||||
g++ -c flyingObject.cpp
|
||||
|
||||
ship.o: ship.cpp ship.h flyingObject.h point.h velocity.h uiDraw.h
|
||||
g++ -c ship.cpp
|
||||
|
||||
bullet.o: bullet.cpp bullet.h flyingObject.h point.h velocity.h uiDraw.h
|
||||
g++ -c bullet.cpp
|
||||
|
||||
rocks.o: rocks.cpp rocks.h flyingObject.h point.h velocity.h uiDraw.h
|
||||
g++ -c rocks.cpp
|
||||
|
||||
###############################################################
|
||||
# General rules
|
||||
###############################################################
|
||||
clean:
|
||||
rm a.out *.o
|
77
point.cpp
Normal file
77
point.cpp
Normal file
@ -0,0 +1,77 @@
|
||||
/***********************************************************************
|
||||
* Source File:
|
||||
* Point : The representation of a position on the screen
|
||||
* Author:
|
||||
* Br. Helfrich
|
||||
* Summary:
|
||||
* Everything we need to know about a location on the screen, including
|
||||
* the location and the bounds.
|
||||
************************************************************************/
|
||||
|
||||
#include "point.h"
|
||||
#include <cassert>
|
||||
#include "uiDraw.h"
|
||||
using namespace std;
|
||||
/******************************************
|
||||
* POINT : CONSTRUCTOR WITH X,Y
|
||||
* Initialize the point to the passed position
|
||||
*****************************************/
|
||||
Point::Point(float x, float y) : x(0.0), y(0.0)
|
||||
{
|
||||
setX(x);
|
||||
setY(y);
|
||||
}
|
||||
|
||||
/*******************************************
|
||||
* POINT : SET X
|
||||
* Set the x position if the value is within range
|
||||
*******************************************/
|
||||
void Point::setX(float x)
|
||||
{
|
||||
this->x = x;
|
||||
}
|
||||
|
||||
/*******************************************
|
||||
* POINT : SET Y
|
||||
* Set the y position if the value is within range
|
||||
*******************************************/
|
||||
void Point::setY(float y)
|
||||
{
|
||||
this->y = y;
|
||||
}
|
||||
|
||||
/******************************************
|
||||
* POINT insertion
|
||||
* Display coordinates on the screen
|
||||
*****************************************/
|
||||
std::ostream & operator << (std::ostream & out, const Point & pt)
|
||||
{
|
||||
out << "(" << pt.getX() << ", " << pt.getY() << ")";
|
||||
return out;
|
||||
}
|
||||
|
||||
/*******************************************
|
||||
* POINT extraction
|
||||
* Prompt for coordinates
|
||||
******************************************/
|
||||
std::istream & operator >> (std::istream & in, Point & pt)
|
||||
{
|
||||
float x;
|
||||
float y;
|
||||
in >> x >> y;
|
||||
|
||||
pt.setX(x);
|
||||
pt.setY(y);
|
||||
|
||||
return in;
|
||||
}
|
||||
|
||||
bool Point::inRange( const Point &p, const float range )
|
||||
{
|
||||
if ( ( fabs( getX() - p.getX() ) < range) &&
|
||||
( fabs( getY() - p.getY() ) < range ) )
|
||||
{
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
49
point.h
Normal file
49
point.h
Normal file
@ -0,0 +1,49 @@
|
||||
/***********************************************************************
|
||||
* Header File:
|
||||
* Point : The representation of a position on the screen
|
||||
* Author:
|
||||
* Br. Helfrich
|
||||
* Summary:
|
||||
* Everything we need to know about a location on the screen, including
|
||||
* the location and the bounds.
|
||||
************************************************************************/
|
||||
|
||||
|
||||
#ifndef POINT_H
|
||||
#define POINT_H
|
||||
|
||||
#include <iostream>
|
||||
|
||||
/*********************************************
|
||||
* POINT
|
||||
* A single position.
|
||||
*********************************************/
|
||||
class Point
|
||||
{
|
||||
public:
|
||||
// constructors
|
||||
Point() : x(0.0), y(0.0) {}
|
||||
Point(bool check) : x(0.0), y(0.0) {}
|
||||
Point(float x, float y);
|
||||
|
||||
// getters
|
||||
float getX() const { return x; }
|
||||
float getY() const { return y; }
|
||||
|
||||
// setters
|
||||
void setX(float x);
|
||||
void setY(float y);
|
||||
void addX(float dx) { setX(getX() + dx); }
|
||||
void addY(float dy) { setY(getY() + dy); }
|
||||
|
||||
bool inRange ( const Point &p , const float range );
|
||||
private:
|
||||
float x; // horizontal position
|
||||
float y; // vertical position
|
||||
};
|
||||
|
||||
// stream I/O useful for debugging
|
||||
std::ostream & operator << (std::ostream & out, const Point & pt);
|
||||
std::istream & operator >> (std::istream & in, Point & pt);
|
||||
|
||||
#endif // POINT_H
|
63
rocks.cpp
Normal file
63
rocks.cpp
Normal file
@ -0,0 +1,63 @@
|
||||
#include "rocks.h"
|
||||
#include "uiDraw.h"
|
||||
#include <cmath>
|
||||
#define M_PI 3.14159265
|
||||
|
||||
// Destroy Big Rock and return vector of new *rocks
|
||||
vector<Rock *> BigRock :: destroy()
|
||||
{
|
||||
vector<Rock *> rocks;
|
||||
Velocity rockVel = this->velocity;
|
||||
Point rockPoint = this->point;
|
||||
|
||||
rockVel.addDy ( 1 );
|
||||
rocks.push_back ( new MediumRock ( rockPoint , rockVel ) );
|
||||
|
||||
rockVel.addDy ( -2 ); // Original rockvel dy - 1
|
||||
rocks.push_back ( new MediumRock ( rockPoint , rockVel ) );
|
||||
|
||||
rockVel.addDy ( 1 ); // Original rockvel dy
|
||||
rockVel.addDx ( (float) random ( 1.0 , 3.0 ) );
|
||||
rocks.push_back ( new SmallRock ( rockPoint , rockVel ) );
|
||||
|
||||
return rocks;
|
||||
}
|
||||
|
||||
// Draw big rock
|
||||
void BigRock :: draw()
|
||||
{
|
||||
drawLargeAsteroid ( this->point , this->angle );
|
||||
}
|
||||
|
||||
// Destroy Medium Rock and return vector of new *rocks
|
||||
vector<Rock *> MediumRock :: destroy()
|
||||
{
|
||||
vector<Rock *> rocks;
|
||||
Velocity rockVel = this->velocity;
|
||||
Point rockPoint = this->point;
|
||||
|
||||
rockVel.addDx ( 3 );
|
||||
rocks.push_back ( new SmallRock ( rockPoint , rockVel ) );
|
||||
rockVel.addDx ( -6 );
|
||||
rocks.push_back ( new SmallRock ( rockPoint , rockVel ) );
|
||||
|
||||
return rocks;
|
||||
}
|
||||
|
||||
// Draw Medium Rock
|
||||
void MediumRock :: draw()
|
||||
{
|
||||
drawMediumAsteroid ( this->point , this->angle );
|
||||
}
|
||||
|
||||
// Destroy Small Rock and return an empty *rock vector
|
||||
vector<Rock *> SmallRock :: destroy()
|
||||
{
|
||||
return vector<Rock *>();
|
||||
}
|
||||
|
||||
// Draw small rock
|
||||
void SmallRock :: draw()
|
||||
{
|
||||
drawSmallAsteroid ( this->point , this->angle );
|
||||
}
|
84
rocks.h
Normal file
84
rocks.h
Normal file
@ -0,0 +1,84 @@
|
||||
#ifndef rocks_h
|
||||
#define rocks_h
|
||||
|
||||
#define BIG_ROCK_SIZE 16
|
||||
#define MEDIUM_ROCK_SIZE 8
|
||||
#define SMALL_ROCK_SIZE 4
|
||||
|
||||
#define BIG_ROCK_SPIN 2
|
||||
#define MEDIUM_ROCK_SPIN 5
|
||||
#define SMALL_ROCK_SPIN 10
|
||||
|
||||
#include "flyingObject.h"
|
||||
#include <vector>
|
||||
|
||||
using namespace std;
|
||||
|
||||
class Rock : public FlyingObject
|
||||
{
|
||||
protected:
|
||||
int rotationDegPerFrame;
|
||||
int size;
|
||||
float angle;
|
||||
public:
|
||||
Rock() : FlyingObject() , rotationDegPerFrame ( 0 ) , size ( 1 ) , angle ( 0 ) {}
|
||||
Rock ( int degPerFrame , int size , float angle ) : rotationDegPerFrame ( degPerFrame ) , size ( size ) , angle ( angle ) {}
|
||||
|
||||
int getRotationDegPerFrame() { return rotationDegPerFrame; }
|
||||
int getSize () { return size; }
|
||||
float getAngle() { return angle; }
|
||||
|
||||
void setAngle ( const float angle ) { this->angle = angle; }
|
||||
void setRotationDegPerFrame ( const int degPerFrame ) { this->rotationDegPerFrame = degPerFrame; }
|
||||
void setSize ( const int size ) { this->size = size; }
|
||||
void advance() { this->angle += rotationDegPerFrame; FlyingObject::advance(); }
|
||||
virtual void draw() {};
|
||||
virtual vector<Rock *> destroy() = 0;
|
||||
};
|
||||
|
||||
class BigRock : public Rock
|
||||
{
|
||||
public:
|
||||
BigRock ( const Point &point , const Velocity &velocity )
|
||||
{
|
||||
setPoint ( point );
|
||||
setAngle ( 0 );
|
||||
setSize ( BIG_ROCK_SIZE );
|
||||
setRotationDegPerFrame ( BIG_ROCK_SPIN );
|
||||
setAngle ( random ( 0 , 360 ) );
|
||||
setVelocity ( velocity );
|
||||
}
|
||||
|
||||
vector<Rock *> destroy();
|
||||
void draw();
|
||||
};
|
||||
|
||||
class MediumRock : public Rock
|
||||
{
|
||||
public:
|
||||
MediumRock ( const Point &point , const Velocity &vel ) {
|
||||
this->point = point;
|
||||
this->velocity = vel;
|
||||
setAngle ( 0 );
|
||||
setRotationDegPerFrame ( MEDIUM_ROCK_SPIN );
|
||||
setSize ( MEDIUM_ROCK_SIZE );
|
||||
}
|
||||
vector<Rock *> destroy();
|
||||
void draw();
|
||||
};
|
||||
|
||||
class SmallRock : public Rock
|
||||
{
|
||||
public:
|
||||
SmallRock( const Point &point , const Velocity &vel ) {
|
||||
this->point = point;
|
||||
this->velocity = vel;
|
||||
setAngle ( 0 );
|
||||
setRotationDegPerFrame ( SMALL_ROCK_SPIN );
|
||||
setSize ( SMALL_ROCK_SIZE );
|
||||
}
|
||||
vector<Rock *> destroy();
|
||||
void draw();
|
||||
};
|
||||
|
||||
#endif /* rocks_h */
|
36
ship.cpp
Normal file
36
ship.cpp
Normal file
@ -0,0 +1,36 @@
|
||||
#include "ship.h"
|
||||
#include "bullet.h"
|
||||
|
||||
#include <cmath>
|
||||
|
||||
#define M_PI 3.14159265
|
||||
// Put your ship methods here
|
||||
|
||||
// Apply thrust to ship
|
||||
void Ship :: thrust ( const bool isUp )
|
||||
{
|
||||
float thrust = THRUST_AMOUNT * ( isUp ? 1 : -1 );
|
||||
fuel -= 3;
|
||||
if ( fuel >= 0 )
|
||||
{
|
||||
velocity.addDx ( thrust * ( -cos ( M_PI / 180 * angle ) ) );
|
||||
velocity.addDy ( thrust * ( sin ( M_PI / 180 * angle ) ) );
|
||||
}
|
||||
else
|
||||
{
|
||||
fuel = 0; // In the case of negative fuel
|
||||
}
|
||||
}
|
||||
|
||||
// Rotate ship
|
||||
void Ship :: rotate ( const bool isRight )
|
||||
{
|
||||
angle += ROTATE_AMOUNT * ( isRight ? -1 : 1 );
|
||||
fuel -= 1;
|
||||
}
|
||||
|
||||
// Draw ship
|
||||
void Ship :: draw ( ) const
|
||||
{
|
||||
drawShip ( getPoint() , -(angle - 90) , isThrusting );
|
||||
}
|
32
ship.h
Normal file
32
ship.h
Normal file
@ -0,0 +1,32 @@
|
||||
#ifndef ship_h
|
||||
#define ship_h
|
||||
|
||||
#define SHIP_SIZE 10
|
||||
#define ROTATE_AMOUNT 6
|
||||
#define THRUST_AMOUNT 0.5
|
||||
|
||||
#include "flyingObject.h"
|
||||
#include "uiDraw.h"
|
||||
#include "uiInteract.h"
|
||||
|
||||
using namespace std;
|
||||
|
||||
class Ship : public FlyingObject
|
||||
{
|
||||
private:
|
||||
float angle;
|
||||
bool isThrusting;
|
||||
int fuel;
|
||||
public:
|
||||
Ship( const Point &point ) : FlyingObject() , fuel ( 1000 ) , angle ( 90.0 ) , isThrusting( false ) { setPoint ( point ); }
|
||||
float getAngle() const { return this->angle; }
|
||||
float getFuel() { return this->fuel; }
|
||||
void setFuel ( const int fuel ) { this->fuel - fuel; }
|
||||
void thrust( const bool isUp );
|
||||
void rotate( const bool isRight );
|
||||
bool getIsThrusting() { return isThrusting; }
|
||||
void setThrusting( const bool isThrusting ) { this->isThrusting = isThrusting; }
|
||||
void draw() const;
|
||||
};
|
||||
|
||||
#endif /* ship_h */
|
714
uiDraw.cpp
Normal file
714
uiDraw.cpp
Normal file
@ -0,0 +1,714 @@
|
||||
/***********************************************************************
|
||||
* Source File:
|
||||
* User Interface Draw : put pixels on the screen
|
||||
* Author:
|
||||
* Br. Helfrich
|
||||
* Summary:
|
||||
* This is the code necessary to draw on the screen. We have a collection
|
||||
* of procedural functions here because each draw function does not
|
||||
* retain state. In other words, they are verbs (functions), not nouns
|
||||
* (variables) or a mixture (objects)
|
||||
************************************************************************/
|
||||
|
||||
#include <string> // need you ask?
|
||||
#include <sstream> // convert an integer into text
|
||||
#include <cassert> // I feel the need... the need for asserts
|
||||
#include <time.h> // for clock
|
||||
|
||||
|
||||
#ifdef __APPLE__
|
||||
#include <openGL/gl.h> // Main OpenGL library
|
||||
#include <GLUT/glut.h> // Second OpenGL library
|
||||
#endif // __APPLE__
|
||||
|
||||
#ifdef __linux__
|
||||
#include <GL/gl.h> // Main OpenGL library
|
||||
#include <GL/glut.h> // Second OpenGL library
|
||||
#endif // __linux__
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <GL/glut.h> // OpenGL library we copied
|
||||
#define _USE_MATH_DEFINES
|
||||
#include <math.h>
|
||||
#endif // _WIN32
|
||||
|
||||
#include "point.h"
|
||||
#include "uiDraw.h"
|
||||
|
||||
using namespace std;
|
||||
|
||||
#define deg2rad(value) ((M_PI / 180) * (value))
|
||||
|
||||
/*********************************************
|
||||
* NUMBER OUTLINES
|
||||
* We are drawing the text for score and things
|
||||
* like that by hand to make it look "old school."
|
||||
* These are how we render each individual charactger.
|
||||
* Note how -1 indicates "done". These are paired
|
||||
* coordinates where the even are the x and the odd
|
||||
* are the y and every 2 pairs represents a point
|
||||
********************************************/
|
||||
const char NUMBER_OUTLINES[10][20] =
|
||||
{
|
||||
{0, 0, 7, 0, 7, 0, 7,10, 7,10, 0,10, 0,10, 0, 0, -1,-1, -1,-1},//0
|
||||
{7, 0, 7,10, -1,-1, -1,-1, -1,-1, -1,-1, -1,-1, -1,-1, -1,-1, -1,-1},//1
|
||||
{0, 0, 7, 0, 7, 0, 7, 5, 7, 5, 0, 5, 0, 5, 0,10, 0,10, 7,10},//2
|
||||
{0, 0, 7, 0, 7, 0, 7,10, 7,10, 0,10, 4, 5, 7, 5, -1,-1, -1,-1},//3
|
||||
{0, 0, 0, 5, 0, 5, 7, 5, 7, 0, 7,10, -1,-1, -1,-1, -1,-1, -1,-1},//4
|
||||
{7, 0, 0, 0, 0, 0, 0, 5, 0, 5, 7, 5, 7, 5, 7,10, 7,10, 0,10},//5
|
||||
{7, 0, 0, 0, 0, 0, 0,10, 0,10, 7,10, 7,10, 7, 5, 7, 5, 0, 5},//6
|
||||
{0, 0, 7, 0, 7, 0, 7,10, -1,-1, -1,-1, -1,-1, -1,-1, -1,-1, -1,-1},//7
|
||||
{0, 0, 7, 0, 0, 5, 7, 5, 0,10, 7,10, 0, 0, 0,10, 7, 0, 7,10},//8
|
||||
{0, 0, 7, 0, 7, 0, 7,10, 0, 0, 0, 5, 0, 5, 7, 5, -1,-1, -1,-1} //9
|
||||
};
|
||||
|
||||
/************************************************************************
|
||||
* DRAW DIGIT
|
||||
* Draw a single digit in the old school line drawing style. The
|
||||
* size of the glyph is 8x11 or x+(0..7), y+(0..10)
|
||||
* INPUT topLeft The top left corner of the character
|
||||
* digit The digit we are rendering: '0' .. '9'
|
||||
*************************************************************************/
|
||||
void drawDigit(const Point & topLeft, char digit)
|
||||
{
|
||||
// we better be only drawing digits
|
||||
assert(isdigit(digit));
|
||||
if (!isdigit(digit))
|
||||
return;
|
||||
|
||||
// compute the row as specified by the digit
|
||||
int r = digit - '0';
|
||||
assert(r >= 0 && r <= 9);
|
||||
|
||||
// go through each segment.
|
||||
for (int c = 0; c < 20 && NUMBER_OUTLINES[r][c] != -1; c += 4)
|
||||
{
|
||||
assert(NUMBER_OUTLINES[r][c ] != -1 &&
|
||||
NUMBER_OUTLINES[r][c + 1] != -1 &&
|
||||
NUMBER_OUTLINES[r][c + 2] != -1 &&
|
||||
NUMBER_OUTLINES[r][c + 3] != -1);
|
||||
|
||||
//Draw a line based off of the num structure for each number
|
||||
Point start;
|
||||
start.setX(topLeft.getX() + NUMBER_OUTLINES[r][c]);
|
||||
start.setY(topLeft.getY() - NUMBER_OUTLINES[r][c + 1]);
|
||||
Point end;
|
||||
end.setX(topLeft.getX() + NUMBER_OUTLINES[r][c + 2]);
|
||||
end.setY(topLeft.getY() - NUMBER_OUTLINES[r][c + 3]);
|
||||
|
||||
drawLine(start, end);
|
||||
}
|
||||
}
|
||||
|
||||
/*************************************************************************
|
||||
* DRAW NUMBER
|
||||
* Display an integer on the screen using the 7-segment method
|
||||
* INPUT topLeft The top left corner of the character
|
||||
* digit The digit we are rendering: '0' .. '9'
|
||||
*************************************************************************/
|
||||
void drawNumber(const Point & topLeft, int number)
|
||||
{
|
||||
// our cursor, if you will. It will advance as we output digits
|
||||
Point point = topLeft;
|
||||
|
||||
// is this negative
|
||||
bool isNegative = (number < 0);
|
||||
number *= (isNegative ? -1 : 1);
|
||||
|
||||
// render the number as text
|
||||
ostringstream sout;
|
||||
sout << number;
|
||||
string text = sout.str();
|
||||
|
||||
// handle the negative
|
||||
if (isNegative)
|
||||
{
|
||||
glBegin(GL_LINES);
|
||||
glVertex2f(point.getX() + 1, point.getY() - 5);
|
||||
glVertex2f(point.getX() + 5, point.getY() - 5);
|
||||
glEnd();
|
||||
point.addX(11);
|
||||
}
|
||||
|
||||
// walk through the text one digit at a time
|
||||
for (const char *p = text.c_str(); *p; p++)
|
||||
{
|
||||
assert(isdigit(*p));
|
||||
drawDigit(point, *p);
|
||||
point.addX(11);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*************************************************************************
|
||||
* DRAW TEXT
|
||||
* Draw text using a simple bitmap font
|
||||
* INPUT topLeft The top left corner of the text
|
||||
* text The text to be displayed
|
||||
************************************************************************/
|
||||
void drawText(const Point & topLeft, const char * text)
|
||||
{
|
||||
void *pFont = GLUT_BITMAP_HELVETICA_12; // also try _18
|
||||
|
||||
// prepare to draw the text from the top-left corner
|
||||
glRasterPos2f(topLeft.getX(), topLeft.getY());
|
||||
|
||||
// loop through the text
|
||||
for (const char *p = text; *p; p++)
|
||||
glutBitmapCharacter(pFont, *p);
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
* DRAW POLYGON
|
||||
* Draw a POLYGON from a given location (center) of a given size (radius).
|
||||
* INPUT center Center of the polygon
|
||||
* radius Size of the polygon
|
||||
* points How many points will we draw it. Larger the number,
|
||||
* the more line segments we will use
|
||||
* rotation True circles are rotation independent. However, if you
|
||||
* are drawing a 3-sided polygon (triangle), this matters!
|
||||
*************************************************************************/
|
||||
void drawPolygon(const Point & center, int radius, int points, int rotation)
|
||||
{
|
||||
// begin drawing
|
||||
glBegin(GL_LINE_LOOP);
|
||||
|
||||
//loop around a circle the given number of times drawing a line from
|
||||
//one point to the next
|
||||
for (double i = 0; i < 2 * M_PI; i += (2 * M_PI) / points)
|
||||
{
|
||||
Point temp(false /*check*/);
|
||||
temp.setX(center.getX() + (radius * cos(i)));
|
||||
temp.setY(center.getY() + (radius * sin(i)));
|
||||
rotate(temp, center, rotation);
|
||||
glVertex2f(temp.getX(), temp.getY());
|
||||
}
|
||||
|
||||
// complete drawing
|
||||
glEnd();
|
||||
|
||||
}
|
||||
|
||||
|
||||
/************************************************************************
|
||||
* ROTATE
|
||||
* Rotate a given point (point) around a given origin (center) by a given
|
||||
* number of degrees (angle).
|
||||
* INPUT point The point to be moved
|
||||
* center The center point we will rotate around
|
||||
* rotation Rotation in degrees
|
||||
* OUTPUT point The new position
|
||||
*************************************************************************/
|
||||
void rotate(Point & point, const Point & origin, int rotation)
|
||||
{
|
||||
// because sine and cosine are expensive, we want to call them only once
|
||||
double cosA = cos(deg2rad(rotation));
|
||||
double sinA = sin(deg2rad(rotation));
|
||||
|
||||
// remember our original point
|
||||
Point tmp(false /*check*/);
|
||||
tmp.setX(point.getX() - origin.getX());
|
||||
tmp.setY(point.getY() - origin.getY());
|
||||
|
||||
// find the new values
|
||||
point.setX(static_cast<int> (tmp.getX() * cosA -
|
||||
tmp.getY() * sinA) +
|
||||
origin.getX());
|
||||
point.setY(static_cast<int> (tmp.getX() * sinA +
|
||||
tmp.getY() * cosA) +
|
||||
origin.getY());
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
* DRAW LINE
|
||||
* Draw a line on the screen from the beginning to the end.
|
||||
* INPUT begin The position of the beginning of the line
|
||||
* end The position of the end of the line
|
||||
*************************************************************************/
|
||||
void drawLine(const Point & begin, const Point & end,
|
||||
float red, float green, float blue)
|
||||
{
|
||||
// Get ready...
|
||||
glBegin(GL_LINES);
|
||||
glColor3f(red, green, blue);
|
||||
|
||||
// Draw the actual line
|
||||
glVertex2f(begin.getX(), begin.getY());
|
||||
glVertex2f( end.getX(), end.getY());
|
||||
|
||||
// Complete drawing
|
||||
glColor3f(1.0 /* red % */, 1.0 /* green % */, 1.0 /* blue % */);
|
||||
glEnd();
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
* DRAW Lander
|
||||
* Draw a moon-lander spaceship on the screen at a given point
|
||||
***********************************************************************/
|
||||
void drawLander(const Point & point)
|
||||
{
|
||||
// ultra simple point
|
||||
struct PT
|
||||
{
|
||||
int x;
|
||||
int y;
|
||||
} points[] =
|
||||
{
|
||||
{-6, 0}, {-10,0}, {-8, 0}, {-8, 3}, // left foot
|
||||
{-5, 4}, {-5, 7}, {-8, 3}, {-5, 4}, // left leg
|
||||
{-1, 4}, {-3, 2}, { 3, 2}, { 1, 4}, {-1, 4}, // bottom
|
||||
{ 5, 4}, { 5, 7}, {-5, 7}, {-3, 7}, // engine square
|
||||
{-6,10}, {-6,13}, {-3,16}, { 3,16}, // left of habitat
|
||||
{ 6,13}, { 6,10}, { 3, 7}, { 5, 7}, // right of habitat
|
||||
{ 5, 4}, { 8, 3}, { 5, 7}, { 5, 4}, // right leg
|
||||
{ 8, 3}, { 8, 0}, {10, 0}, { 6, 0} // right foot
|
||||
};
|
||||
|
||||
// draw it
|
||||
glBegin(GL_LINE_STRIP);
|
||||
for (int i = 0; i < sizeof(points) / sizeof(points[0]); i++)
|
||||
glVertex2f(point.getX() + points[i].x,
|
||||
point.getY() + points[i].y);
|
||||
|
||||
// complete drawing
|
||||
glEnd();
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
* DRAW Lander Flame
|
||||
* Draw the flames coming out of a moonlander for thrust
|
||||
***********************************************************************/
|
||||
void drawLanderFlames(const Point & point,
|
||||
bool bottom,
|
||||
bool left,
|
||||
bool right)
|
||||
{
|
||||
// simple point
|
||||
struct PT
|
||||
{
|
||||
int x;
|
||||
int y;
|
||||
};
|
||||
|
||||
int iFlame = random(0, 3); // so the flame flickers
|
||||
|
||||
// draw it
|
||||
glBegin(GL_LINE_LOOP);
|
||||
glColor3f(1.0 /* red % */, 0.0 /* green % */, 0.0 /* blue % */);
|
||||
|
||||
// bottom thrust
|
||||
if (bottom)
|
||||
{
|
||||
PT points[3][3] =
|
||||
{
|
||||
{ {-5, -6}, { 0, -1}, { 3, -10} },
|
||||
{ {-3, -6}, {-1, -2}, { 0, -15} },
|
||||
{ { 2, -12}, { 1, 0}, { 6, -4} }
|
||||
};
|
||||
|
||||
glVertex2f(point.getX() - 2, point.getY() + 2);
|
||||
for (int i = 0; i < 3; i++)
|
||||
glVertex2f(point.getX() + points[iFlame][i].x,
|
||||
point.getY() + points[iFlame][i].y);
|
||||
glVertex2f(point.getX() + 2, point.getY() + 2);
|
||||
}
|
||||
|
||||
// right thrust
|
||||
if (right)
|
||||
{
|
||||
PT points[3][3] =
|
||||
{
|
||||
{ {10, 14}, { 8, 12}, {12, 12} },
|
||||
{ {12, 10}, { 8, 10}, {10, 8} },
|
||||
{ {14, 11}, {14, 11}, {14, 11} }
|
||||
};
|
||||
|
||||
glVertex2f(point.getX() + 6, point.getY() + 12);
|
||||
for (int i = 0; i < 3; i++)
|
||||
glVertex2f(point.getX() + points[iFlame][i].x,
|
||||
point.getY() + points[iFlame][i].y);
|
||||
glVertex2f(point.getX() + 6, point.getY() + 10);
|
||||
}
|
||||
|
||||
// left thrust
|
||||
if (left)
|
||||
{
|
||||
PT points[3][3] =
|
||||
{
|
||||
{ {-10, 14}, { -8, 12}, {-12, 12} },
|
||||
{ {-12, 10}, { -8, 10}, {-10, 8} },
|
||||
{ {-14, 11}, {-14, 11}, {-14, 11} }
|
||||
};
|
||||
|
||||
glVertex2f(point.getX() - 6, point.getY() + 12);
|
||||
for (int i = 0; i < 3; i++)
|
||||
glVertex2f(point.getX() + points[iFlame][i].x,
|
||||
point.getY() + points[iFlame][i].y);
|
||||
glVertex2f(point.getX() - 6, point.getY() + 10);
|
||||
}
|
||||
|
||||
glColor3f(1.0 /* red % */, 1.0 /* green % */, 1.0 /* blue % */);
|
||||
glEnd();
|
||||
}
|
||||
|
||||
|
||||
/******************************************************************
|
||||
* RANDOM
|
||||
* This function generates a random number.
|
||||
*
|
||||
* INPUT: min, max : The number of values (min <= num <= max)
|
||||
* OUTPUT <return> : Return the integer
|
||||
****************************************************************/
|
||||
int random(int min, int max)
|
||||
{
|
||||
assert(min < max);
|
||||
int num = (rand() % (max - min)) + min;
|
||||
assert(min <= num && num <= max);
|
||||
|
||||
return num;
|
||||
}
|
||||
|
||||
/******************************************************************
|
||||
* RANDOM
|
||||
* This function generates a random number.
|
||||
*
|
||||
* INPUT: min, max : The number of values (min <= num <= max)
|
||||
* OUTPUT <return> : Return the double
|
||||
****************************************************************/
|
||||
double random(double min, double max)
|
||||
{
|
||||
assert(min <= max);
|
||||
double num = min + ((double)rand() / (double)RAND_MAX * (max - min));
|
||||
|
||||
assert(min <= num && num <= max);
|
||||
|
||||
return num;
|
||||
}
|
||||
|
||||
|
||||
/************************************************************************
|
||||
* DRAW RECTANGLE
|
||||
* Draw a rectangle on the screen centered on a given point (center) of
|
||||
* a given size (width, height), and at a given orientation (rotation)
|
||||
* INPUT center Center of the rectangle
|
||||
* width Horizontal size
|
||||
* height Vertical size
|
||||
* rotation Orientation
|
||||
*************************************************************************/
|
||||
void drawRect(const Point & center, int width, int height, int rotation)
|
||||
{
|
||||
Point tl(false /*check*/); // top left
|
||||
Point tr(false /*check*/); // top right
|
||||
Point bl(false /*check*/); // bottom left
|
||||
Point br(false /*check*/); // bottom right
|
||||
|
||||
//Top Left point
|
||||
tl.setX(center.getX() - (width / 2));
|
||||
tl.setY(center.getY() + (height / 2));
|
||||
|
||||
//Top right point
|
||||
tr.setX(center.getX() + (width / 2));
|
||||
tr.setY(center.getY() + (height / 2));
|
||||
|
||||
//Bottom left point
|
||||
bl.setX(center.getX() - (width / 2));
|
||||
bl.setY(center.getY() - (height / 2));
|
||||
|
||||
//Bottom right point
|
||||
br.setX(center.getX() + (width / 2));
|
||||
br.setY(center.getY() - (height / 2));
|
||||
|
||||
//Rotate all points the given degrees
|
||||
rotate(tl, center, rotation);
|
||||
rotate(tr, center, rotation);
|
||||
rotate(bl, center, rotation);
|
||||
rotate(br, center, rotation);
|
||||
|
||||
//Finally draw the rectangle
|
||||
glBegin(GL_LINE_STRIP);
|
||||
glVertex2f(tl.getX(), tl.getY());
|
||||
glVertex2f(tr.getX(), tr.getY());
|
||||
glVertex2f(br.getX(), br.getY());
|
||||
glVertex2f(bl.getX(), bl.getY());
|
||||
glVertex2f(tl.getX(), tl.getY());
|
||||
glEnd();
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
* DRAW CIRCLE
|
||||
* Draw a circle from a given location (center) of a given size (radius).
|
||||
* INPUT center Center of the circle
|
||||
* radius Size of the circle
|
||||
*************************************************************************/
|
||||
void drawCircle(const Point & center, int radius)
|
||||
{
|
||||
assert(radius > 1.0);
|
||||
const double increment = 1.0 / (double)radius;
|
||||
|
||||
// begin drawing
|
||||
glBegin(GL_LINE_LOOP);
|
||||
|
||||
// go around the circle
|
||||
for (double radians = 0; radians < M_PI * 2.0; radians += increment)
|
||||
glVertex2f(center.getX() + (radius * cos(radians)),
|
||||
center.getY() + (radius * sin(radians)));
|
||||
|
||||
// complete drawing
|
||||
glEnd();
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
* DRAW DOT
|
||||
* Draw a single point on the screen, 2 pixels by 2 pixels
|
||||
* INPUT point The position of the dow
|
||||
*************************************************************************/
|
||||
void drawDot(const Point & point)
|
||||
{
|
||||
// Get ready, get set...
|
||||
glBegin(GL_POINTS);
|
||||
|
||||
// Go...
|
||||
glVertex2f(point.getX(), point.getY() );
|
||||
glVertex2f(point.getX() + 1, point.getY() );
|
||||
glVertex2f(point.getX() + 1, point.getY() + 1);
|
||||
glVertex2f(point.getX(), point.getY() + 1);
|
||||
|
||||
// Done! OK, that was a bit too dramatic
|
||||
glEnd();
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
* DRAW Tough Bird
|
||||
* Draw a tough bird on the screen
|
||||
* INPUT point The position of the sacred
|
||||
* radius The size of the bird
|
||||
* hits How many its remaining to kill the bird
|
||||
*************************************************************************/
|
||||
void drawToughBird(const Point & center, float radius, int hits)
|
||||
{
|
||||
assert(radius > 1.0);
|
||||
const double increment = M_PI / 6.0;
|
||||
|
||||
// begin drawing
|
||||
glBegin(GL_TRIANGLES);
|
||||
|
||||
// three points: center, pt1, pt2
|
||||
Point pt1(false /*check*/);
|
||||
pt1.setX(center.getX() + (radius * cos(0.0)));
|
||||
pt1.setY(center.getY() + (radius * sin(0.0)));
|
||||
Point pt2(pt1);
|
||||
|
||||
// go around the circle
|
||||
for (double radians = increment;
|
||||
radians <= M_PI * 2.0 + .5;
|
||||
radians += increment)
|
||||
{
|
||||
pt2.setX(center.getX() + (radius * cos(radians)));
|
||||
pt2.setY(center.getY() + (radius * sin(radians)));
|
||||
|
||||
glVertex2f(center.getX(), center.getY());
|
||||
glVertex2f(pt1.getX(), pt1.getY() );
|
||||
glVertex2f(pt2.getX(), pt2.getY() );
|
||||
|
||||
pt1 = pt2;
|
||||
}
|
||||
|
||||
// complete drawing
|
||||
glEnd();
|
||||
|
||||
// draw the score in the center
|
||||
if (hits > 0 && hits < 10)
|
||||
{
|
||||
glColor3f(0.0 /* red % */, 0.0 /* green % */, 0.0 /* blue % */);
|
||||
glRasterPos2f(center.getX() - 4, center.getY() - 3);
|
||||
glutBitmapCharacter(GLUT_BITMAP_8_BY_13, (char)(hits + '0'));
|
||||
glColor3f(1.0, 1.0, 1.0); // reset to white
|
||||
}
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
* DRAW Sacred Bird
|
||||
* Draw a sacred bird on the screen
|
||||
* INPUT point The position of the sacred
|
||||
* radius The size of the bird
|
||||
*************************************************************************/
|
||||
void drawSacredBird(const Point & center, float radius)
|
||||
{
|
||||
// handle auto-rotation
|
||||
static float rotation = 0.0;
|
||||
rotation += 5.0;
|
||||
|
||||
|
||||
// begin drawing
|
||||
glBegin(GL_LINE_LOOP);
|
||||
glColor3f(1.0 /* red % */, 0.0 /* green % */, 0.0 /* blue % */);
|
||||
|
||||
|
||||
//loop around a circle the given number of times drawing a line from
|
||||
//one point to the next
|
||||
for (int i = 0; i < 5; i++)
|
||||
{
|
||||
Point temp(false /*check*/);
|
||||
float radian = (float)i * (M_PI * 2.0) * 0.4;
|
||||
temp.setX(center.getX() + (radius * cos(radian)));
|
||||
temp.setY(center.getY() + (radius * sin(radian)));
|
||||
rotate(temp, center, rotation);
|
||||
glVertex2f(temp.getX(), temp.getY());
|
||||
}
|
||||
|
||||
// complete drawing
|
||||
glColor3f(1.0, 1.0, 1.0); // reset to white
|
||||
glEnd();
|
||||
}
|
||||
|
||||
/**********************************************************************
|
||||
* DRAW SMALL ASTEROID
|
||||
**********************************************************************/
|
||||
void drawSmallAsteroid( const Point & center, int rotation)
|
||||
{
|
||||
// ultra simple point
|
||||
struct PT
|
||||
{
|
||||
int x;
|
||||
int y;
|
||||
} points[] =
|
||||
{
|
||||
{-5, 9}, {4, 8}, {8, 4},
|
||||
{8, -5}, {-2, -8}, {-2, -3},
|
||||
{-8, -4}, {-8, 4}, {-5, 10}
|
||||
};
|
||||
|
||||
glBegin(GL_LINE_STRIP);
|
||||
glColor3f(1.0 /* red % */, 0.0/* green % */, 1.0/* blue % */);
|
||||
for (int i = 0; i < sizeof(points)/sizeof(PT); i++)
|
||||
{
|
||||
Point pt(center.getX() + points[i].x,
|
||||
center.getY() + points[i].y);
|
||||
rotate(pt, center, rotation);
|
||||
glVertex2f(pt.getX(), pt.getY());
|
||||
}
|
||||
glEnd();
|
||||
}
|
||||
|
||||
/**********************************************************************
|
||||
* DRAW MEDIUM ASTEROID
|
||||
**********************************************************************/
|
||||
void drawMediumAsteroid( const Point & center, int rotation)
|
||||
{
|
||||
// ultra simple point
|
||||
struct PT
|
||||
{
|
||||
int x;
|
||||
int y;
|
||||
} points[] =
|
||||
{
|
||||
{2, 8}, {8, 15}, {12, 8},
|
||||
{6, 2}, {12, -6}, {2, -15},
|
||||
{-6, -15}, {-14, -10}, {-15, 0},
|
||||
{-4, 15}, {2, 8}
|
||||
};
|
||||
|
||||
glBegin(GL_LINE_STRIP);
|
||||
glColor3f(1.0 /* red % */, 0.0/* green % */, 1.0/* blue % */);
|
||||
for (int i = 0; i < sizeof(points)/sizeof(PT); i++)
|
||||
{
|
||||
Point pt(center.getX() + points[i].x,
|
||||
center.getY() + points[i].y);
|
||||
rotate(pt, center, rotation);
|
||||
glVertex2f(pt.getX(), pt.getY());
|
||||
}
|
||||
glEnd();
|
||||
}
|
||||
|
||||
/**********************************************************************
|
||||
* DRAW LARGE ASTEROID
|
||||
**********************************************************************/
|
||||
void drawLargeAsteroid( const Point & center, int rotation)
|
||||
{
|
||||
// ultra simple point
|
||||
struct PT
|
||||
{
|
||||
int x;
|
||||
int y;
|
||||
} points[] =
|
||||
{
|
||||
{0, 12}, {8, 20}, {16, 14},
|
||||
{10, 12}, {20, 0}, {0, -20},
|
||||
{-18, -10}, {-20, -2}, {-20, 14},
|
||||
{-10, 20}, {0, 12}
|
||||
};
|
||||
|
||||
glBegin(GL_LINE_STRIP);
|
||||
glColor3f(1.0 /* red % */, 0.0/* green % */, 0.0/* blue % */);
|
||||
for (int i = 0; i < sizeof(points)/sizeof(PT); i++)
|
||||
{
|
||||
Point pt(center.getX() + points[i].x,
|
||||
center.getY() + points[i].y);
|
||||
rotate(pt, center, rotation);
|
||||
glVertex2f(pt.getX(), pt.getY());
|
||||
}
|
||||
glEnd();
|
||||
}
|
||||
|
||||
|
||||
/************************************************************************
|
||||
* DRAW Ship
|
||||
* Draw a spaceship on the screen
|
||||
* INPUT point The position of the ship
|
||||
* angle Which direction it is ponted
|
||||
*************************************************************************/
|
||||
void drawShip(const Point & center, int rotation, bool thrust)
|
||||
{
|
||||
// ultra simple point
|
||||
struct PT
|
||||
{
|
||||
int x;
|
||||
int y;
|
||||
};
|
||||
|
||||
// draw the ship
|
||||
const PT pointsShip[] =
|
||||
{ // top r.wing r.engine l.engine l.wing top
|
||||
{0, 6}, {6, -6}, {2, -3}, {-2, -3}, {-6, -6}, {0, 6}
|
||||
};
|
||||
|
||||
glBegin(GL_LINE_STRIP);
|
||||
glColor3f(0.0 /* red % */, 0.0/* green % */, 1.0/* blue % */);
|
||||
for (int i = 0; i < sizeof(pointsShip)/sizeof(PT); i++)
|
||||
{
|
||||
Point pt(center.getX() + pointsShip[i].x,
|
||||
center.getY() + pointsShip[i].y);
|
||||
rotate(pt, center, rotation);
|
||||
glVertex2f(pt.getX(), pt.getY());
|
||||
}
|
||||
glEnd();
|
||||
|
||||
// draw the flame if necessary
|
||||
if (thrust)
|
||||
{
|
||||
const PT pointsFlame[3][5] =
|
||||
{
|
||||
{ {-2, -3}, {-2, -13}, { 0, -6}, { 2, -13}, {2, -3} },
|
||||
{ {-2, -3}, {-4, -9}, {-1, -7}, { 1, -14}, {2, -3} },
|
||||
{ {-2, -3}, {-1, -14}, { 1, -7}, { 4, -9}, {2, -3} }
|
||||
};
|
||||
|
||||
glBegin(GL_LINE_STRIP);
|
||||
glColor3f(1.0 /* red % */, 0.0 /* green % */, 0.0 /* blue % */);
|
||||
int iFlame = random(0, 3);
|
||||
for (int i = 0; i < 5; i++)
|
||||
{
|
||||
Point pt(center.getX() + pointsFlame[iFlame][i].x,
|
||||
center.getY() + pointsFlame[iFlame][i].y);
|
||||
rotate(pt, center, rotation);
|
||||
glVertex2f(pt.getX(), pt.getY());
|
||||
}
|
||||
glColor3f(1.0, 1.0, 1.0); // reset to white
|
||||
glEnd();
|
||||
}
|
||||
}
|
135
uiDraw.h
Normal file
135
uiDraw.h
Normal file
@ -0,0 +1,135 @@
|
||||
/***********************************************************************
|
||||
* Header File:
|
||||
* User Interface Draw : put pixels on the screen
|
||||
* Author:
|
||||
* Br. Helfrich
|
||||
* Summary:
|
||||
* This is the code necessary to draw on the screen. We have a collection
|
||||
* of procedural functions here because each draw function does not
|
||||
* retain state. In other words, they are verbs (functions), not nouns
|
||||
* (variables) or a mixture (objects)
|
||||
************************************************************************/
|
||||
|
||||
#ifndef UI_DRAW_H
|
||||
#define UI_DRAW_H
|
||||
|
||||
#include <string> // To display text on the screen
|
||||
#include <cmath> // for M_PI, sin() and cos()
|
||||
#include "point.h" // Where things are drawn
|
||||
using std::string;
|
||||
|
||||
/************************************************************************
|
||||
* DRAW DIGIT
|
||||
* Draw a single digit in the old school line drawing style. The
|
||||
* size of the glyph is 8x11 or x+(0..7), y+(0..10)
|
||||
*************************************************************************/
|
||||
void drawDigit(const Point & topLeft, char digit);
|
||||
|
||||
/*************************************************************************
|
||||
* DRAW NUMBER
|
||||
* Display an integer on the screen using the 7-segment method
|
||||
*************************************************************************/
|
||||
void drawNumber(const Point & topLeft, int number);
|
||||
|
||||
/*************************************************************************
|
||||
* DRAW TEXT
|
||||
* Draw text using a simple bitmap font
|
||||
************************************************************************/
|
||||
void drawText(const Point & topLeft, const char * text);
|
||||
|
||||
/************************************************************************
|
||||
* ROTATE
|
||||
* Rotate a given point (point) around a given origin (center) by a given
|
||||
* number of degrees (angle).
|
||||
*************************************************************************/
|
||||
void rotate(Point & point, const Point & origin, int rotation = 0);
|
||||
|
||||
/************************************************************************
|
||||
* DRAW RECTANGLE
|
||||
* Draw a rectangle on the screen centered on a given point (center) of
|
||||
* a given size (width, height), and at a given orientation (rotation)
|
||||
* measured in degrees (0 - 360)
|
||||
*************************************************************************/
|
||||
void drawRect(const Point & center, int width, int height, int rotation);
|
||||
|
||||
/************************************************************************
|
||||
* DRAW CIRCLE
|
||||
* Draw a circle from a given location (center) of a given size (radius).
|
||||
*************************************************************************/
|
||||
void drawCircle(const Point & center, int radius);
|
||||
|
||||
/************************************************************************
|
||||
* DRAW POLYGON
|
||||
* Draw a polygon from a given location (center) of a given size (radius).
|
||||
*************************************************************************/
|
||||
void drawPolygon(const Point & center,
|
||||
int radius = 20,
|
||||
int points = 4,
|
||||
int rotation = 0);
|
||||
|
||||
/************************************************************************
|
||||
* DRAW LINE
|
||||
* Draw a line on the screen from the beginning to the end.
|
||||
*************************************************************************/
|
||||
void drawLine(const Point & begin, const Point & end,
|
||||
float red = 1.0, float green = 1.0, float blue = 1.0);
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
* DRAW Lander
|
||||
* Draw a moon-lander spaceship on the screen at a given point
|
||||
***********************************************************************/
|
||||
void drawLander(const Point & point);
|
||||
|
||||
/***********************************************************************
|
||||
* DRAW Lander Flame
|
||||
* Draw the flames coming out of a moonlander for thrust
|
||||
***********************************************************************/
|
||||
void drawLanderFlames(const Point & point,
|
||||
bool bottom,
|
||||
bool left,
|
||||
bool right);
|
||||
|
||||
/************************************************************************
|
||||
* DRAW DOT
|
||||
* Draw a single point on the screen, 2 pixels by 2 pixels
|
||||
*************************************************************************/
|
||||
void drawDot(const Point & point);
|
||||
|
||||
/************************************************************************
|
||||
* DRAW Sacred Bird
|
||||
* Draw the bird on the screen
|
||||
*************************************************************************/
|
||||
void drawSacredBird(const Point & center, float radius);
|
||||
|
||||
/************************************************************************
|
||||
* DRAW Tough Bird
|
||||
* Draw a tough bird on the screen
|
||||
*************************************************************************/
|
||||
void drawToughBird(const Point & center, float radius, int hits);
|
||||
|
||||
/************************************************************************
|
||||
* DRAW Ship
|
||||
* Draw the spaceship on the screen
|
||||
*************************************************************************/
|
||||
void drawShip(const Point & point, int rotation, bool thrust);
|
||||
|
||||
/**********************************************************************
|
||||
* DRAW * ASTEROID
|
||||
**********************************************************************/
|
||||
void drawSmallAsteroid( const Point & point, int rotation);
|
||||
void drawMediumAsteroid(const Point & point, int rotation);
|
||||
void drawLargeAsteroid( const Point & point, int rotation);
|
||||
|
||||
/******************************************************************
|
||||
* RANDOM
|
||||
* This function generates a random number. The user specifies
|
||||
* The parameters
|
||||
* INPUT: min, max : The number of values (min <= num <= max)
|
||||
* OUTPUT <return> : Return the integer
|
||||
****************************************************************/
|
||||
int random(int min, int max);
|
||||
double random(double min, double max);
|
||||
|
||||
|
||||
#endif // UI_DRAW_H
|
326
uiInteract.cpp
Normal file
326
uiInteract.cpp
Normal file
@ -0,0 +1,326 @@
|
||||
/***********************************************************************
|
||||
* Source File:
|
||||
* UI INTERACT
|
||||
* Author:
|
||||
* Br. Helfrich
|
||||
* Description:
|
||||
* Implement the interfaces specified in uiInterface.h. This handles
|
||||
* all the interfaces and events necessary to work with OpenGL. Your
|
||||
* program will interface with this thorough the callback function
|
||||
* pointer towards the bottom of the file.
|
||||
************************************************************************/
|
||||
|
||||
#include <string> // need you ask?
|
||||
#include <sstream> // convert an integer into text
|
||||
#include <cassert> // I feel the need... the need for asserts
|
||||
#include <time.h> // for clock
|
||||
#include <cstdlib> // for rand()
|
||||
|
||||
|
||||
#ifdef __APPLE__
|
||||
#include <openGL/gl.h> // Main OpenGL library
|
||||
#include <GLUT/glut.h> // Second OpenGL library
|
||||
#endif // __APPLE__
|
||||
|
||||
#ifdef __linux__
|
||||
#include <GL/gl.h> // Main OpenGL library
|
||||
#include <GL/glut.h> // Second OpenGL library
|
||||
#endif // __linux__
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <Gl/glut.h> // OpenGL library we copied
|
||||
#include <ctime> // for ::Sleep();
|
||||
#include <Windows.h>
|
||||
|
||||
#define _USE_MATH_DEFINES
|
||||
#include <math.h>
|
||||
#endif // _WIN32
|
||||
|
||||
#include "uiInteract.h"
|
||||
#include "point.h"
|
||||
|
||||
using namespace std;
|
||||
|
||||
|
||||
/*********************************************************************
|
||||
* SLEEP
|
||||
* Pause for a while. We want to put the program to sleep until it
|
||||
* is time to draw again. Note that this requires us to tell the OS
|
||||
* that we are idle. the nanosleep function performs this task for us
|
||||
* INPUT: msSleep: sleep time in milliseconds
|
||||
*********************************************************************/
|
||||
void sleep(unsigned long msSleep)
|
||||
{
|
||||
// Windows handles sleep one way
|
||||
#ifdef _WIN32
|
||||
::Sleep(msSleep + 35);
|
||||
|
||||
// Unix-based operating systems (OS-X, Linux) do it another
|
||||
#else // LINUX, XCODE
|
||||
timespec req = {};
|
||||
time_t sec = (int)(msSleep / 1000);
|
||||
msSleep -= (sec * 1000);
|
||||
|
||||
req.tv_sec = sec;
|
||||
req.tv_nsec = msSleep * 1000000L;
|
||||
|
||||
while (nanosleep(&req, &req) == -1)
|
||||
;
|
||||
#endif // LINUX, XCODE
|
||||
return;
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
* DRAW CALLBACK
|
||||
* This is the main callback from OpenGL. It gets called constantly by
|
||||
* the graphics engine to refresh and draw the window. Here we will
|
||||
* clear the background buffer, draw on it, and send it to the forefront
|
||||
* when the appropriate time period has passsed.
|
||||
*
|
||||
* Note: This and all other callbacks can't be member functions, they must
|
||||
* have global scope for OpenGL to see them.
|
||||
*************************************************************************/
|
||||
void drawCallback()
|
||||
{
|
||||
// even though this is a local variable, all the members are static
|
||||
Interface ui;
|
||||
// Prepare the background buffer for drawing
|
||||
glClear(GL_COLOR_BUFFER_BIT); //clear the screen
|
||||
glColor3f(1,1,1);
|
||||
|
||||
//calls the client's display function
|
||||
assert(ui.callBack != NULL);
|
||||
ui.callBack(&ui, ui.p);
|
||||
|
||||
//loop until the timer runs out
|
||||
if (!ui.isTimeToDraw())
|
||||
sleep((unsigned long)((ui.getNextTick() - clock()) / 1000));
|
||||
|
||||
// from this point, set the next draw time
|
||||
ui.setNextDrawTime();
|
||||
|
||||
// bring forth the background buffer
|
||||
glutSwapBuffers();
|
||||
|
||||
// clear the space at the end
|
||||
ui.keyEvent();
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
* KEY DOWN CALLBACK
|
||||
* When a key on the keyboard has been pressed, we need to pass that
|
||||
* on to the client. Currently, we are only registering the arrow keys
|
||||
* INPUT key: the key we pressed according to the GLUT_KEY_ prefix
|
||||
* x y: the position in the window, which we ignore
|
||||
*************************************************************************/
|
||||
void keyDownCallback(int key, int x, int y)
|
||||
{
|
||||
// Even though this is a local variable, all the members are static
|
||||
// so we are actually getting the same version as in the constructor.
|
||||
Interface ui;
|
||||
ui.keyEvent(key, true /*fDown*/);
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
* KEY UP CALLBACK
|
||||
* When the user has released the key, we need to reset the pressed flag
|
||||
* INPUT key: the key we pressed according to the GLUT_KEY_ prefix
|
||||
* x y: the position in the window, which we ignore
|
||||
*************************************************************************/
|
||||
void keyUpCallback(int key, int x, int y)
|
||||
{
|
||||
// Even though this is a local variable, all the members are static
|
||||
// so we are actually getting the same version as in the constructor.
|
||||
Interface ui;
|
||||
ui.keyEvent(key, false /*fDown*/);
|
||||
}
|
||||
|
||||
/***************************************************************
|
||||
* KEYBOARD CALLBACK
|
||||
* Generic callback to a regular ascii keyboard event, such as
|
||||
* the space bar or the letter 'q'
|
||||
***************************************************************/
|
||||
void keyboardCallback(unsigned char key, int x, int y)
|
||||
{
|
||||
// Even though this is a local variable, all the members are static
|
||||
// so we are actually getting the same version as in the constructor.
|
||||
Interface ui;
|
||||
ui.keyEvent(key, true /*fDown*/);
|
||||
}
|
||||
|
||||
/***************************************************************
|
||||
* INTERFACE : KEY EVENT
|
||||
* Either set the up or down event for a given key
|
||||
* INPUT key which key is pressed
|
||||
* fDown down or brown
|
||||
****************************************************************/
|
||||
void Interface::keyEvent(int key, bool fDown)
|
||||
{
|
||||
switch(key)
|
||||
{
|
||||
case GLUT_KEY_DOWN:
|
||||
isDownPress = fDown;
|
||||
break;
|
||||
case GLUT_KEY_UP:
|
||||
isUpPress = fDown;
|
||||
break;
|
||||
case GLUT_KEY_RIGHT:
|
||||
isRightPress = fDown;
|
||||
break;
|
||||
case GLUT_KEY_LEFT:
|
||||
isLeftPress = fDown;
|
||||
break;
|
||||
case GLUT_KEY_HOME:
|
||||
case ' ':
|
||||
isSpacePress = fDown;
|
||||
break;
|
||||
}
|
||||
}
|
||||
/***************************************************************
|
||||
* INTERFACE : KEY EVENT
|
||||
* Either set the up or down event for a given key
|
||||
* INPUT key which key is pressed
|
||||
* fDown down or brown
|
||||
****************************************************************/
|
||||
void Interface::keyEvent()
|
||||
{
|
||||
if (isDownPress)
|
||||
isDownPress++;
|
||||
if (isUpPress)
|
||||
isUpPress++;
|
||||
if (isLeftPress)
|
||||
isLeftPress++;
|
||||
if (isRightPress)
|
||||
isRightPress++;
|
||||
isSpacePress = false;
|
||||
}
|
||||
|
||||
|
||||
/************************************************************************
|
||||
* INTEFACE : IS TIME TO DRAW
|
||||
* Have we waited long enough to draw swap the background buffer with
|
||||
* the foreground buffer?
|
||||
*************************************************************************/
|
||||
bool Interface::isTimeToDraw()
|
||||
{
|
||||
return ((unsigned int)clock() >= nextTick);
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
* INTERFACE : SET NEXT DRAW TIME
|
||||
* What time should we draw the buffer again? This is a function of
|
||||
* the current time and the frames per second.
|
||||
*************************************************************************/
|
||||
void Interface::setNextDrawTime()
|
||||
{
|
||||
nextTick = clock() + static_cast<int> (timePeriod * CLOCKS_PER_SEC);
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
* INTERFACE : SET FRAMES PER SECOND
|
||||
* The frames per second dictates the speed of the game. The more frames
|
||||
* per second, the quicker the game will appear to the user. We will default
|
||||
* to 30 frames/second but the client can set this at will.
|
||||
* INPUT value The number of frames per second. 30 is default
|
||||
*************************************************************************/
|
||||
void Interface::setFramesPerSecond(double value)
|
||||
{
|
||||
timePeriod = (1 / value);
|
||||
}
|
||||
|
||||
/***************************************************
|
||||
* STATICS
|
||||
* All the static member variables need to be initialized
|
||||
* Somewhere globally. This is a good spot
|
||||
**************************************************/
|
||||
int Interface::isDownPress = 0;
|
||||
int Interface::isUpPress = 0;
|
||||
int Interface::isLeftPress = 0;
|
||||
int Interface::isRightPress = 0;
|
||||
bool Interface::isSpacePress = false;
|
||||
bool Interface::initialized = false;
|
||||
double Interface::timePeriod = 1.0 / 30; // default to 30 frames/second
|
||||
unsigned int Interface::nextTick = 0; // redraw now please
|
||||
void * Interface::p = NULL;
|
||||
void (*Interface::callBack)(const Interface *, void *) = NULL;
|
||||
|
||||
|
||||
/************************************************************************
|
||||
* INTERFACE : DESTRUCTOR
|
||||
* Nothing here!
|
||||
***********************************************************************/
|
||||
Interface::~Interface()
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
/************************************************************************
|
||||
* INTEFACE : INITIALIZE
|
||||
* Initialize our drawing window. This will set the size and position,
|
||||
* get ready for drawing, set up the colors, and everything else ready to
|
||||
* draw the window. All these are part of initializing Open GL.
|
||||
* INPUT argc: Count of command-line arguments from main
|
||||
* argv: The actual command-line parameters
|
||||
* title: The text for the titlebar of the window
|
||||
*************************************************************************/
|
||||
void Interface::initialize(int argc, char ** argv, const char * title, Point topLeft, Point bottomRight)
|
||||
{
|
||||
if (initialized)
|
||||
return;
|
||||
|
||||
// set up the random number generator
|
||||
srand((unsigned int)time(NULL));
|
||||
|
||||
// create the window
|
||||
glutInit(&argc, argv);
|
||||
Point point;
|
||||
glutInitWindowSize( // size of the window
|
||||
(int)(bottomRight.getX() - topLeft.getX()),
|
||||
(int)(topLeft.getY() - bottomRight.getY()));
|
||||
|
||||
glutInitWindowPosition( 10, 10); // initial position
|
||||
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB); // double buffering
|
||||
glutCreateWindow(title); // text on titlebar
|
||||
glutIgnoreKeyRepeat(true);
|
||||
|
||||
// set up the drawing style: B/W and 2D
|
||||
glClearColor(0, 0, 0, 0); // Black is the background color
|
||||
gluOrtho2D((int)topLeft.getX(), (int)bottomRight.getX(),
|
||||
(int)bottomRight.getY(), (int)topLeft.getY()); // 2D environment
|
||||
|
||||
// register the callbacks so OpenGL knows how to call us
|
||||
glutDisplayFunc( drawCallback );
|
||||
glutIdleFunc( drawCallback );
|
||||
glutKeyboardFunc( keyboardCallback);
|
||||
glutSpecialFunc( keyDownCallback );
|
||||
glutSpecialUpFunc( keyUpCallback );
|
||||
initialized = true;
|
||||
|
||||
// done
|
||||
return;
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
* INTERFACE : RUN
|
||||
* Start the main graphics loop and play the game
|
||||
* INPUT callBack: Callback function. Every time we are beginning
|
||||
* to draw a new frame, we first callback to the client
|
||||
* to see if he wants to do anything, such as move
|
||||
* the game pieces or respond to input
|
||||
* p: Void point to whatever the caller wants. You
|
||||
* will need to cast this back to your own data
|
||||
* type before using it.
|
||||
*************************************************************************/
|
||||
void Interface::run(void (*callBack)(const Interface *, void *), void *p)
|
||||
{
|
||||
// setup the callbacks
|
||||
this->p = p;
|
||||
this->callBack = callBack;
|
||||
|
||||
glutMainLoop();
|
||||
|
||||
return;
|
||||
}
|
||||
|
131
uiInteract.h
Normal file
131
uiInteract.h
Normal file
@ -0,0 +1,131 @@
|
||||
/*********************************************
|
||||
* Header file:
|
||||
* UI INTERFACE
|
||||
* Author:
|
||||
* Br. Helfrich
|
||||
* Summary:
|
||||
* This module will create an OpenGL window,
|
||||
* enter the OpenGL main loop, and accept events.
|
||||
* The main methods are:
|
||||
* 1. Constructors - Create the window
|
||||
* 2. run() - Run the main loop
|
||||
* 3. callback - Specified in Run, this user-provided
|
||||
* function will get called with every frame
|
||||
* 4. isDown() - Is a given key pressed on this loop?
|
||||
**********************************************/
|
||||
|
||||
#ifndef UI_INTERFACE_H
|
||||
#define UI_INTERFACE_H
|
||||
|
||||
#include "point.h"
|
||||
|
||||
/********************************************
|
||||
* INTERFACE
|
||||
* All the data necessary to keep our graphics
|
||||
* state in memory
|
||||
********************************************/
|
||||
class Interface
|
||||
{
|
||||
public:
|
||||
// Default constructor useful for setting up the random variables
|
||||
// or for opening the file for output
|
||||
Interface() { initialize(0, 0x0000, "Window", Point(-50, 50), Point(50, -50)); };
|
||||
|
||||
// Constructor if you want to set up the window with anything but
|
||||
// the default parameters
|
||||
Interface(int argc, char ** argv, const char * title, Point topLeft, Point bottomRight)
|
||||
{
|
||||
initialize(argc, argv, title, topLeft, bottomRight);
|
||||
}
|
||||
|
||||
// Destructor, incase any housecleaning needs to occr
|
||||
~Interface();
|
||||
|
||||
// This will set the game in motion
|
||||
void run(void (*callBack)(const Interface *, void *), void *p);
|
||||
|
||||
// Is it time to redraw the screen
|
||||
bool isTimeToDraw();
|
||||
|
||||
// Set the next draw time based on current time and time period
|
||||
void setNextDrawTime();
|
||||
|
||||
// Retrieve the next tick time... the time of the next draw.
|
||||
unsigned int getNextTick() { return nextTick; };
|
||||
|
||||
// How many frames per second are we configured for?
|
||||
void setFramesPerSecond(double value);
|
||||
|
||||
// Key event indicating a key has been pressed or not. The callbacks
|
||||
// should be the only onces to call this
|
||||
void keyEvent(int key, bool fDown);
|
||||
void keyEvent();
|
||||
|
||||
// Current frame rate
|
||||
double frameRate() const { return timePeriod; };
|
||||
|
||||
// Get various key events
|
||||
int isDown() const { return isDownPress; };
|
||||
int isUp() const { return isUpPress; };
|
||||
int isLeft() const { return isLeftPress; };
|
||||
int isRight() const { return isRightPress; };
|
||||
bool isSpace() const { return isSpacePress; };
|
||||
|
||||
static void *p; // for client
|
||||
static void (*callBack)(const Interface *, void *);
|
||||
|
||||
private:
|
||||
void initialize(int argc, char ** argv, const char * title, Point topLeft, Point bottomRight);
|
||||
|
||||
static bool initialized; // only run the constructor once!
|
||||
static double timePeriod; // interval between frame draws
|
||||
static unsigned int nextTick; // time (from clock()) of our next draw
|
||||
|
||||
static int isDownPress; // is the down arrow currently pressed?
|
||||
static int isUpPress; // " up "
|
||||
static int isLeftPress; // " left "
|
||||
static int isRightPress; // " right "
|
||||
static bool isSpacePress; // " space "
|
||||
};
|
||||
|
||||
|
||||
|
||||
/************************************************************************
|
||||
* DRAW CALLBACK
|
||||
* This is the main callback from OpenGL. It gets called constantly by
|
||||
* the graphics engine to refresh and draw the window. Here we will
|
||||
* clear the background buffer, draw on it, and send it to the forefront
|
||||
* when the appropriate time period has passsed.
|
||||
*
|
||||
* Note: This and all other callbacks can't be member functions, they must
|
||||
* have global scope for OpenGL to see them.
|
||||
*************************************************************************/
|
||||
void drawCallback();
|
||||
|
||||
/************************************************************************
|
||||
* KEY DOWN CALLBACK
|
||||
* When a key on the keyboard has been pressed, we need to pass that
|
||||
* on to the client. Currnetly, we are only registering the arrow keys
|
||||
*************************************************************************/
|
||||
void keyDownCallback(int key, int x, int y);
|
||||
|
||||
/************************************************************************
|
||||
* KEY UP CALLBACK
|
||||
* When the user has released the key, we need to reset the pressed flag
|
||||
*************************************************************************/
|
||||
void keyUpCallback(int key, int x, int y);
|
||||
|
||||
/***************************************************************
|
||||
* KEYBOARD CALLBACK
|
||||
* Generic callback to a regular ascii keyboard event, such as
|
||||
* the space bar or the letter 'q'
|
||||
***************************************************************/
|
||||
void keyboardCallback(unsigned char key, int x, int y);
|
||||
|
||||
/************************************************************************
|
||||
* RUN
|
||||
* Set the game in action. We will get control back in our drawCallback
|
||||
*************************************************************************/
|
||||
void run();
|
||||
|
||||
#endif // UI_INTERFACE_H
|
59
velocity.cpp
Normal file
59
velocity.cpp
Normal file
@ -0,0 +1,59 @@
|
||||
#include "velocity.h"
|
||||
|
||||
// Default velocity constructor
|
||||
Velocity :: Velocity ()
|
||||
{
|
||||
setDx ( 0.0 );
|
||||
setDy ( 0.0 );
|
||||
}
|
||||
|
||||
// Velocity constructor
|
||||
Velocity :: Velocity ( float dx , float dy )
|
||||
{
|
||||
setDx ( dx );
|
||||
setDy ( dy );
|
||||
}
|
||||
|
||||
// Get Velocity dx
|
||||
float Velocity :: getDx() const
|
||||
{
|
||||
return dx;
|
||||
}
|
||||
|
||||
// Get Velocity dy
|
||||
float Velocity :: getDy() const
|
||||
{
|
||||
return dy;
|
||||
}
|
||||
|
||||
// Set Velocity dx
|
||||
void Velocity :: setDx( float dx )
|
||||
{
|
||||
this->dx = dx;
|
||||
}
|
||||
|
||||
// Set Velocity dy
|
||||
void Velocity :: setDy( float dy )
|
||||
{
|
||||
this->dy = dy;
|
||||
}
|
||||
|
||||
// Add dy Velocity
|
||||
void Velocity :: addDy ( const float dy )
|
||||
{
|
||||
this->dy += dy;
|
||||
}
|
||||
|
||||
// Add dx Velocity
|
||||
void Velocity :: addDx ( const float dx )
|
||||
{
|
||||
this->dx += dx;
|
||||
}
|
||||
|
||||
// Update a point
|
||||
Point Velocity :: updatePoint ( Point &point )
|
||||
{
|
||||
point.addX ( dx );
|
||||
point.addY ( dy );
|
||||
return point;
|
||||
}
|
23
velocity.h
Normal file
23
velocity.h
Normal file
@ -0,0 +1,23 @@
|
||||
#ifndef VELOCITY_H
|
||||
#define VELOCITY_H
|
||||
|
||||
#include "point.h"
|
||||
|
||||
class Velocity
|
||||
{
|
||||
public:
|
||||
Velocity();
|
||||
Velocity( float dx , float dy );
|
||||
float getDx() const;
|
||||
float getDy() const;
|
||||
void addDy( const float dy );
|
||||
void addDx( const float dx );
|
||||
void setDx( float dx );
|
||||
void setDy( float dy );
|
||||
Point updatePoint ( Point &point );
|
||||
private:
|
||||
float dx;
|
||||
float dy;
|
||||
};
|
||||
|
||||
#endif
|
Loading…
Reference in New Issue
Block a user