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

    34

void PhysicsObject::updatePosition () {

    35

    36

    // Calculate gravity's influence on the velocity vector

    37

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

    38

    39

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

    40

    41

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

    42

    43

    bool collided = false;

    44

    45

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

    46

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

    49

    Vector reached = position;

    52

        tmpVector += unitVector;

    53

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

    54

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

    55

            // Then we have hit something

    56

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

    57

            collided = true;

    58

            break;

    59

        } else {

    60

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

    61

		}

    62

    }

    63

    64

    // In case of some float error

    65

    if(!collided) {

    66

        if(world.getType(newPosition)) {

    67

            // There was error, and there is ground

    68

            newPosition = tmpVector;

    69

        } else {

    70

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

    71

        }

    72

    } else {

    73

        newPosition = reached;

    74

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

    75

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

    76

    }

    77

    this->position = newPosition;

    78

}

    79

    80

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

    81

    int deltaX = oldPos.x - newPos.x; 

    82

    int deltaY = oldPos.y - newPos.y; 

    83

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

    84

    double xInc = deltaX / distance;

    85

    double yInc = deltaY / distance;

    86

    double currentX = oldPos.x;

    87

    double currentY = oldPos.y;

    88

    89

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

    90

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

    91

        currentX += xInc;

    92

        currentY += yInc;

    93

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

    94

            return true;

    95

    }

    96

    return false;

    97

}

    98

    99

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

   100

    // TODO

   101

}

   102

   103

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

   104

    Vector oldVelocity = velocity;

   105

   106

    this->velocity += force * dt / 1000 / mass;  // The last factor denotes the time.

   107

    // It should be scaled somehow.

   108

   109

//    Engine::log(DEBUG, "physics.apply_force") << "force=" << force << ", velocity " << oldVelocity << " -> " << velocity;

   110

}

   111

   112

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

   113

    this->position = position;

   114

    this->velocity = velocity;

   115

}

   116

   117

Vector PhysicsObject::getPosition () {

   118

    return this->position;

   119

}

   120

   121

void PhysicsObject::tick () {

   122

    this->updatePosition();

   123

}

   124

   125

/**

   126

 * simple random map generation

   127

 * first fills whole level with dirt

   128

 * then randomizes circles of empty or rock

   129

 * @param seed - seed number for random number generator

   130

 */

   131

void PhysicsWorld::generateTerrain(int seed) {

   132

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

   133

    srand(seed);

   134

   135

    // some constants to control random generation

   136

    const int min_range = 10;

   137

    const int max_range = 40;

   138

    const int num = 0;

   139

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

   140

   141

    // loops for amount of circles

   142

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

   143

        // information of new circle

   144

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

   145

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

   146

   147

        // put first circle in the middle of the cave

   148

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

   149

		if(i == 0) {

   150

			midx = dimensions.x / 2;

   151

			midy = dimensions.y / 2;

   152

		}

   153

   154

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

   155

        TerrainType type = EMPTY;

   156

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

   157

            type = ROCK;

   158

        }

   159

        // loops for every pixel of circle

   160

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

   161

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

   162

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

   163

                    // and sets it to type

   164

                    terrain[x][y] = type;

   165

                }

   166

            }

   167

        }

   168

    }

   169

}

   170

   171

/**

   172

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

   173

 * @param pos - coordinate of tile

   174

 */

   175

TerrainType PhysicsWorld::getType(Vector pos) const {

   176

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

   177

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

   178

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

   179

        return ROCK;

   180

    }

   181

    return terrain[x][y];

   182

}