kg: comparison src/proto2/Physics.cc

equal deleted inserted replaced

-:d90977611fee
+:1b9ad61bdf2d
 #include <assert.h>
 PhysicsWorld::PhysicsWorld (Vector gravity, Vector dimensions)
 : tick_timer(PHYSICS_TICK_MS), tick_counter(0), gravity(gravity), dimensions(dimensions), terrain(dimensions.x, std::vector<TerrainType>(dimensions.y, DIRT)) {
-	generateTerrain(1337);
+generateTerrain(1337);
 slots.connect(tick_timer.sig_timer(), this, &PhysicsWorld::tick);
 tick_timer.enable();
 }
 *
 * Make the worm walk on the ground.
 * @return Final position.
 */
 Vector PhysicsObject::walk (bool right) {
-	Vector cursor = right ? this->position + Vector(1,0) : this->position + Vector(-1,0);
+Vector cursor = right ? this->position + Vector(1,0) : this->position + Vector(-1,0);
-	Vector reached = this->position;
+Vector reached = this->position;
-	//for(int steps = 0; steps < 3; steps++) {
+//for(int steps = 0; steps < 3; steps++) {
-		// Go up but not if the wall is over two pixels
+// Go up but not if the wall is over two pixels
-		if(world.getType(cursor) != EMPTY) {
+if(world.getType(cursor) != EMPTY) {
-		for(int height = 0, max = 3; height < max+42; height++) {
+for(int height = 0, max = 3; height < max+42; height++) {
-				if(height >= max)
+if(height >= max)
-					return reached;
+return reached;
-				cursor.y--;
+cursor.y--;
-				if(world.getType(cursor) == EMPTY) {
+if(world.getType(cursor) == EMPTY) {
-					// Check that the other parts of the worm don't collide with anything
+// Check that the other parts of the worm don't collide with anything
-					if(possibleLocation(cursor)) {
+if(possibleLocation(cursor)) {
-						reached = cursor;
+reached = cursor;
-						continue;
+continue;
-					} else {
+} else {
-						// Can't get any further
+// Can't get any further
-						return reached;
+return reached;
-					}
+}
-				}
+}
-			}
+}
-		} else {
+} else {
-			if(possibleLocation(cursor)) {
+if(possibleLocation(cursor)) {
-				reached = cursor;
+reached = cursor;
-			}
+}
-			// Start checking if the lower squares are empty
+// Start checking if the lower squares are empty
 for(int depth = 0, max = 3; depth < max+42; depth++) {
-				if(depth >= max) {
+if(depth >= max) {
-					// We can start a free fall now
+// We can start a free fall now
-					//
+//
-				// TODO it should be set inAir if it falls from a cliff
+// TODO it should be set inAir if it falls from a cliff
-				//this->inAir = true;
+//this->inAir = true;
 // Put some speed there to make loke smoother
-					//this->velocity.y = -5;
+//this->velocity.y = -5;
-					return reached;
+return reached;
-				}
+}
-				cursor.y++;
+cursor.y++;
-				if(world.getType(cursor) == EMPTY) {
+if(world.getType(cursor) == EMPTY) {
-					// Check that the other parts of the worm don't collide with anything
+// Check that the other parts of the worm don't collide with anything
-					if(possibleLocation(cursor)) {
+if(possibleLocation(cursor)) {
-						reached = cursor;
+reached = cursor;
-						continue;
+continue;
-					} else {
+} else {
-						// Can't get any further
+// Can't get any further
-						return reached;
+return reached;
-					}
+}
-				}
+}
-			}
+}
-		}
+}
-	//	cursor.x += right ? 1 : -1;
+//    cursor.x += right ? 1 : -1;
-	//}
+//}
-	return reached;
+return reached;
 }
 void PhysicsObject::jump () {
-	velocity.y = -100;
+velocity.y = -100;
-	inAir = true;
+inAir = true;
 }
 bool PhysicsObject::possibleLocation (Vector loc) {
-	for(unsigned int i = 0; i < this->shape.size(); i++) {
+for(unsigned int i = 0; i < this->shape.size(); i++) {
-		if(world.getType(loc+shape[i]) != EMPTY)
+if(world.getType(loc+shape[i]) != EMPTY)
-			return false;
+return false;
-	}
+}
-	return true;
+return true;
 }
 /**
 * Updates object speed and position. This function organises force
 * integration and collision detection.
 this->position = moveVertically(forceq.front().x > 0);
 forceq.pop();
 }
 } */
 return;
-	}
+}
-	// TODO HERE
+// TODO HERE
 // Add gravity to the force queue
 forceq.push(world.gravity);
 // Go trough every force in the queue
 bool collided = false;
 //goes 1 unit forward every step and check if has hit anything
 Vector unitVector = (newPosition-position) / (newPosition-position).length();
-	Vector tmpVector = position;
+Vector tmpVector = position;
 Vector reached = position;
-	int steps = (int) (newPosition-position).length() + 2;
+int steps = (int) (newPosition-position).length() + 2;
-	//Engine::log(DEBUG, "physics.update_position") << unitVector-newPosition;
+//Engine::log(DEBUG, "physics.update_position") << unitVector-newPosition;
-	//Vector foo = position+unitVector*steps-newPosition;
+//Vector foo = position+unitVector*steps-newPosition;
 //Engine::log(DEBUG, "PhysicsObject.updatePosition") << "Virhe: "<< foo;
 for(int i = 0; i < steps; i++) {
 tmpVector += unitVector;
-		float minVelocity = 10;
+float minVelocity = 10;
-		// Check if any of the four corners of the worm collide
+// Check if any of the four corners of the worm collide
-		for(int sh = 0; sh < 4; sh++) {
+for(int sh = 0; sh < 4; sh++) {
 if(world.getType(tmpVector+shape[sh]) != EMPTY) {
-				reached = position + unitVector*(i-1);
+reached = position + unitVector*(i-1);
-				collided = true;
+collided = true;
-				this->bounce(world.getNormal(tmpVector+shape[sh], tmpVector-unitVector+shape[sh]));
+this->bounce(world.getNormal(tmpVector+shape[sh], tmpVector-unitVector+shape[sh]));
-				this->velocity *= 0.4;
+this->velocity *= 0.4;
-				if(abs(this->velocity.x) < minVelocity && (abs(this->velocity.y) < minVelocity)) {
+if(abs(this->velocity.x) < minVelocity && (abs(this->velocity.y) < minVelocity)) {
-					this->inAir = false;
+this->inAir = false;
-					this->velocity = Vector(0,0);
+this->velocity = Vector(0,0);
-				}
+}
-				break;
+break;
-			}
+}
-		}
+}
-		if(collided)
+if(collided)
-			break;
+break;
-		/*
+/*
-		if(velocity.y > 0) {
+if(velocity.y > 0) {
-	if(world.getType(tmpVector+shape[2]) != EMPTY) {
+if(world.getType(tmpVector+shape[2]) != EMPTY) {
-	reached = position + unitVector*(i-1);
+reached = position + unitVector*(i-1);
-	collided = true;
+collided = true;
-				this->velocity.y *= -0.3;
+this->velocity.y *= -0.3;
-				this->velocity.x *= 0.7;
+this->velocity.x *= 0.7;
-				if(abs(this->velocity.x) < minVelocity && (abs(this->velocity.y) < minVelocity)) {
+if(abs(this->velocity.x) < minVelocity && (abs(this->velocity.y) < minVelocity)) {
-		this->inAir = false;
+this->inAir = false;
-					this->velocity = Vector(0,0);
+this->velocity = Vector(0,0);
-				}
+}
-	break;
+break;
-			}
+}
-		} else {
+} else {
-	if(world.getType(tmpVector+shape[0]) != EMPTY) {
+if(world.getType(tmpVector+shape[0]) != EMPTY) {
-	reached = position + unitVector*(i-1);
+reached = position + unitVector*(i-1);
-	collided = true;
+collided = true;
-				this->velocity.y *= -0.3;
+this->velocity.y *= -0.3;
-				this->velocity.x *= 0.7;
+this->velocity.x *= 0.7;
-				if(abs(this->velocity.x) < minVelocity && (abs(this->velocity.y) < minVelocity)) {
+if(abs(this->velocity.x) < minVelocity && (abs(this->velocity.y) < minVelocity)) {
-		this->inAir = false;
+this->inAir = false;
-					this->velocity = Vector(0,0);
+this->velocity = Vector(0,0);
-				}
+}
-	break;
+break;
-			}
+}
 }
-		if(velocity.x > 0) {
+if(velocity.x > 0) {
-	if(world.getType(tmpVector+shape[1]) != EMPTY) {
+if(world.getType(tmpVector+shape[1]) != EMPTY) {
-	reached = position + unitVector*(i-1);
+reached = position + unitVector*(i-1);
-	collided = true;
+collided = true;
-				this->velocity.x *= -0.6;
+this->velocity.x *= -0.6;
-				this->velocity.y *= 0.7;
+this->velocity.y *= 0.7;
-				if(abs(this->velocity.x) < minVelocity && (abs(this->velocity.y) < minVelocity)) {
+if(abs(this->velocity.x) < minVelocity && (abs(this->velocity.y) < minVelocity)) {
-		this->inAir = false;
+this->inAir = false;
-					this->velocity = Vector(0,0);
+this->velocity = Vector(0,0);
-				}
+}
-	break;
+break;
-			}
+}
-		} else {
+} else {
-	if(world.getType(tmpVector+shape[3]) != EMPTY) {
+if(world.getType(tmpVector+shape[3]) != EMPTY) {
-	reached = position + unitVector*(i-1);
+reached = position + unitVector*(i-1);
-	collided = true;
+collided = true;
-				this->velocity.x *= -0.6;
+this->velocity.x *= -0.6;
-				this->velocity.y *= 0.7;
+this->velocity.y *= 0.7;
-				if(abs(this->velocity.x) < minVelocity && (abs(this->velocity.y) < minVelocity)) {
+if(abs(this->velocity.x) < minVelocity && (abs(this->velocity.y) < minVelocity)) {
-		this->inAir = false;
+this->inAir = false;
-					this->velocity = Vector(0,0);
+this->velocity = Vector(0,0);
-				}
+}
-	break;
+break;
-			}
+}
 }*/
-		// This col. det. doesn't let worms inside the ground, but on the other hand the worms get often stuck
+// This col. det. doesn't let worms inside the ground, but on the other hand the worms get often stuck
-		/*if(world.getType(tmpVector+shape[0]) != EMPTY || (world.getType(tmpVector+shape[2]) != EMPTY)) {
+/*if(world.getType(tmpVector+shape[0]) != EMPTY || (world.getType(tmpVector+shape[2]) != EMPTY)) {
 reached = position + unitVector*(i-1);
 collided = true;
-			this->velocity.y *= -0.3;
+this->velocity.y *= -0.3;
-			if(abs(this->velocity.x) < minVelocity && (abs(this->velocity.y) < minVelocity)) {
+if(abs(this->velocity.x) < minVelocity && (abs(this->velocity.y) < minVelocity)) {
-	this->inAir = false;
+this->inAir = false;
-				this->velocity = Vector(0,0);
+this->velocity = Vector(0,0);
-			}
+}
 break;
 }
-		if(world.getType(tmpVector+shape[1]) != EMPTY || (world.getType(tmpVector+shape[3]) != EMPTY)) {
+if(world.getType(tmpVector+shape[1]) != EMPTY || (world.getType(tmpVector+shape[3]) != EMPTY)) {
 reached = position + unitVector*(i-1);
 collided = true;
-			this->velocity.x *= -0.6;
+this->velocity.x *= -0.6;
-			if(abs(this->velocity.x) < minVelocity && (abs(this->velocity.y) < minVelocity)) {
+if(abs(this->velocity.x) < minVelocity && (abs(this->velocity.y) < minVelocity)) {
-	this->inAir = false;
+this->inAir = false;
-				this->velocity = Vector(0,0);
+this->velocity = Vector(0,0);
-			}
+}
 break;
-		}*/
+}*/
-			//Engine::log(DEBUG, "physics.update_position") << "didnt hit";
+//Engine::log(DEBUG, "physics.update_position") << "didnt hit";
 }
 // In case of some float error check the final coordinate
 if(!collided) {
 if(world.getType(newPosition+shape[0]) != EMPTY || (world.getType(newPosition+shape[1]) != EMPTY)
-			|| (world.getType(newPosition+shape[2]) != EMPTY) || (world.getType(newPosition+shape[3]) != EMPTY)) {
+|| (world.getType(newPosition+shape[2]) != EMPTY) || (world.getType(newPosition+shape[3]) != EMPTY)) {
-			Engine::log(DEBUG, "physics.update_position") << "didnt hit";
+Engine::log(DEBUG, "physics.update_position") << "didnt hit";
-			// There was error, and there is ground
+// There was error, and there is ground
 //newPosition = tmpVector;
 } else {
 // This means everything was ok, so no need to do anything
 }
 } else {
 /**
 * Computes hitten wall's normal. Calculated from 3*3 grid
 */
 Vector PhysicsWorld::getNormal (Vector hitPoint, Vector prevPoint) {
-	// Search free points with bfs and put them to vector
+// Search free points with bfs and put them to vector
-	std::vector<Vector> frees;
+std::vector<Vector> frees;
-	Vector hit = Vector((int)hitPoint.x, (int)hitPoint.y);
+Vector hit = Vector((int)hitPoint.x, (int)hitPoint.y);
-	Vector prev = Vector((int)prevPoint.x, (int)prevPoint.y);
+Vector prev = Vector((int)prevPoint.x, (int)prevPoint.y);
-	assert(hit != prev);
+assert(hit != prev);
-	int dirIdx = getDirectionIndex(prev-hit);
+int dirIdx = getDirectionIndex(prev-hit);
-	float tmp1 = hit.x-prev.x;
+float tmp1 = hit.x-prev.x;
-	float tmp2 = hit.y-prev.y;
+float tmp2 = hit.y-prev.y;
 //    Engine::log(DEBUG, "physics.getNormal ") << dirIdx << " " << tmp1 << " " << tmp2;
-	for(int i = 1; i <= 2; i++) {
+for(int i = 1; i <= 2; i++) {
-		if(getType(hit+DIRECTIONS[(dirIdx+i) % 8]) == EMPTY)
+if(getType(hit+DIRECTIONS[(dirIdx+i) % 8]) == EMPTY)
-			frees.push_back(DIRECTIONS[(dirIdx+i) % 8]);
+frees.push_back(DIRECTIONS[(dirIdx+i) % 8]);
-		else
+else
-			break;
+break;
-	}
+}
-	for(int i = 1; i <= 2; i++) {
+for(int i = 1; i <= 2; i++) {
-		if(getType(hit+DIRECTIONS[(dirIdx-i+8) % 8]) == EMPTY)
+if(getType(hit+DIRECTIONS[(dirIdx-i+8) % 8]) == EMPTY)
-			frees.push_back(DIRECTIONS[(dirIdx-i+8) % 8]);
+frees.push_back(DIRECTIONS[(dirIdx-i+8) % 8]);
-		else
+else
-			break;
+break;
-	}
+}
 frees.push_back(DIRECTIONS[dirIdx]);
-	Vector normal(0,0);
+Vector normal(0,0);
-	for(unsigned int i = 0; i < frees.size(); i++) {
+for(unsigned int i = 0; i < frees.size(); i++) {
-		normal += frees[i];
+normal += frees[i];
-	}
+}
 Engine::log(DEBUG, "physics.getNormal ") << "normal: " << normal;
-	return normal;
+return normal;
 }
 /**
 * Bounces from straight wall in any direction.
 * Direction given as normal of that wall
 Vector nprojection = normal*(velocity * normal) / (normal.length()*normal.length());
 velocity = tprojection - nprojection;
 }
 /*bool PhysicsWorld::collided (Vector oldPos, Vector newPos) {
-	return false;
+return false;
 }*/
 /**
 * Integrates given force over time and stores new position to
 * posAfterTick and new velocity to velAfterTick.
 // XXX: dt is not used? It is here because we might want forces to
 // apply longer than one tick in the future.
 // Add applied force to the queue
 forceq.push(force);
-	this->inAir = true;
+this->inAir = true;
 }
 void PhysicsObject::changeAim(float da) {
 this->aim += da;
 std::vector<Vector>& PhysicsObject::getShape () {
 return this->shape;
 }
 void PhysicsObject::setShape (std::vector<Vector> shape) {
-	this->shape = shape;
+this->shape = shape;
 }
 void PhysicsObject::tick () {
 this->updatePosition();
 }
 int midx = rand()%(int)dimensions.x;
 int midy = rand()%(int)dimensions.y;
 int range = rand()%(max_range-min_range)+min_range;
 // put first circle in the middle of the cave
-		// so that we have some area we can certainly spawn into
+// so that we have some area we can certainly spawn into
-		if(i == 0) {
+if(i == 0) {
-			midx = dimensions.x/2;
+midx = dimensions.x/2;
-			midy = dimensions.y/2;
+midy = dimensions.y/2;
-			range = 150;
+range = 150;
-		}
+}
 TerrainType type = EMPTY;
 if(rand()%rock_rarity == 0) {
 type = ROCK;
 }
 /**
 * Returns terrainType in given tile. ROCK if tile is out of area
 * @param pos - coordinate of tile
 */
+TerrainType PhysicsWorld::getType(int x, int y) const {
+if(x < 0 || y < 0 || x >= dimensions.x || y >= dimensions.y) {
+return ROCK;
+}
+return terrain[x][y];
+}
 TerrainType PhysicsWorld::getType(Vector pos) const {
 int x = (int)(pos.x);
 int y = (int)(pos.y);
-if(x < 0 || y < 0 || x >= dimensions.x || y >= dimensions.y) {
+return getType(x, y);
-return ROCK;
+}
-}
-return terrain[x][y];
+/**
-}
+* Removes ground from given circle. ROCK is not removed.
+* @param (x, y) or pos - center of circle.
+* @param r - radius of circle
+*/
+void PhysicsWorld::removeGround(int x, int y, float r) {
+for(int i = x-(int)r; i < x+r; i++) {
+for(int j = y-(int)r; j < y+r; j++) {
+if(getType(i, j) != ROCK) {
+if((i-x)*(i-x)+(j-y)*(j-y) < r*r) {
+// Safe because getType returns ROCK if tile is out of bounds
+terrain[i][j] = EMPTY;
+}
+}
+}
+}
+}
+void PhysicsWorld::removeGround(Vector pos, float r) {
+removeGround((int)pos.x, (int)pos.y, r);
+}

changeset 112	1b9ad61bdf2d
parent 111	d90977611fee
child 114	71f7e9d3d052