1

     2

#include "Physics.hh"

     3

#include "Engine.hh"

     4

     5

#include <algorithm>

     6

#include <functional>

     7

#include <cmath>

     8

     9

PhysicsWorld::PhysicsWorld (Vector gravity, Vector dimensions)

    10

    : tick_timer(PHYSICS_TICK_MS), gravity(gravity), dimensions(dimensions), terrain(dimensions.x, std::vector<TerrainType>(dimensions.y, EMPTY)) {

    11

    12

    slots.connect(tick_timer.sig_timer(), this, &PhysicsWorld::tick);

    13

    tick_timer.enable();

    14

}

    15

    16

void PhysicsWorld::addObject (PhysicsObject *object) {

    17

    objects.push_back(object);

    18

}

    19

    20

void PhysicsWorld::tick () {

    21

//    Engine::log(DEBUG, "physics.apply_force") << "*tick*";

    22

    23

    for (std::vector<PhysicsObject*>::iterator i = objects.begin(); i != objects.end(); i++) {

    24

        (*i)->tick(); 

    25

    }

    26

}

    27

    28

PhysicsObject::PhysicsObject (PhysicsWorld &world, float mass, Vector position, Vector velocity)

    29

    : world(world), mass(mass), position(position), velocity(velocity) {

    30

    31

    world.addObject(this);

    32

}

    33

    65

    this->velocity += world.gravity * (PHYSICS_TICK_MS / 1000.0);

    67

    Vector newPosition = position + velocity * (PHYSICS_TICK_MS / 1000.0);

    69

    70

    //TODO Handle the object as a square or a polygon

    72

    bool collided = false;

    73

    74

    //goes 1 unit forward every step and check if has hit anything

    75

    Vector unitVector = (newPosition-position) / (newPosition-position).length();

    76

    77

	Vector tmpVector = position;

    78

    Vector reached = position;

    79

	int steps = (int) (newPosition-position).length();

    80

    for(int i = 0; i < steps; i++) {

    81

        tmpVector += unitVector;

    82

        if(world.getType(tmpVector) != EMPTY) {

    83

			//Engine::log(DEBUG, "physics.update_position") << "hit something";

    84

            // Then we have hit something

    85

            reached = position + unitVector*(i-1);

    86

            collided = true;

    87

            break;

    88

        } else {

    89

			//Engine::log(DEBUG, "physics.update_position") << "didnt hit";

    90

		}

    91

    }

    92

    93

    // In case of some float error

    94

    if(!collided) {

    95

        if(world.getType(newPosition)) {

    96

            // There was error, and there is ground

    97

            newPosition = tmpVector;

    98

        } else {

    99

            // This means everything was ok, so no need to do anything

   100

        }

   101

    } else {

   102

        newPosition = reached;

   103

        this->velocity = Vector(0, 0);

   104

        //TODO: it shouldn't just stop on collision

   105

    }

   106

    this->position = newPosition;

   108

}

   109

   110

bool PhysicsWorld::collided (Vector oldPos, Vector newPos) {

   111

    int deltaX = oldPos.x - newPos.x; 

   112

    int deltaY = oldPos.y - newPos.y; 

   113

    double distance = sqrt(deltaX * deltaX + deltaY * deltaY);

   114

    double xInc = deltaX / distance;

   115

    double yInc = deltaY / distance;

   116

    double currentX = oldPos.x;

   117

    double currentY = oldPos.y;

   118

   119

    // This implementation is bit slow since it checks some squares twice.

   120

    for(unsigned int i = 1; i < distance; i++) {

   121

        currentX += xInc;

   122

        currentY += yInc;

   123

        if(terrain[(int)currentX][(int)currentY] != EMPTY)

   124

            return true;

   125

    }

   126

    return false;

   127

}

   128

   135

void PhysicsObject::integrate(Vector force, TimeMS dt) {

   150

}

   151

   155

   176

}

   177

   178

void PhysicsObject::updatePhysics (Vector position, Vector velocity) {

   179

    this->position = position;

   180

    this->velocity = velocity;

   181

}

   182

   183

Vector PhysicsObject::getPosition () {

   184

    return this->position;

   185

}

   186

   187

void PhysicsObject::tick () {

   188

    this->updatePosition();

   189

}

   190

   191

/**

   192

 * simple random map generation

   193

 * first fills whole level with dirt

   194

 * then randomizes circles of empty or rock

   195

 * @param seed - seed number for random number generator

   196

 */

   197

void PhysicsWorld::generateTerrain(int seed) {

   198

    // generating should use own random number generator, but didn't find easily how that is done

   199

    srand(seed);

   200

   201

    // some constants to control random generation

   202

    const int min_range = 10;

   203

    const int max_range = 40;

   204

    const int num = 0;

   205

    const int rock_rarity = 4; // 1 / rock_rarity will be rock circle

   206

   207

    // loops for amount of circles

   208

    for(int i = 0; i < num; i++) {

   209

        // information of new circle

   210

        int midx = rand()%(int)dimensions.x;

   211

        int midy = rand()%(int)dimensions.y;

   212

   213

        // put first circle in the middle of the cave

   214

		// so that we have some area we can certainly spawn into 

   215

		if(i == 0) {

   216

			midx = dimensions.x / 2;

   217

			midy = dimensions.y / 2;

   218

		}

   219

   220

        int range = rand()%(max_range-min_range)+min_range;

   221

        TerrainType type = EMPTY;

   222

        if(rand()%rock_rarity == 0) {

   223

            type = ROCK;

   224

        }

   225

        // loops for every pixel of circle

   226

        for(int x = std::max(0, midx-range); x < std::min((int)dimensions.x, midx+range); x++) {

   227

            for(int y = std::max(0, midy-range); y < std::min((int)dimensions.y, midy+range); y++) {

   228

                if(x*x+y*y < range*range) {

   229

                    // and sets it to type

   230

                    terrain[x][y] = type;

   231

                }

   232

            }

   233

        }

   234

    }

   235

}

   236

   237

/**

   238

 * Returns terrainType in given tile. ROCK if tile is out of area

   239

 * @param pos - coordinate of tile

   240

 */

   241

TerrainType PhysicsWorld::getType(Vector pos) const {

   242

    int x = (int)(pos.x);

   243

    int y = (int)(pos.y);

   244

    if(x < 0 || y < 0 || x >= dimensions.x || y >= dimensions.y) {

   245

        return ROCK;

   246

    }

   247

    return terrain[x][y];

   248

}