initial commit

src/Asteroid.cpp

+
+#include "Asteroid.hpp"
+
+Asteroid::Asteroid() {
+    // random size, position, speed and colour
+    a.set(ofRandom(1, 10));
+    pos = ofVec3f(ofRandom(-ofGetWidth()*.2, ofGetWidth()*.2), -20, ofRandom(-2000, -10000));
+    color = ofColor(ofRandom(0, 255), ofRandom(0, 255), ofRandom(0, 255));
+    speed = ofRandom(1, 20);
+    wiggleAmount = ofRandom(5);
+    wiggleSpeed = ofRandom(0.01);
+}
+
+void Asteroid::draw() {
+    ofSetColor(color);
+    a.draw();
+}
+
+void Asteroid::update(ofBoxPrimitive player) {
+    ofVec3f playerPos = player.getPosition();
+    float playerSize = player.getSize().x;
+    
+    // reset asteroid position once it is off screen
+    if(pos.z > 0) respawn();
+    
+    // move asteroid towards player
+    pos.z += speed;
+    
+    // wiggle asteroid
+    pos.x += ofMap(ofNoise(ofGetElapsedTimeMillis() * wiggleSpeed), 0, 1, -wiggleAmount, wiggleAmount);
+    
+    a.setPosition(pos);
+}
+
+void Asteroid::respawn() {
+    // position asteroid way in the distance
+    pos.z = ofRandom(-8000, -10000);
+}
+
+bool Asteroid::collision(ofBoxPrimitive player) {
+    ofVec3f playerPos = player.getPosition();
+    float playerSize = player.getSize().x;
+    
+    if(pos.z > playerPos.z &&
+       pos.x < playerPos.x + playerSize &&
+       pos.x > playerPos.x - playerSize)
+        return true;
+    
+    return false;
+}

src/Asteroid.hpp

+
+#pragma once
+
+#include "ofMain.h"
+
+class Asteroid {
+    
+    public:
+        Asteroid();
+        
+        void draw();
+        void update(ofBoxPrimitive player);
+        void respawn();
+        bool collision(ofBoxPrimitive player);
+        
+        ofBoxPrimitive a;
+        ofVec3f pos;
+        ofColor color;
+        int speed, wiggleAmount;
+        float wiggleSpeed;
+};

src/GamePlay.cpp

+#include "GamePlay.hpp"
+
+/*
+ a very crude 3D asteroids game - sorry if it runs slowly, there are no pointers
+ */
+
+GamePlay::GamePlay() {
+    state = 0;
+    
+    player.set(5);
+    player.setPosition(0, -20, -50);
+        
+    camera.setPosition(0, 0, 0);
+    
+    addAsteroids(50);
+}
+
+void GamePlay::run() {
+    if(state == 0) playing();
+    if(state == 1) gameOver();
+}
+
+void GamePlay::playing() {
+    // increment score
+    score = ofGetFrameNum();
+    // add 10 more asteroids whenever score is multiple of 100
+    if (score % 100 == 0) addAsteroids(10);
+    // don't let asteroids size grow over 250
+    if (asteroids.size() >= 250) asteroids.pop_back();
+    
+    // display score
+    ofSetColor(160, 210, 214);
+    ofDrawBitmapString("score: " + to_string(score), 20, 20);
+    
+    // camera perspective
+    camera.begin();
+        ofSetColor(255, ofRandom(200, 240));
+        player.drawWireframe();
+    
+        for(int i = 0; i < asteroids.size(); i++) {
+            asteroids[i].draw();
+            asteroids[i].update(player);
+            // game over
+            if(asteroids[i].collision(player)) state = 1;
+        }
+    camera.end();
+    
+    borders();
+}
+
+void GamePlay::gameOver() {
+    finalScore = score;
+    ofSetColor(160, 210, 214);
+    ofDrawBitmapString("game over\nscore: " + to_string(finalScore), ofGetWidth()*.5, ofGetHeight()*.5);
+}
+
+void GamePlay::addAsteroids(int num) {
+    for(int i = 0; i < num; i++) {
+        Asteroid a;
+        asteroids.push_back(a);
+    }
+}
+
+void GamePlay::move(float amount) {
+    player.truck(amount);
+}
+
+void GamePlay::borders() {
+    if(player.getX() >= 34) player.setPosition(34, -20, -50);
+    if(player.getX() <= -34)player.setPosition(-34,-20, -50);
+}
+

src/GamePlay.hpp

+
+#pragma once
+
+#include "ofMain.h"
+#include "Asteroid.hpp"
+
+#include <vector>
+
+class GamePlay {
+    
+    public:
+        GamePlay();
+    
+        void run();
+        void playing();
+        void gameOver();
+        void addAsteroids(int num);
+    
+        void borders();
+        void move(float amount);
+    
+        ofBoxPrimitive player;
+        ofCamera camera;
+        vector<Asteroid> asteroids;
+    
+        int score, finalScore, state;
+};

src/main.cpp

+#include "ofMain.h"
+#include "ofApp.h"
+
+//========================================================================
+int main( ){
+	ofSetupOpenGL(1524,768,OF_WINDOW);			// <-------- setup the GL context
+
+	// this kicks off the running of my app
+	// can be OF_WINDOW or OF_FULLSCREEN
+	// pass in width and height too:
+	ofRunApp(new ofApp());
+
+}

src/ofApp.cpp

+#include "ofApp.h"
+
+//--------------------------------------------------------------
+void ofApp::setup(){
+    ofBackground(10);
+    ofEnableDepthTest();
+    
+    cam.setup(320, 240);
+}
+
+//--------------------------------------------------------------
+void ofApp::update(){
+    cam.update();
+    
+    // send camera to optical flow algorithm
+    if(cam.isFrameNew())
+        fb.calcOpticalFlow(cam);
+    
+    avgFlow = fb.getAverageFlow();
+    
+    smoothAvgFlow = onePole(smoothAvgFlow, avgFlow);
+    
+    movePlayerUsingFlow();
+    
+
+}
+
+//--------------------------------------------------------------
+void ofApp::draw() {
+    ofSetColor(255);
+    ofSetLineWidth(1);
+    
+    ofPushMatrix();
+        // draw camera feed in top right corner
+        ofTranslate(ofGetWidth()-cam.getWidth(), 0);
+        fb.draw(0,0);
+        cam.draw(0,0);
+    ofPopMatrix();
+    
+    ofPushMatrix();
+        // draw camera feed in top right corner
+        ofTranslate(ofGetWidth()/2, ofGetHeight()/2);
+    ofDrawLine(0, 0,smoothAvgFlow.x * 100, smoothAvgFlow.y * 100);
+    ofPopMatrix();
+    
+    //printing out location
+    ofDrawBitmapString("Player loaction: " +
+        to_string(smoothAvgFlow.x) +
+        to_string(smoothAvgFlow.y), 20, 50);
+    game.run();
+}
+
+//--------------------------------------------------------------
+void ofApp::keyPressed(int key){
+    if(key == OF_KEY_LEFT)  game.move(-2);
+    if(key == OF_KEY_RIGHT) game.move(2);
+}
+
+ofVec2f ofApp::onePole(ofVec2f current, ofVec2f prev){
+    //coefficient
+    float a = 0.9;
+    return prev + a * (current - prev);
+}
+
+void ofApp::movePlayerUsingFlow(){
+    float speed = 0.5;
+    float threshold = 0.1;
+    
+    if(smoothAvgFlow.x < -threshold){
+        game.move(-speed);
+    }
+    else if (smoothAvgFlow.x > threshold){
+        game.move(speed);
+    }
+}

src/ofApp.h

+#pragma once
+
+#include "ofMain.h"
+#include "GamePlay.hpp"
+#include "ofxCv.h"
+
+using namespace ofxCv;
+
+class ofApp : public ofBaseApp{
+    
+    public:
+        void setup();
+        void update();
+        void draw();
+        void keyPressed(int key);
+    
+        //player moving function
+        void movePlayerUsingFlow();
+    
+        //one pole function
+        ofVec2f onePole(ofVec2f current, ofVec2f prev);
+    
+        ofVideoGrabber cam;
+        FlowFarneback fb;
+    
+        GamePlay game;
+    
+        ofVec2f avgFlow;
+        ofVec2f smoothAvgFlow;
+};