julian/EndlessRoll
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Redid some collision-detection - no new features

Browse Source
This commit is contained in:
julian
2018-06-29 16:24:39 +02:00
parent 292c6cf08f
commit ed3a54af10
17 changed files with 321 additions and 296 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
app/src/main/assets/levelpacks/Grasslands.xml
View File

@ -169,7 +169,7 @@
</obstacles>
<stars class="java.util.ArrayList">
<positionData x="2.8000035" y="-0.77999914"/>
<positionData x="11.243364" y="-0.43999982"/>
<positionData x="11.210031" y="-0.47333312"/>
<positionData x="16.21668" y="0.34666675"/>
</stars>
<energy x="19.086668" y="-0.81333315"/>

36
app/src/main/java/de/frajul/endlessroll/entities/collision/CircleTriangleCollisionDetector.java
View File

@ -9,7 +9,7 @@ import de.frajul.endlessroll.entities.collision.geometry.Triangle;
*/
public class CircleTriangleCollisionDetector {
public boolean circleTriangleCollision(Circle circle, Triangle triangle) {
public boolean isCircleTriangleCollision(Circle circle, Triangle triangle) {
if (circleIntersectingWithTriangleVertices(circle, triangle))
return true;
@ -22,18 +22,18 @@ public class CircleTriangleCollisionDetector {
}
private boolean circleIntersectingWithTriangleEdges(Circle circle, Triangle triangle) {
Vector edge1 = triangle.getVertex1().vectorTo(triangle.getVertex2());
Vector edge2 = triangle.getVertex2().vectorTo(triangle.getVertex3());
Vector edge3 = triangle.getVertex3().vectorTo(triangle.getVertex1());
Vector edge1 = triangle.getBottomRightVertex().vectorTo(triangle.getTopRightVertex());
Vector edge2 = triangle.getTopRightVertex().vectorTo(triangle.getBottomLeftVertex());
Vector edge3 = triangle.getBottomLeftVertex().vectorTo(triangle.getBottomRightVertex());
boolean intersectingWithEdge1 = circleIntersectingWithTriangleEdge(circle, triangle.getVertex1(), edge1);
boolean intersectingWithEdge2 = circleIntersectingWithTriangleEdge(circle, triangle.getVertex2(), edge2);
boolean intersectingWithEdge3 = circleIntersectingWithTriangleEdge(circle, triangle.getVertex3(), edge3);
boolean intersectingWithEdge1 = circleIntersectingWithTriangleEdge(circle, triangle.getBottomRightVertex(), edge1);
boolean intersectingWithEdge2 = circleIntersectingWithTriangleEdge(circle, triangle.getTopRightVertex(), edge2);
boolean intersectingWithEdge3 = circleIntersectingWithTriangleEdge(circle, triangle.getBottomLeftVertex(), edge3);
return intersectingWithEdge1 || intersectingWithEdge2 || intersectingWithEdge3;
}
private boolean circleIntersectingWithTriangleEdge(Circle circle, Vector vertex, Vector edge) {
Vector vertexToCenter = vertex.vectorTo(circle.getCenter());
Vector vertexToCenter = vertex.vectorTo(circle.getPosition());
Vector kVector = new Vector(vertexToCenter).mul(edge);
float k = kVector.x + kVector.y;
@ -49,12 +49,12 @@ public class CircleTriangleCollisionDetector {
}
private boolean circleCenterInsideTriangle(Circle circle, Triangle triangle) {
Vector vertex1To2 = triangle.getVertex1().vectorTo(triangle.getVertex2());
Vector vertex2To3 = triangle.getVertex2().vectorTo(triangle.getVertex3());
Vector vertex3To1 = triangle.getVertex3().vectorTo(triangle.getVertex1());
Vector vertex1ToCenter = triangle.getVertex1().vectorTo(circle.getCenter());
Vector vertex2ToCenter = triangle.getVertex2().vectorTo(circle.getCenter());
Vector vertex3ToCenter = triangle.getVertex3().vectorTo(circle.getCenter());
Vector vertex1To2 = triangle.getBottomRightVertex().vectorTo(triangle.getTopRightVertex());
Vector vertex2To3 = triangle.getTopRightVertex().vectorTo(triangle.getBottomLeftVertex());
Vector vertex3To1 = triangle.getBottomLeftVertex().vectorTo(triangle.getBottomRightVertex());
Vector vertex1ToCenter = triangle.getBottomRightVertex().vectorTo(circle.getPosition());
Vector vertex2ToCenter = triangle.getTopRightVertex().vectorTo(circle.getPosition());
Vector vertex3ToCenter = triangle.getBottomLeftVertex().vectorTo(circle.getPosition());
boolean centerInsideV1V2 = vertex1To2.y * vertex1ToCenter.x - vertex1To2.x * vertex1ToCenter.y < 0;
boolean centerInsideV2V3 = vertex2To3.y * vertex2ToCenter.x - vertex2To3.x * vertex2ToCenter.y < 0;
@ -64,14 +64,14 @@ public class CircleTriangleCollisionDetector {
}
private boolean circleIntersectingWithTriangleVertices(Circle circle, Triangle triangle) {
boolean intersectingWithVertex1 = circleIntersectingWithTriangleVertex(circle, triangle.getVertex1());
boolean intersectingWithVertex2 = circleIntersectingWithTriangleVertex(circle, triangle.getVertex2());
boolean intersectingWithVertex3 = circleIntersectingWithTriangleVertex(circle, triangle.getVertex3());
boolean intersectingWithVertex1 = circleIntersectingWithTriangleVertex(circle, triangle.getBottomRightVertex());
boolean intersectingWithVertex2 = circleIntersectingWithTriangleVertex(circle, triangle.getTopRightVertex());
boolean intersectingWithVertex3 = circleIntersectingWithTriangleVertex(circle, triangle.getBottomLeftVertex());
return intersectingWithVertex1 || intersectingWithVertex2 || intersectingWithVertex3;
}
private boolean circleIntersectingWithTriangleVertex(Circle circle, Vector vertex) {
Vector centerToVertex = circle.getCenter().vectorTo(vertex);
Vector centerToVertex = circle.getPosition().vectorTo(vertex);
return centerToVertex.length() <= circle.getRadius();
}

180
app/src/main/java/de/frajul/endlessroll/entities/collision/CollisionDetector.java
View File

@ -5,8 +5,10 @@ import de.frajul.endlessroll.entities.Entity;
import de.frajul.endlessroll.entities.Player;
import de.frajul.endlessroll.entities.collision.collisionData.EntityCollisionData;
import de.frajul.endlessroll.entities.collision.geometry.Circle;
import de.frajul.endlessroll.entities.collision.geometry.Geometry;
import de.frajul.endlessroll.entities.collision.geometry.Quad;
import de.frajul.endlessroll.entities.collision.geometry.Triangle;
import de.frajul.endlessroll.entities.tileLists.Tile;
/**
* Created by Julian on 01.12.2015.
@ -19,7 +21,35 @@ public class CollisionDetector {
triangleDetector = new CircleTriangleCollisionDetector();
}
public boolean isPointQuadCollision(Vector point, Quad quad) {
public boolean isCollision(Geometry g1, Geometry g2) {
if (g1 instanceof Triangle) {
if (g2 instanceof Triangle)
return isTriangleTriangleCollision((Triangle) g1, (Triangle) g2);
if (g2 instanceof Quad)
return isQuadTriangleCollision((Quad) g2, (Triangle) g1);
if (g2 instanceof Circle)
return isCircleTriangleCollision((Circle) g2, (Triangle) g1);
}
if (g1 instanceof Quad) {
if (g2 instanceof Triangle)
return isQuadTriangleCollision((Quad) g1, (Triangle) g2);
if (g2 instanceof Quad)
return isQuadQuadCollision((Quad) g1, (Quad) g2);
if (g2 instanceof Circle)
return isCircleQuadCollision((Circle) g2, (Quad) g1);
}
if (g1 instanceof Circle) {
if (g2 instanceof Triangle)
return isCircleTriangleCollision((Circle) g1, (Triangle) g2);
if (g2 instanceof Quad)
return isCircleQuadCollision((Circle) g1, (Quad) g2);
if (g2 instanceof Circle)
return isCircleCircleCollision((Circle) g1, (Circle) g2);
}
return false;
}
public boolean isPointInQuad(Vector point, Quad quad) {
if (point.getX() >= quad.getLeftEdge() && point.getX() <= quad.getRightEdge()) {
if (point.getY() >= quad.getBottomEdge() && point.getY() <= quad.getTopEdge()) {
return true;
@ -29,13 +59,13 @@ public class CollisionDetector {
}
public boolean isCircleCircleCollision(Circle c1, Circle c2) {
float distance = Math.abs(c1.getCenter().vectorTo(c2.getCenter()).length());
float distance = Math.abs(c1.getPosition().vectorTo(c2.getPosition()).length());
float radiusSum = c1.getRadius() + c2.getRadius();
return distance < radiusSum;
}
public boolean isCircleQuadCollision(Circle circle, Quad quad) {
Vector distance = circle.getCenter().vectorTo(quad.getPosition());
Vector distance = circle.getPosition().vectorTo(quad.getPosition());
distance.x = Math.abs(distance.x);
distance.y = Math.abs(distance.y);
@ -56,7 +86,7 @@ public class CollisionDetector {
}
public boolean isCircleTriangleCollision(Circle circle, Triangle triangle) {
return triangleDetector.circleTriangleCollision(circle, triangle);
return triangleDetector.isCircleTriangleCollision(circle, triangle);
}
public boolean isQuadQuadCollision(Quad q1, Quad q2) {
@ -69,6 +99,28 @@ public class CollisionDetector {
return true;
}
public boolean isTriangleTriangleCollision(Triangle triangle1, Triangle triangle2) {
boolean triangle1Vertex1InTriangle2 = isVertexInTriangle(triangle1.getBottomRightVertex(), triangle2);
if (triangle1Vertex1InTriangle2)
return true;
boolean triangle1Vertex2InTriangle2 = isVertexInTriangle(triangle1.getTopRightVertex(), triangle2);
if (triangle1Vertex2InTriangle2)
return true;
boolean triangle1Vertex3InTriangle2 = isVertexInTriangle(triangle1.getBottomLeftVertex(), triangle2);
if (triangle1Vertex3InTriangle2)
return true;
boolean triangle2Vertex1InTriangle1 = isVertexInTriangle(triangle2.getBottomRightVertex(), triangle1);
if (triangle2Vertex1InTriangle1)
return true;
boolean triangle2Vertex2InTriangle1 = isVertexInTriangle(triangle2.getTopRightVertex(), triangle1);
if (triangle2Vertex2InTriangle1)
return true;
boolean triangle2Vertex3InTriangle1 = isVertexInTriangle(triangle2.getBottomLeftVertex(), triangle1);
if (triangle2Vertex3InTriangle1)
return true;
return false;
}
public boolean isQuadTriangleCollision(Quad quad, Triangle triangle) {
boolean quadVertex1InTriangle = isVertexInTriangle(
new Vector(quad.getLeftEdge(), quad.getTopEdge()), triangle);
@ -86,61 +138,57 @@ public class CollisionDetector {
new Vector(quad.getLeftEdge(), quad.getBottomEdge()), triangle);
if (quadVertex4InTriangle)
return true;
boolean triangleVertex1InQuad = isVertexInQuad(triangle.getVertex1(), quad);
boolean triangleVertex1InQuad = isPointInQuad(triangle.getBottomRightVertex(), quad);
if (triangleVertex1InQuad)
return true;
boolean triangleVertex2InQuad = isVertexInQuad(triangle.getVertex2(), quad);
boolean triangleVertex2InQuad = isPointInQuad(triangle.getTopRightVertex(), quad);
if (triangleVertex2InQuad)
return true;
boolean triangleVertex3InQuad = isVertexInQuad(triangle.getVertex3(), quad);
boolean triangleVertex3InQuad = isPointInQuad(triangle.getBottomLeftVertex(), quad);
if (triangleVertex3InQuad)
return true;
return false;
}
public boolean isTriangleTriangleCollision(Triangle triangle1, Triangle triangle2) {
boolean triangle1Vertex1InTriangle2 = isVertexInTriangle(triangle1.getVertex1(), triangle2);
if (triangle1Vertex1InTriangle2)
return true;
boolean triangle1Vertex2InTriangle2 = isVertexInTriangle(triangle1.getVertex2(), triangle2);
if (triangle1Vertex2InTriangle2)
return true;
boolean triangle1Vertex3InTriangle2 = isVertexInTriangle(triangle1.getVertex3(), triangle2);
if (triangle1Vertex3InTriangle2)
return true;
boolean triangle2Vertex1InTriangle1 = isVertexInTriangle(triangle2.getVertex1(), triangle1);
if (triangle2Vertex1InTriangle1)
return true;
boolean triangle2Vertex2InTriangle1 = isVertexInTriangle(triangle2.getVertex2(), triangle1);
if (triangle2Vertex2InTriangle1)
return true;
boolean triangle2Vertex3InTriangle1 = isVertexInTriangle(triangle2.getVertex3(), triangle1);
if (triangle2Vertex3InTriangle1)
return true;
return false;
}
private boolean isVertexInTriangle(Vector vertex, Triangle triangle) {
Vector vertex1To2 = triangle.getVertex1().vectorTo(triangle.getVertex2());
Vector vertex2To3 = triangle.getVertex2().vectorTo(triangle.getVertex3());
Vector vertex3To1 = triangle.getVertex3().vectorTo(triangle.getVertex1());
Vector vertex1ToCenter = triangle.getVertex1().vectorTo(vertex);
Vector vertex2ToCenter = triangle.getVertex2().vectorTo(vertex);
Vector vertex3ToCenter = triangle.getVertex3().vectorTo(vertex);
boolean centerInsideV1V2 = vertex1To2.y * vertex1ToCenter.x - vertex1To2.x * vertex1ToCenter.y < 0;
boolean centerInsideV2V3 = vertex2To3.y * vertex2ToCenter.x - vertex2To3.x * vertex2ToCenter.y < 0;
boolean centerInsideV3V1 = vertex3To1.y * vertex3ToCenter.x - vertex3To1.x * vertex3ToCenter.y < 0;
return centerInsideV1V2 && centerInsideV2V3 && centerInsideV3V1;
if (!isPointInQuad(vertex, triangle))
return false;
float gradient = triangle.getGradient();
float maxVertexY = vertex.getX() * gradient + triangle.getBottomEdge();
return vertex.getY() <= maxVertexY;
}
private boolean isVertexInQuad(Vector vertex, Quad quad) {
return vertex.getX() >= quad.getLeftEdge() && vertex.getX() <= quad.getRightEdge() && vertex
.getY() >= quad.getBottomEdge() && vertex.getY() <= quad.getTopEdge();
public EntityCollisionData playerTerrainCollision(Player player, Tile terrainTile) {
Circle circle = new Circle(player);
if (circle.getTopEdge() < terrainTile.getTopEdge()) {
float xDistance = Math.abs(circle.getPosition().x - terrainTile.getPosition().x);
if (xDistance < circle.getRadius() + terrainTile.getWidth() / 2)
return new EntityCollisionData(terrainTile, Edge.BOTTOM);
}
if (isCircleQuadCollision(circle, terrainTile)) {
Edge edge = circleQuadCollisionEdge(circle, player.getMovement(), terrainTile,
terrainTile.getMovement());
return new EntityCollisionData(terrainTile, edge);
}
return new EntityCollisionData(null, null);
}
public EntityCollisionData playerCeilingCollision(Player player, Tile ceilingTile) {
Circle circle = new Circle(player);
if (circle.getBottomEdge() > ceilingTile.getBottomEdge()) {
float xDistance = Math.abs(circle.getPosition().x - ceilingTile.getPosition().x);
if (xDistance < circle.getRadius() + ceilingTile.getWidth() / 2)
return new EntityCollisionData(ceilingTile, Edge.TOP);
}
if (isCircleQuadCollision(circle, ceilingTile)) {
Edge edge = circleQuadCollisionEdge(circle, player.getMovement(), ceilingTile,
ceilingTile.getMovement());
return new EntityCollisionData(ceilingTile, edge);
}
return new EntityCollisionData(null, null);
}
public EntityCollisionData playerEntityCollision(Player player, Entity entity) {
Circle circle = new Circle(player);
@ -156,10 +204,10 @@ public class CollisionDetector {
private Edge circleQuadCollisionEdge(Circle circle, Vector circleMovement, Quad quad, Vector quadMovement) {
boolean circleFullyInsideQuad = false;
if (circle.getCenter().getX() + circle.getRadius() <= quad.getRightEdge() && circle
.getCenter().getX() - circle.getRadius() >= quad.getLeftEdge()) {
if (circle.getCenter().getY() + circle.getRadius() <= quad.getTopEdge() && circle
.getCenter().getY() - circle.getRadius() >= quad.getBottomEdge()) {
if (circle.getPosition().getX() + circle.getRadius() <= quad.getRightEdge() && circle
.getPosition().getX() - circle.getRadius() >= quad.getLeftEdge()) {
if (circle.getPosition().getY() + circle.getRadius() <= quad.getTopEdge() && circle
.getPosition().getY() - circle.getRadius() >= quad.getBottomEdge()) {
circleFullyInsideQuad = true;
}
}
@ -172,30 +220,30 @@ public class CollisionDetector {
Vector relativeMovement = new Vector(circleMovement).translate(quadMovement.negate());
Edge edge = Edge.NONE;
if (circle.getCenter().getY() + circle.getRadius() >= quad.getTopEdge())
if (circle.getPosition().getY() + circle.getRadius() >= quad.getTopEdge())
edge = Edge.TOP;
else if (circle.getCenter().getY() - circle.getRadius() <= quad.getBottomEdge())
else if (circle.getPosition().getY() - circle.getRadius() <= quad.getBottomEdge())
edge = Edge.BOTTOM;
if (circle.getCenter().getX() - circle.getRadius() <= quad.getLeftEdge()) {
if (circle.getPosition().getX() - circle.getRadius() <= quad.getLeftEdge()) {
if (edge != Edge.NONE) {
if (edge == Edge.TOP) {
float m = -1;
float t = quad.getTopEdge() - m * quad.getLeftEdge();
if (circle.getCenter().getY() >= m * circle.getCenter().getX() + t)
if (circle.getPosition().getY() >= m * circle.getPosition().getX() + t)
edge = Edge.TOP;
else
edge = Edge.LEFT;
} else if (edge == Edge.BOTTOM) {
float m = 1;
float t = quad.getBottomEdge() - m * quad.getLeftEdge();
if (circle.getCenter().getY() <= m * circle.getCenter().getX() + t)
if (circle.getPosition().getY() <= m * circle.getPosition().getX() + t)
edge = Edge.BOTTOM;
else
edge = Edge.LEFT;
}
} else
edge = Edge.LEFT;
} else if (circle.getCenter().getX() + circle.getRadius() >= quad.getRightEdge()) {
} else if (circle.getPosition().getX() + circle.getRadius() >= quad.getRightEdge()) {
if (edge != Edge.NONE) {
if (edge == Edge.TOP) {
//This movement check is because if player falls with too much speed on topLeft Vertex, sometimes RIGHT-Edge is returned
@ -204,7 +252,7 @@ public class CollisionDetector {
} else {
float m = 1;
float t = quad.getTopEdge() - m * quad.getRightEdge();
if (circle.getCenter().getY() >= m * circle.getCenter().getX() + t)
if (circle.getPosition().getY() >= m * circle.getPosition().getX() + t)
edge = Edge.TOP;
else
edge = Edge.RIGHT;
@ -212,7 +260,7 @@ public class CollisionDetector {
} else if (edge == Edge.BOTTOM) {
float m = -1;
float t = quad.getBottomEdge() - m * quad.getRightEdge();
if (circle.getCenter().getY() <= m * circle.getCenter().getX() + t)
if (circle.getPosition().getY() <= m * circle.getPosition().getX() + t)
edge = Edge.BOTTOM;
else
edge = Edge.RIGHT;
@ -227,7 +275,7 @@ public class CollisionDetector {
Vector relativeMovement = new Vector(circleMovement).translate(quadMovement.negate());
float m = relativeMovement.getY() / relativeMovement.getX();
float t = circle.getCenter().getY() - m * circle.getCenter().getX();
float t = circle.getPosition().getY() - m * circle.getPosition().getX();
float yAtLeftEdge = m * quad.getLeftEdge() + t;
boolean touchingLeftEdge = yAtLeftEdge < quad.getTopEdge() && yAtLeftEdge > quad
@ -244,8 +292,8 @@ public class CollisionDetector {
.getRightEdge();
if (relativeMovement.getX() == 0) {
if (circle.getCenter().getX() - circle.getRadius() <= quad.getRightEdge() && circle
.getCenter().getX() + circle.getRadius() >= quad.getLeftEdge()) {
if (circle.getPosition().getX() - circle.getRadius() <= quad.getRightEdge() && circle
.getPosition().getX() + circle.getRadius() >= quad.getLeftEdge()) {
touchingTopEdge = true;
touchingBottomEdge = true;
}
@ -254,21 +302,21 @@ public class CollisionDetector {
// CORNERS BELONGING TO TOP / BOTTOM EDGES
if (touchingLeftEdge) {
if (touchingRightEdge) {
if (circle.getCenter().getX() <= quad.getPosition().getX())
if (circle.getPosition().getX() <= quad.getPosition().getX())
return Edge.LEFT;
return Edge.RIGHT;
} else if (touchingTopEdge) {
// Normale through vertex
float mn = -1 / m;
float tn = quad.getTopEdge() - mn * quad.getLeftEdge();
if (circle.getCenter().getY() < mn * circle.getCenter().getX() + tn)
if (circle.getPosition().getY() < mn * circle.getPosition().getX() + tn)
return Edge.LEFT;
return Edge.TOP;
} else if (touchingBottomEdge) {
// Normale through vertex
float mn = -1 / m;
float tn = quad.getBottomEdge() - mn * quad.getLeftEdge();
if (circle.getCenter().getY() > mn * circle.getCenter().getX() + tn)
if (circle.getPosition().getY() > mn * circle.getPosition().getX() + tn)
return Edge.LEFT;
return Edge.BOTTOM;
} else {
@ -279,14 +327,14 @@ public class CollisionDetector {
// Normale through vertex
float mn = -1 / m;
float tn = quad.getTopEdge() - mn * quad.getRightEdge();
if (circle.getCenter().getY() < mn * circle.getCenter().getX() + tn)
if (circle.getPosition().getY() < mn * circle.getPosition().getX() + tn)
return Edge.RIGHT;
return Edge.TOP;
} else if (touchingBottomEdge) {
// Normale through vertex
float mn = -1 / m;
float tn = quad.getBottomEdge() - mn * quad.getRightEdge();
if (circle.getCenter().getY() > mn * circle.getCenter().getX() + tn)
if (circle.getPosition().getY() > mn * circle.getPosition().getX() + tn)
return Edge.RIGHT;
return Edge.BOTTOM;
} else {
@ -294,7 +342,7 @@ public class CollisionDetector {
}
} else if (touchingTopEdge) {
if (touchingBottomEdge) {
if (circle.getCenter().getY() >= quad.getPosition().getY())
if (circle.getPosition().getY() >= quad.getPosition().getY())
return Edge.TOP;
return Edge.BOTTOM;
} else {

2
app/src/main/java/de/frajul/endlessroll/entities/collision/CollisionManager.java
View File

@ -57,7 +57,7 @@ public class CollisionManager {
private void checkCeilingCollision(EntityCollisionData data) {
checkEntityCollision(data);
if (data.getEdge() == Edge.RIGHT || data.getEdge() == Edge.LEFT)
if (data.getEdge() != Edge.BOTTOM)
game.onGameOver(true);
}

39
app/src/main/java/de/frajul/endlessroll/entities/collision/geometry/Circle.java
View File

@ -7,7 +7,7 @@ import de.frajul.endlessroll.entities.collision.CollisionDetector;
/**
* Created by Julian on 01.12.2015.
*/
public class Circle implements Geometry {
public class Circle extends Geometry {
private Vector center;
private float radius;
@ -21,7 +21,27 @@ public class Circle implements Geometry {
this.radius = radius;
}
public Vector getCenter() {
@Override
public float getRightEdge() {
return center.x + radius;
}
@Override
public float getLeftEdge() {
return center.x - radius;
}
@Override
public float getTopEdge() {
return center.y + radius;
}
@Override
public float getBottomEdge() {
return center.y - radius;
}
public Vector getPosition() {
return center;
}
@ -33,19 +53,4 @@ public class Circle implements Geometry {
this.radius = radius;
}
@Override
public boolean isCollisionWithCircle(Circle circle, CollisionDetector collisionDetector){
return collisionDetector.isCircleCircleCollision(this, circle);
}
@Override
public boolean isCollisionWithQuad(Quad quad, CollisionDetector collisionDetector){
return collisionDetector.isCircleQuadCollision(this, quad);
}
@Override
public boolean isCollisionWithTriangle(Triangle triangle, CollisionDetector collisionDetector){
return collisionDetector.isCircleTriangleCollision(this, triangle);
}
}

11
app/src/main/java/de/frajul/endlessroll/entities/collision/geometry/Geometry.java
View File

@ -1,17 +1,16 @@
package de.frajul.endlessroll.entities.collision.geometry;
import de.frajul.endlessroll.entities.collision.CollisionDetector;
/**
* Created by Julian on 28.02.2016.
*/
public interface Geometry {
public abstract class Geometry {
boolean isCollisionWithCircle(Circle circle, CollisionDetector collisionDetector);
public abstract float getTopEdge();
boolean isCollisionWithQuad(Quad quad, CollisionDetector collisionDetector);
public abstract float getBottomEdge();
boolean isCollisionWithTriangle(Triangle triangle, CollisionDetector collisionDetector);
public abstract float getRightEdge();
public abstract float getLeftEdge();
}

22
app/src/main/java/de/frajul/endlessroll/entities/collision/geometry/Quad.java
View File

@ -1,12 +1,11 @@
package de.frajul.endlessroll.entities.collision.geometry;
import de.frajul.endlessroll.data.Vector;
import de.frajul.endlessroll.entities.collision.CollisionDetector;
/**
* Created by Julian on 01.12.2015.
*/
public class Quad implements Geometry {
public class Quad extends Geometry {
protected Vector position;
protected float width, height;
@ -17,18 +16,22 @@ public class Quad implements Geometry {
this.height = height;
}
@Override
public float getRightEdge() {
return position.x + width / 2;
}
@Override
public float getLeftEdge() {
return position.x - width / 2;
}
@Override
public float getTopEdge() {
return position.y + height / 2;
}
@Override
public float getBottomEdge() {
return position.y - height / 2;
}
@ -57,19 +60,4 @@ public class Quad implements Geometry {
this.height = height;
}
@Override
public boolean isCollisionWithCircle(Circle circle, CollisionDetector collisionDetector) {
return collisionDetector.isCircleQuadCollision(circle, this);
}
@Override
public boolean isCollisionWithQuad(Quad quad, CollisionDetector collisionDetector) {
return collisionDetector.isQuadQuadCollision(this, quad);
}
@Override
public boolean isCollisionWithTriangle(Triangle triangle, CollisionDetector collisionDetector) {
return collisionDetector.isQuadTriangleCollision(this, triangle);
}
}

50
app/src/main/java/de/frajul/endlessroll/entities/collision/geometry/Triangle.java
View File

@ -1,61 +1,31 @@
package de.frajul.endlessroll.entities.collision.geometry;
import de.frajul.endlessroll.data.Vector;
import de.frajul.endlessroll.entities.collision.CollisionDetector;
import de.frajul.endlessroll.entities.tools.Ramp;
/**
* Created by Julian on 01.12.2015.
*/
public class Triangle implements Geometry {
//bottom right
private Vector vertex1;
//top right
private Vector vertex2;
//bottom left
private Vector vertex3;
public class Triangle extends Quad {
public Triangle(Ramp ramp) {
Vector vertex1 = new Vector(ramp.getRightEdge(), ramp.getBottomEdge());
Vector vertex2 = new Vector(ramp.getRightEdge(), ramp.getTopEdge());
Vector vertex3 = new Vector(ramp.getLeftEdge(), ramp.getBottomEdge());
this.vertex1 = vertex1;
this.vertex2 = vertex2;
this.vertex3 = vertex3;
super(ramp.getPosition(), ramp.getWidth(), ramp.getHeight());
}
public Triangle(Vector vertex1, Vector vertex2, Vector vertex3) {
this.vertex1 = vertex1;
this.vertex2 = vertex2;
this.vertex3 = vertex3;
public float getGradient() {
return super.getHeight() / super.getWidth();
}
public Vector getVertex1() {
return vertex1;
public Vector getBottomRightVertex() {
return new Vector(getRightEdge(), getBottomEdge());
}
public Vector getVertex2() {
return vertex2;
public Vector getBottomLeftVertex() {
return new Vector(getLeftEdge(), getBottomEdge());
}
public Vector getVertex3() {
return vertex3;
}
@Override
public boolean isCollisionWithCircle(Circle circle, CollisionDetector collisionDetector) {
return collisionDetector.isCircleTriangleCollision(circle, this);
}
@Override
public boolean isCollisionWithQuad(Quad quad, CollisionDetector collisionDetector) {
return collisionDetector.isQuadTriangleCollision(quad, this);
}
@Override
public boolean isCollisionWithTriangle(Triangle triangle, CollisionDetector collisionDetector) {
return collisionDetector.isTriangleTriangleCollision(this, triangle);
public Vector getTopRightVertex() {
return new Vector(getRightEdge(), getTopEdge());
}
}

2
app/src/main/java/de/frajul/endlessroll/levels/worlds/World.java
View File

@ -17,7 +17,7 @@ import de.frajul.endlessroll.entities.textures.TexturePack;
public enum World {
GRASSLANDS(R.drawable.world_previews_grasslands, R.drawable.terrain_t_grass,
R.drawable.terrain_c_grass, R.drawable.juri_obstacles_grass,
R.drawable.terrain_c_grass, R.drawable.obstacles_grass,
R.drawable.backgrounds_game_grass),
ICY_MOUNTAINS(R.drawable.world_previews_icymountains, R.drawable.terrain_t_ice,
R.drawable.terrain_c_ice, R.drawable.obstacles_snow, R.drawable.backgrounds_game_snow),

7
app/src/main/java/de/frajul/endlessroll/main/MyGlSurfaceView.java
View File

@ -3,6 +3,7 @@ package de.frajul.endlessroll.main;
import android.content.Context;
import android.opengl.GLSurfaceView;
import android.view.MotionEvent;
import android.view.View;
import de.frajul.endlessroll.rendering.renderer.GameRenderer;
@ -26,7 +27,10 @@ public class MyGlSurfaceView extends GLSurfaceView {
@Override
public boolean onTouchEvent(MotionEvent event) {
renderer.onTouch(event.getX(), event.getY());
if(event.getAction() == MotionEvent.ACTION_DOWN) {
GameLog.i("TouchEvent!!!");
renderer.onTouch(event.getX(), event.getY());
}
return true;
}
@ -41,4 +45,5 @@ public class MyGlSurfaceView extends GLSurfaceView {
GameLog.i("GLSurfaceView: onPause");
super.onPause();
}
}

3
app/src/main/java/de/frajul/endlessroll/main/game/Game.java
View File

@ -132,7 +132,6 @@ public class Game extends Rendering<GameScene> {
@Override
public void update() {
try {
GameLog.i("FrameTimeMilliseconds: " + timer.getFrameTimeMilliseconds());
particleSystem.update(timer);
if (scene == null || player == null)
return;
@ -175,7 +174,7 @@ public class Game extends Rendering<GameScene> {
for (ToolButton toolButton : toolButtonBar.getToolButtons()) {
ToolType toolType = toolButton.getToolType();
if (collisionDetector.isPointQuadCollision(touchPoint,
if (collisionDetector.isPointInQuad(touchPoint,
toolButton.getBorder()) && toolType != null) {
toolButtonBar.setActive(toolType);
setCurrentTool(toolType, toolButton.hasFinishedLoading());

2
app/src/main/java/de/frajul/endlessroll/main/game/GameScene.java
View File

@ -95,7 +95,7 @@ public class GameScene extends Scene {
public Obstacle getObstacleAtPoint(Vector point) {
synchronized (obstacles) {
for (Obstacle obstacle : obstacles) {
if (collisionDetector.isPointQuadCollision(point, obstacle))
if (collisionDetector.isPointInQuad(point, obstacle))
return obstacle;
}
}

10
app/src/main/java/de/frajul/endlessroll/main/physics/Physics.java
View File

@ -61,7 +61,7 @@ public class Physics {
}
public synchronized void checkSingleToolCollision(Tool tool, Scene scene) {
if(tool.isFloating())
if (tool.isFloating())
return;
float terrainEdge = getTerrainEdge(tool, scene.getTerrain());
Obstacle toolIsCollidingWith = getHighestObstacleToolIsCollidingWith(tool, scene);
@ -93,7 +93,7 @@ public class Physics {
List<Obstacle> collisionObstacles = new ArrayList<>();
synchronized (scene.getObstacles()) {
for (Obstacle obstacle : scene.getObstacles()) {
if (tool.getWorldCollisionBounds().isCollisionWithQuad(obstacle, detector)) {
if (detector.isCollision(tool.getWorldCollisionBounds(), obstacle)) {
collisionObstacles.add(obstacle);
}
}
@ -133,7 +133,7 @@ public class Physics {
Terrain terrain = scene.getTerrain();
for (Tile terrainTile : terrain) {
EntityCollisionData data = detector
.playerEntityCollision(scene.getPlayer(), terrainTile);
.playerTerrainCollision(scene.getPlayer(), terrainTile);
if (data.isCollision())
return data;
}
@ -144,7 +144,7 @@ public class Physics {
Ceiling ceiling = scene.getCeiling();
for (Tile ceilingTile : ceiling) {
EntityCollisionData data = detector
.playerEntityCollision(scene.getPlayer(), ceilingTile);
.playerCeilingCollision(scene.getPlayer(), ceilingTile);
if (data.isCollision())
return data;
}
@ -169,7 +169,7 @@ public class Physics {
Circle circle = new Circle(scene.getPlayer());
synchronized (scene.getTools()) {
for (Tool tool : scene.getTools()) {
if (tool.getPlayerCollisionBounds().isCollisionWithCircle(circle, detector))
if (detector.isCollision(tool.getPlayerCollisionBounds(), circle))
tools.add(tool);
}
}