Skip to content

Commit

Permalink
change append for make in NewPolygon, use array instead of slice in t…
Browse files Browse the repository at this point in the history 
…ests
  • Loading branch information
@Tarliton
Tarliton committed Mar 30, 2016
1 parent f03ea63 commit 0c50e54
Show file tree
Hide file tree
Showing 3 changed files with 40 additions and 40 deletions.
44 changes: 22 additions & 22 deletions collision_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -23,24 +23,24 @@ func TestCollisionPointNotInCircle(t *testing.T) {

func TestCollisionPointInPolygon(t *testing.T) {
point := collision2d.NewVector(35, 5)
polygonCorners := []float64{
polygonCorners := [...]float64{
0, 0,
30, 0,
0, 30,
}
polygon := collision2d.NewPolygon(collision2d.NewVector(30, 0), collision2d.NewVector(0, 0), 0, polygonCorners)
polygon := collision2d.NewPolygon(collision2d.NewVector(30, 0), collision2d.NewVector(0, 0), 0, polygonCorners[:])
result := collision2d.PointInPolygon(point, polygon)
assert.Equal(t, true, result, "they should be equal")
}

func TestCollisionPointNotInPolygon(t *testing.T) {
point := collision2d.NewVector(0, 0)
polygonCorners := []float64{
polygonCorners := [...]float64{
0, 0,
30, 0,
0, 30,
}
polygon := collision2d.NewPolygon(collision2d.NewVector(30, 0), collision2d.NewVector(0, 0), 0, polygonCorners)
polygon := collision2d.NewPolygon(collision2d.NewVector(30, 0), collision2d.NewVector(0, 0), 0, polygonCorners[:])
result := collision2d.PointInPolygon(point, polygon)
assert.Equal(t, false, result, "they should be equal")
}
Expand All @@ -65,13 +65,13 @@ func TestCollisionTestNotCircleCircle(t *testing.T) {
}

func TestCollisionTestPolygonCircle(t *testing.T) {
polygonCorners := []float64{
polygonCorners := [...]float64{
0, 0,
40, 0,
40, 40,
0, 40,
}
polygon := collision2d.NewPolygon(collision2d.NewVector(0, 0), collision2d.NewVector(0, 0), 0, polygonCorners)
polygon := collision2d.NewPolygon(collision2d.NewVector(0, 0), collision2d.NewVector(0, 0), 0, polygonCorners[:])
circle := collision2d.NewCircle(collision2d.NewVector(50, 50), 20)
result, response := collision2d.TestPolygonCircle(polygon, circle)
assert.Equal(t, true, result, "they should be equal")
Expand All @@ -81,13 +81,13 @@ func TestCollisionTestPolygonCircle(t *testing.T) {
}

func TestCollisionTestNotPolygonCircle(t *testing.T) {
polygonCorners := []float64{
polygonCorners := [...]float64{
0, 0,
40, 0,
40, 40,
0, 40,
}
polygon := collision2d.NewPolygon(collision2d.NewVector(0, 0), collision2d.NewVector(0, 0), 0, polygonCorners)
polygon := collision2d.NewPolygon(collision2d.NewVector(0, 0), collision2d.NewVector(0, 0), 0, polygonCorners[:])
circle := collision2d.NewCircle(collision2d.NewVector(200, 200), 1)
result, response := collision2d.TestPolygonCircle(polygon, circle)
assert.Equal(t, false, result, "they should be equal")
Expand All @@ -97,13 +97,13 @@ func TestCollisionTestNotPolygonCircle(t *testing.T) {
}

func TestCollisionTestCirclePolygon(t *testing.T) {
polygonCorners := []float64{
polygonCorners := [...]float64{
0, 0,
40, 0,
40, 40,
0, 40,
}
polygon := collision2d.NewPolygon(collision2d.NewVector(0, 0), collision2d.NewVector(0, 0), 0, polygonCorners)
polygon := collision2d.NewPolygon(collision2d.NewVector(0, 0), collision2d.NewVector(0, 0), 0, polygonCorners[:])
circle := collision2d.NewCircle(collision2d.NewVector(50, 50), 20)
result, response := collision2d.TestCirclePolygon(circle, polygon)
assert.Equal(t, true, result, "they should be equal")
Expand All @@ -113,13 +113,13 @@ func TestCollisionTestCirclePolygon(t *testing.T) {
}

func TestCollisionTestPolygonPolygon(t *testing.T) {
polygonCorners := []float64{
polygonCorners := [...]float64{
0, 0,
40, 0,
40, 40,
0, 40,
}
polygon := collision2d.NewPolygon(collision2d.NewVector(0, 0), collision2d.NewVector(0, 0), 0, polygonCorners)
polygon := collision2d.NewPolygon(collision2d.NewVector(0, 0), collision2d.NewVector(0, 0), 0, polygonCorners[:])
result, response := collision2d.TestPolygonPolygon(polygon, polygon)
assert.Equal(t, true, result, "they should be equal")
assert.Equal(t, float64(40), response.Overlap, "they should be equal")
Expand All @@ -138,13 +138,13 @@ func BenchmarkCollisionPointInCircle(b *testing.B) {
}

func BenchmarkCollisionPointInPolygon(b *testing.B) {
polygonCorners := []float64{
polygonCorners := [...]float64{
0, 0,
40, 0,
40, 40,
0, 40,
}
polygon := collision2d.NewPolygon(collision2d.NewVector(0, 0), collision2d.NewVector(0, 0), 0, polygonCorners)
polygon := collision2d.NewPolygon(collision2d.NewVector(0, 0), collision2d.NewVector(0, 0), 0, polygonCorners[:])
point := collision2d.NewVector(1, 2)
for i := 0; i < b.N; i++ {
collision2d.PointInPolygon(point, polygon)
Expand All @@ -161,47 +161,47 @@ func BenchmarkCollisionTestCircleCircle(b *testing.B) {

func BenchmarkCollisionTestPolygonCircle(b *testing.B) {
circle := collision2d.NewCircle(collision2d.NewVector(0, 0), 20)
polygonCorners := []float64{
polygonCorners := [...]float64{
0, 0,
40, 0,
40, 40,
0, 40,
}
polygon := collision2d.NewPolygon(collision2d.NewVector(0, 0), collision2d.NewVector(0, 0), 0, polygonCorners)
polygon := collision2d.NewPolygon(collision2d.NewVector(0, 0), collision2d.NewVector(0, 0), 0, polygonCorners[:])
for i := 0; i < b.N; i++ {
_, response = collision2d.TestPolygonCircle(polygon, circle)
}
}

func BenchmarkCollisionTestCirclePolygon(b *testing.B) {
circle := collision2d.NewCircle(collision2d.NewVector(0, 0), 20)
polygonCorners := []float64{
polygonCorners := [...]float64{
0, 0,
40, 0,
40, 40,
0, 40,
}
polygon := collision2d.NewPolygon(collision2d.NewVector(0, 0), collision2d.NewVector(0, 0), 0, polygonCorners)
polygon := collision2d.NewPolygon(collision2d.NewVector(0, 0), collision2d.NewVector(0, 0), 0, polygonCorners[:])
for i := 0; i < b.N; i++ {
_, response = collision2d.TestCirclePolygon(circle, polygon)
}
}

func BenchmarkCollisionTestPolygonPolygon(b *testing.B) {
polygonCorners1 := []float64{
polygonCorners1 := [...]float64{
0, 0,
40, 0,
40, 40,
0, 40,
}
polygon1 := collision2d.NewPolygon(collision2d.NewVector(0, 0), collision2d.NewVector(0, 0), 0, polygonCorners1)
polygonCorners2 := []float64{
polygon1 := collision2d.NewPolygon(collision2d.NewVector(0, 0), collision2d.NewVector(0, 0), 0, polygonCorners1[:])
polygonCorners2 := [...]float64{
0, 0,
40, 0,
40, 40,
0, 40,
}
polygon2 := collision2d.NewPolygon(collision2d.NewVector(15, 25), collision2d.NewVector(0, 0), 0, polygonCorners2)
polygon2 := collision2d.NewPolygon(collision2d.NewVector(15, 25), collision2d.NewVector(0, 0), 0, polygonCorners2[:])
for i := 0; i < b.N; i++ {
_, response = collision2d.TestPolygonPolygon(polygon1, polygon2)
}
Expand Down
4 changes: 2 additions & 2 deletions polygon.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -19,9 +19,9 @@ func (polygon Polygon) String() string {
//Points is an array of pairs of float64 values, that are mapped into Vectors with X and Y.
//The first value is X and the second is Y. See test to understand better.
func NewPolygon(pos, offset Vector, angle float64, points []float64) Polygon {
var vectorPoints []Vector
var vectorPoints = make([]Vector, len(points)/2)
for i := 0; i < len(points); i += 2 {
vectorPoints = append(vectorPoints, NewVector(points[i], points[i+1]))
vectorPoints[i/2] = NewVector(points[i], points[i+1])
}
polygon := Polygon{Pos: pos, Offset: offset, Angle: angle}
return polygon.SetPoints(vectorPoints)
Expand Down
32 changes: 16 additions & 16 deletions polygon_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,98 +8,98 @@ import (
)

func TestPolygonString(t *testing.T) {
polygonCorners := []float64{
polygonCorners := [...]float64{
0, 0,
10, 0,
10, 10,
0, 10,
}
polygon := collision2d.NewPolygon(collision2d.NewVector(5, 5), collision2d.NewVector(0, 0), 0, polygonCorners)
polygon := collision2d.NewPolygon(collision2d.NewVector(5, 5), collision2d.NewVector(0, 0), 0, polygonCorners[:])
output := string(polygon.String())
assert.Equal(t, "{Pos:{X:5.000000, Y:5.000000}\nOffset:{X:0.000000, Y:0.000000}\nAngle: 0.000000\nPoints: [{X:0.000000, Y:0.000000}\n {X:10.000000, Y:0.000000}\n {X:10.000000, Y:10.000000}\n {X:0.000000, Y:10.000000}\n]}", output, "they should be equal")
}

func TestPolygonNewPolygon(t *testing.T) {
polygonCorners := []float64{
polygonCorners := [...]float64{
0, 0,
10, 0,
10, 10,
0, 10,
}
polygon := collision2d.NewPolygon(collision2d.NewVector(5, 4), collision2d.NewVector(0, 0), 0, polygonCorners)
polygon := collision2d.NewPolygon(collision2d.NewVector(5, 4), collision2d.NewVector(0, 0), 0, polygonCorners[:])
assert.Equal(t, float64(5), polygon.Pos.X, "they should be equal")
assert.Equal(t, float64(4), polygon.Pos.Y, "they should be equal")
assert.Equal(t, float64(0), polygon.Angle, "they should be equal")
}

func TestPolygonSetAngle(t *testing.T) {
polygonCorners := []float64{
polygonCorners := [...]float64{
0, 0,
10, 0,
10, 10,
0, 10,
}
polygon := collision2d.NewPolygon(collision2d.NewVector(5, 5), collision2d.NewVector(0, 0), 0, polygonCorners)
polygon := collision2d.NewPolygon(collision2d.NewVector(5, 5), collision2d.NewVector(0, 0), 0, polygonCorners[:])
polygon = polygon.SetAngle(math.Pi / 2)
assert.Equal(t, math.Pi/2, polygon.Angle, "they should be equal")
}

func TestPolygonSetOffset(t *testing.T) {
polygonCorners := []float64{
polygonCorners := [...]float64{
0, 0,
10, 0,
10, 10,
0, 10,
}
polygon := collision2d.NewPolygon(collision2d.NewVector(5, 5), collision2d.NewVector(0, 0), 0, polygonCorners)
polygon := collision2d.NewPolygon(collision2d.NewVector(5, 5), collision2d.NewVector(0, 0), 0, polygonCorners[:])
polygon = polygon.SetOffset(collision2d.NewVector(50, 50))
assert.Equal(t, collision2d.NewVector(50, 50), polygon.Offset, "they should be equal")
}

func TestPolygonRotate(t *testing.T) {
polygonCorners := []float64{
polygonCorners := [...]float64{
0, 0,
10, 0,
10, 10,
0, 10,
}
polygon := collision2d.NewPolygon(collision2d.NewVector(5, 5), collision2d.NewVector(0, 0), 0, polygonCorners)
polygon := collision2d.NewPolygon(collision2d.NewVector(5, 5), collision2d.NewVector(0, 0), 0, polygonCorners[:])
polygon = polygon.Rotate(math.Pi)
assert.Equal(t, []collision2d.Vector{collision2d.Vector{X: -0, Y: 0}, collision2d.Vector{X: -10, Y: 1.2246467991473515e-15}, collision2d.Vector{X: -10.000000000000002, Y: -9.999999999999998}, collision2d.Vector{X: -1.2246467991473515e-15, Y: -10}}, polygon.Points, "they should be equal")
}

func TestPolygonTranslate(t *testing.T) {
polygonCorners := []float64{
polygonCorners := [...]float64{
0, 0,
10, 0,
10, 10,
0, 10,
}
polygon := collision2d.NewPolygon(collision2d.NewVector(5, 5), collision2d.NewVector(0, 0), 0, polygonCorners)
polygon := collision2d.NewPolygon(collision2d.NewVector(5, 5), collision2d.NewVector(0, 0), 0, polygonCorners[:])
polygon = polygon.Translate(5.5, 9.2)
assert.Equal(t, []collision2d.Vector{collision2d.Vector{X: 5.5, Y: 9.2}, collision2d.Vector{X: 15.5, Y: 9.2}, collision2d.Vector{X: 15.5, Y: 19.2}, collision2d.Vector{X: 5.5, Y: 19.2}}, polygon.Points, "they should be equal")
}

func TestPolygonGetAABBOne(t *testing.T) {
polygonCorners := []float64{
polygonCorners := [...]float64{
0, 0,
10, 0,
10, 10,
0, 10,
}
polygon := collision2d.NewPolygon(collision2d.NewVector(5, 5), collision2d.NewVector(0, 0), 0, polygonCorners)
polygon := collision2d.NewPolygon(collision2d.NewVector(5, 5), collision2d.NewVector(0, 0), 0, polygonCorners[:])
polygonAABB := polygon.GetAABB()
assert.Equal(t, polygon, polygonAABB, "they should be equal")
}

func TestPolygonGetAABBTwo(t *testing.T) {
polygonCorners := []float64{
polygonCorners := [...]float64{
10, 10,
0, 10,
0, 0,
10, 0,
}
polygon := collision2d.NewPolygon(collision2d.NewVector(5, 5), collision2d.NewVector(0, 0), 0, polygonCorners)
polygon := collision2d.NewPolygon(collision2d.NewVector(5, 5), collision2d.NewVector(0, 0), 0, polygonCorners[:])
polygonAABB := polygon.GetAABB()
assert.Equal(t, collision2d.Polygon{Pos: collision2d.Vector{X: 5, Y: 5}, Offset: collision2d.Vector{X: 0, Y: 0}, Angle: 0, Points: []collision2d.Vector{collision2d.Vector{X: 0, Y: 0}, collision2d.Vector{X: 10, Y: 0}, collision2d.Vector{X: 10, Y: 10}, collision2d.Vector{X: 0, Y: 10}}, CalcPoints: []collision2d.Vector{collision2d.Vector{X: 0, Y: 0}, collision2d.Vector{X: 10, Y: 0}, collision2d.Vector{X: 10, Y: 10}, collision2d.Vector{X: 0, Y: 10}}, Edges: []collision2d.Vector{collision2d.Vector{X: 10, Y: 0}, collision2d.Vector{X: 0, Y: 10}, collision2d.Vector{X: -10, Y: 0}, collision2d.Vector{X: 0, Y: -10}}, Normals: []collision2d.Vector{collision2d.Vector{X: 0, Y: -1}, collision2d.Vector{X: 1, Y: -0}, collision2d.Vector{X: 0, Y: 1}, collision2d.Vector{X: -1, Y: -0}}}, polygonAABB, "they should be equal")
}

0 comments on commit 0c50e54

Please sign in to comment.