mirror of
https://github.com/photonstorm/phaser
synced 2024-11-10 07:04:31 +00:00
All physics projections added.
This commit is contained in:
parent
c2d7fb7fab
commit
7aa82a1cb0
36 changed files with 5811 additions and 874 deletions
|
@ -94,6 +94,18 @@
|
|||
<TypeScriptCompile Include="physics\aabb\ProjAABBFull.ts" />
|
||||
<TypeScriptCompile Include="physics\aabb\ProjAABBConvex.ts" />
|
||||
<TypeScriptCompile Include="physics\aabb\ProjAABBConcave.ts" />
|
||||
<TypeScriptCompile Include="physics\aabb\ProjAABB45Deg.ts" />
|
||||
<TypeScriptCompile Include="physics\aabb\ProjAABB22Deg.ts" />
|
||||
<Content Include="physics\aabb\ProjAABB22Deg.js">
|
||||
<DependentUpon>ProjAABB22Deg.ts</DependentUpon>
|
||||
</Content>
|
||||
<Content Include="physics\aabb\ProjAABB45Deg.js">
|
||||
<DependentUpon>ProjAABB45Deg.ts</DependentUpon>
|
||||
</Content>
|
||||
<TypeScriptCompile Include="physics\aabb\ProjAABB67Deg.ts" />
|
||||
<Content Include="physics\aabb\ProjAABB67Deg.js">
|
||||
<DependentUpon>ProjAABB67Deg.ts</DependentUpon>
|
||||
</Content>
|
||||
<Content Include="physics\aabb\ProjAABBConcave.js">
|
||||
<DependentUpon>ProjAABBConcave.ts</DependentUpon>
|
||||
</Content>
|
||||
|
@ -104,6 +116,10 @@
|
|||
<DependentUpon>ProjAABBFull.ts</DependentUpon>
|
||||
</Content>
|
||||
<TypeScriptCompile Include="physics\Body.ts" />
|
||||
<TypeScriptCompile Include="physics\aabb\ProjAABBHalf.ts" />
|
||||
<Content Include="physics\aabb\ProjAABBHalf.js">
|
||||
<DependentUpon>ProjAABBHalf.ts</DependentUpon>
|
||||
</Content>
|
||||
<Content Include="physics\Body.js">
|
||||
<DependentUpon>Body.ts</DependentUpon>
|
||||
</Content>
|
||||
|
@ -112,10 +128,18 @@
|
|||
</Content>
|
||||
<TypeScriptCompile Include="physics\circle\ProjCircleFull.ts" />
|
||||
<TypeScriptCompile Include="physics\circle\ProjCircle45Deg.ts" />
|
||||
<TypeScriptCompile Include="physics\circle\ProjCircle22Deg.ts" />
|
||||
<Content Include="physics\circle\ProjCircle22Deg.js">
|
||||
<DependentUpon>ProjCircle22Deg.ts</DependentUpon>
|
||||
</Content>
|
||||
<Content Include="physics\circle\ProjCircle45Deg.js">
|
||||
<DependentUpon>ProjCircle45Deg.ts</DependentUpon>
|
||||
</Content>
|
||||
<TypeScriptCompile Include="physics\circle\ProjCircleConcave.ts" />
|
||||
<TypeScriptCompile Include="physics\circle\ProjCircle67Deg.ts" />
|
||||
<Content Include="physics\circle\ProjCircle67Deg.js">
|
||||
<DependentUpon>ProjCircle67Deg.ts</DependentUpon>
|
||||
</Content>
|
||||
<Content Include="physics\circle\ProjCircleConcave.js">
|
||||
<DependentUpon>ProjCircleConcave.ts</DependentUpon>
|
||||
</Content>
|
||||
|
@ -126,6 +150,10 @@
|
|||
<Content Include="physics\circle\ProjCircleFull.js">
|
||||
<DependentUpon>ProjCircleFull.ts</DependentUpon>
|
||||
</Content>
|
||||
<TypeScriptCompile Include="physics\circle\ProjCircleHalf.ts" />
|
||||
<Content Include="physics\circle\ProjCircleHalf.js">
|
||||
<DependentUpon>ProjCircleHalf.ts</DependentUpon>
|
||||
</Content>
|
||||
<Content Include="physics\PhysicsManager.js">
|
||||
<DependentUpon>PhysicsManager.ts</DependentUpon>
|
||||
</Content>
|
||||
|
|
|
@ -114,13 +114,22 @@
|
|||
/// <reference path="physics/AABB.ts" />
|
||||
/// <reference path="physics/Circle.ts" />
|
||||
/// <reference path="physics/TileMapCell.ts" />
|
||||
/// <reference path="physics/aabb/ProjAABBFull.ts" />
|
||||
/// <reference path="physics/aabb/ProjAABBConvex.ts" />
|
||||
|
||||
/// <reference path="physics/aabb/ProjAABB22Deg.ts" />
|
||||
/// <reference path="physics/aabb/ProjAABB45Deg.ts" />
|
||||
/// <reference path="physics/aabb/ProjAABB67Deg.ts" />
|
||||
/// <reference path="physics/aabb/ProjAABBConcave.ts" />
|
||||
/// <reference path="physics/circle/ProjCircleFull.ts" />
|
||||
/// <reference path="physics/circle/ProjCircleConvex.ts" />
|
||||
/// <reference path="physics/circle/ProjCircleConcave.ts" />
|
||||
/// <reference path="physics/aabb/ProjAABBConvex.ts" />
|
||||
/// <reference path="physics/aabb/ProjAABBFull.ts" />
|
||||
/// <reference path="physics/aabb/ProjAABBHalf.ts" />
|
||||
|
||||
/// <reference path="physics/circle/ProjCircle22Deg.ts" />
|
||||
/// <reference path="physics/circle/ProjCircle45Deg.ts" />
|
||||
/// <reference path="physics/circle/ProjCircle67Deg.ts" />
|
||||
/// <reference path="physics/circle/ProjCircleConcave.ts" />
|
||||
/// <reference path="physics/circle/ProjCircleConvex.ts" />
|
||||
/// <reference path="physics/circle/ProjCircleFull.ts" />
|
||||
/// <reference path="physics/circle/ProjCircleHalf.ts" />
|
||||
|
||||
/// <reference path="particles/ParticleManager.ts" />
|
||||
/// <reference path="particles/Particle.ts" />
|
||||
|
|
|
@ -21,7 +21,7 @@ var Phaser;
|
|||
this.aabbTileProjections[Phaser.Physics.TileMapCell.CTYPE_CONCAVE] = Phaser.Physics.Projection.AABBConcave.Collide;
|
||||
this.aabbTileProjections[Phaser.Physics.TileMapCell.CTYPE_CONVEX] = Phaser.Physics.Projection.AABBConvex.Collide;
|
||||
}
|
||||
AABB.prototype.IntegrateVerlet = function () {
|
||||
AABB.prototype.integrateVerlet = function () {
|
||||
var d = 1;
|
||||
var g = 0.2;
|
||||
|
||||
|
@ -41,7 +41,7 @@ var Phaser;
|
|||
p.y += (d * py) - (d * oy) + g;
|
||||
};
|
||||
|
||||
AABB.prototype.ReportCollisionVsWorld = function (px, py, dx, dy, obj) {
|
||||
AABB.prototype.reportCollisionVsWorld = function (px, py, dx, dy, obj) {
|
||||
var p = this.pos;
|
||||
var o = this.oldpos;
|
||||
|
||||
|
@ -84,7 +84,7 @@ var Phaser;
|
|||
o.y += py + by + fy;
|
||||
};
|
||||
|
||||
AABB.prototype.CollideAABBVsTile = function (tile) {
|
||||
AABB.prototype.collideAABBVsTile = function (tile) {
|
||||
var pos = this.pos;
|
||||
var c = tile;
|
||||
|
||||
|
@ -121,12 +121,12 @@ var Phaser;
|
|||
}
|
||||
}
|
||||
|
||||
this.ResolveBoxTile(px, py, this, c);
|
||||
this.resolveBoxTile(px, py, this, c);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
AABB.prototype.CollideAABBVsWorldBounds = function () {
|
||||
AABB.prototype.collideAABBVsWorldBounds = function () {
|
||||
var p = this.pos;
|
||||
var xw = this.xw;
|
||||
var yw = this.yw;
|
||||
|
@ -140,13 +140,13 @@ var Phaser;
|
|||
var dx = XMIN - (p.x - xw);
|
||||
if (0 < dx) {
|
||||
//object is colliding with XMIN
|
||||
this.ReportCollisionVsWorld(dx, 0, 1, 0, null);
|
||||
this.reportCollisionVsWorld(dx, 0, 1, 0, null);
|
||||
} else {
|
||||
//test XMAX
|
||||
dx = (p.x + xw) - XMAX;
|
||||
if (0 < dx) {
|
||||
//object is colliding with XMAX
|
||||
this.ReportCollisionVsWorld(-dx, 0, -1, 0, null);
|
||||
this.reportCollisionVsWorld(-dx, 0, -1, 0, null);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -155,13 +155,13 @@ var Phaser;
|
|||
var dy = YMIN - (p.y - yw);
|
||||
if (0 < dy) {
|
||||
//object is colliding with YMIN
|
||||
this.ReportCollisionVsWorld(0, dy, 0, 1, null);
|
||||
this.reportCollisionVsWorld(0, dy, 0, 1, null);
|
||||
} else {
|
||||
//test YMAX
|
||||
dy = (p.y + yw) - YMAX;
|
||||
if (0 < dy) {
|
||||
//object is colliding with YMAX
|
||||
this.ReportCollisionVsWorld(0, -dy, 0, -1, null);
|
||||
this.reportCollisionVsWorld(0, -dy, 0, -1, null);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
@ -177,11 +177,11 @@ var Phaser;
|
|||
context.fillRect(this.pos.x, this.pos.y, 2, 2);
|
||||
};
|
||||
|
||||
AABB.prototype.ResolveBoxTile = function (x, y, box, t) {
|
||||
AABB.prototype.resolveBoxTile = function (x, y, box, t) {
|
||||
if (0 < t.ID) {
|
||||
return this.aabbTileProjections[t.CTYPE](x, y, box, t);
|
||||
} else {
|
||||
//trace("ResolveBoxTile() was called with an empty (or unknown) tile!: ID=" + t.ID + " ("+ t.i + "," + t.j + ")");
|
||||
//trace("resolveBoxTile() was called with an empty (or unknown) tile!: ID=" + t.ID + " ("+ t.i + "," + t.j + ")");
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
|
|
@ -19,9 +19,15 @@ module Phaser.Physics {
|
|||
this.yw = Math.abs(yw);
|
||||
|
||||
this.aabbTileProjections = {};
|
||||
this.aabbTileProjections[Phaser.Physics.TileMapCell.CTYPE_FULL] = Phaser.Physics.Projection.AABBFull.Collide;
|
||||
this.aabbTileProjections[Phaser.Physics.TileMapCell.CTYPE_22DEGs] = Phaser.Physics.Projection.AABB22Deg.CollideS;
|
||||
this.aabbTileProjections[Phaser.Physics.TileMapCell.CTYPE_22DEGb] = Phaser.Physics.Projection.AABB22Deg.CollideB;
|
||||
this.aabbTileProjections[Phaser.Physics.TileMapCell.CTYPE_45DEG] = Phaser.Physics.Projection.AABB45Deg.Collide;
|
||||
this.aabbTileProjections[Phaser.Physics.TileMapCell.CTYPE_67DEGs] = Phaser.Physics.Projection.AABB67Deg.CollideS;
|
||||
this.aabbTileProjections[Phaser.Physics.TileMapCell.CTYPE_67DEGb] = Phaser.Physics.Projection.AABB67Deg.CollideB;
|
||||
this.aabbTileProjections[Phaser.Physics.TileMapCell.CTYPE_CONCAVE] = Phaser.Physics.Projection.AABBConcave.Collide;
|
||||
this.aabbTileProjections[Phaser.Physics.TileMapCell.CTYPE_CONVEX] = Phaser.Physics.Projection.AABBConvex.Collide;
|
||||
this.aabbTileProjections[Phaser.Physics.TileMapCell.CTYPE_FULL] = Phaser.Physics.Projection.AABBFull.Collide;
|
||||
this.aabbTileProjections[Phaser.Physics.TileMapCell.CTYPE_HALF] = Phaser.Physics.Projection.AABBHalf.Collide;
|
||||
|
||||
}
|
||||
|
||||
|
@ -41,7 +47,7 @@ module Phaser.Physics {
|
|||
|
||||
private aabbTileProjections;
|
||||
|
||||
public IntegrateVerlet() {
|
||||
public integrateVerlet() {
|
||||
|
||||
var d = 1; // global drag
|
||||
var g = 0.2; // global gravity
|
||||
|
@ -63,7 +69,7 @@ module Phaser.Physics {
|
|||
|
||||
}
|
||||
|
||||
public ReportCollisionVsWorld(px: number, py: number, dx: number, dy: number, obj: TileMapCell) {
|
||||
public reportCollisionVsWorld(px: number, py: number, dx: number, dy: number, obj: TileMapCell = null) {
|
||||
|
||||
var p = this.pos;
|
||||
var o = this.oldpos;
|
||||
|
@ -113,7 +119,7 @@ module Phaser.Physics {
|
|||
}
|
||||
|
||||
|
||||
public CollideAABBVsTile(tile:Phaser.Physics.TileMapCell) {
|
||||
public collideAABBVsTile(tile:Phaser.Physics.TileMapCell) {
|
||||
|
||||
var pos = this.pos;
|
||||
var c = tile;
|
||||
|
@ -167,13 +173,13 @@ module Phaser.Physics {
|
|||
}
|
||||
}
|
||||
|
||||
this.ResolveBoxTile(px, py, this, c);
|
||||
this.resolveBoxTile(px, py, this, c);
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public CollideAABBVsWorldBounds() {
|
||||
public collideAABBVsWorldBounds() {
|
||||
|
||||
var p = this.pos;
|
||||
var xw = this.xw;
|
||||
|
@ -189,7 +195,7 @@ module Phaser.Physics {
|
|||
if (0 < dx)
|
||||
{
|
||||
//object is colliding with XMIN
|
||||
this.ReportCollisionVsWorld(dx, 0, 1, 0, null);
|
||||
this.reportCollisionVsWorld(dx, 0, 1, 0, null);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -198,7 +204,7 @@ module Phaser.Physics {
|
|||
if (0 < dx)
|
||||
{
|
||||
//object is colliding with XMAX
|
||||
this.ReportCollisionVsWorld(-dx, 0, -1, 0, null);
|
||||
this.reportCollisionVsWorld(-dx, 0, -1, 0, null);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -208,7 +214,7 @@ module Phaser.Physics {
|
|||
if (0 < dy)
|
||||
{
|
||||
//object is colliding with YMIN
|
||||
this.ReportCollisionVsWorld(0, dy, 0, 1, null);
|
||||
this.reportCollisionVsWorld(0, dy, 0, 1, null);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -217,7 +223,7 @@ module Phaser.Physics {
|
|||
if (0 < dy)
|
||||
{
|
||||
//object is colliding with YMAX
|
||||
this.ReportCollisionVsWorld(0, -dy, 0, -1, null);
|
||||
this.reportCollisionVsWorld(0, -dy, 0, -1, null);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -235,7 +241,7 @@ module Phaser.Physics {
|
|||
|
||||
}
|
||||
|
||||
public ResolveBoxTile(x, y, box, t) {
|
||||
public resolveBoxTile(x, y, box, t) {
|
||||
|
||||
if (0 < t.ID)
|
||||
{
|
||||
|
@ -243,7 +249,7 @@ module Phaser.Physics {
|
|||
}
|
||||
else
|
||||
{
|
||||
//trace("ResolveBoxTile() was called with an empty (or unknown) tile!: ID=" + t.ID + " ("+ t.i + "," + t.j + ")");
|
||||
//trace("resolveBoxTile() was called with an empty (or unknown) tile!: ID=" + t.ID + " ("+ t.i + "," + t.j + ")");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -20,7 +20,7 @@ var Phaser;
|
|||
this.circleTileProjections[Phaser.Physics.TileMapCell.CTYPE_CONCAVE] = Phaser.Physics.Projection.CircleConcave.Collide;
|
||||
this.circleTileProjections[Phaser.Physics.TileMapCell.CTYPE_CONVEX] = Phaser.Physics.Projection.CircleConvex.Collide;
|
||||
}
|
||||
Circle.prototype.IntegrateVerlet = function () {
|
||||
Circle.prototype.integrateVerlet = function () {
|
||||
var d = 1;
|
||||
var g = 0.2;
|
||||
|
||||
|
@ -41,7 +41,7 @@ var Phaser;
|
|||
p.y += (d * py) - (d * oy) + g;
|
||||
};
|
||||
|
||||
Circle.prototype.ReportCollisionVsWorld = function (px, py, dx, dy, obj) {
|
||||
Circle.prototype.reportCollisionVsWorld = function (px, py, dx, dy, obj) {
|
||||
var p = this.pos;
|
||||
var o = this.oldpos;
|
||||
|
||||
|
@ -84,7 +84,7 @@ var Phaser;
|
|||
o.y += py + by + fy;
|
||||
};
|
||||
|
||||
Circle.prototype.CollideCircleVsWorldBounds = function () {
|
||||
Circle.prototype.collideCircleVsWorldBounds = function () {
|
||||
var p = this.pos;
|
||||
var r = this.radius;
|
||||
var XMIN = 0;
|
||||
|
@ -98,13 +98,13 @@ var Phaser;
|
|||
|
||||
if (0 < dx) {
|
||||
//object is colliding with XMIN
|
||||
this.ReportCollisionVsWorld(dx, 0, 1, 0, null);
|
||||
this.reportCollisionVsWorld(dx, 0, 1, 0, null);
|
||||
} else {
|
||||
//test XMAX
|
||||
dx = (p.x + r) - XMAX;
|
||||
if (0 < dx) {
|
||||
//object is colliding with XMAX
|
||||
this.ReportCollisionVsWorld(-dx, 0, -1, 0, null);
|
||||
this.reportCollisionVsWorld(-dx, 0, -1, 0, null);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -114,13 +114,13 @@ var Phaser;
|
|||
|
||||
if (0 < dy) {
|
||||
//object is colliding with YMIN
|
||||
this.ReportCollisionVsWorld(0, dy, 0, 1, null);
|
||||
this.reportCollisionVsWorld(0, dy, 0, 1, null);
|
||||
} else {
|
||||
//test YMAX
|
||||
dy = (p.y + r) - YMAX;
|
||||
if (0 < dy) {
|
||||
//object is colliding with YMAX
|
||||
this.ReportCollisionVsWorld(0, -dy, 0, -1, null);
|
||||
this.reportCollisionVsWorld(0, -dy, 0, -1, null);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
@ -165,7 +165,7 @@ var Phaser;
|
|||
}
|
||||
};
|
||||
|
||||
Circle.prototype.CollideCircleVsTile = function (tile) {
|
||||
Circle.prototype.collideCircleVsTile = function (tile) {
|
||||
var pos = this.pos;
|
||||
var r = this.radius;
|
||||
var c = tile;
|
||||
|
@ -203,16 +203,16 @@ var Phaser;
|
|||
this.oV = 1;
|
||||
}
|
||||
|
||||
this.ResolveCircleTile(px, py, this.oH, this.oV, this, c);
|
||||
this.resolveCircleTile(px, py, this.oH, this.oV, this, c);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
Circle.prototype.ResolveCircleTile = function (x, y, oH, oV, obj, t) {
|
||||
Circle.prototype.resolveCircleTile = function (x, y, oH, oV, obj, t) {
|
||||
if (0 < t.ID) {
|
||||
return this.circleTileProjections[t.CTYPE](x, y, oH, oV, obj, t);
|
||||
} else {
|
||||
console.log("ResolveCircleTile() was called with an empty (or unknown) tile!: ID=" + t.ID + " (" + t.i + "," + t.j + ")");
|
||||
console.log("resolveCircleTile() was called with an empty (or unknown) tile!: ID=" + t.ID + " (" + t.i + "," + t.j + ")");
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
|
|
@ -17,10 +17,15 @@ module Phaser.Physics {
|
|||
this.radius = radius;
|
||||
|
||||
this.circleTileProjections = {};
|
||||
this.circleTileProjections[Phaser.Physics.TileMapCell.CTYPE_FULL] = Phaser.Physics.Projection.CircleFull.Collide;
|
||||
this.circleTileProjections[Phaser.Physics.TileMapCell.CTYPE_22DEGs] = Phaser.Physics.Projection.Circle22Deg.CollideS;
|
||||
this.circleTileProjections[Phaser.Physics.TileMapCell.CTYPE_22DEGb] = Phaser.Physics.Projection.Circle22Deg.CollideB;
|
||||
this.circleTileProjections[Phaser.Physics.TileMapCell.CTYPE_45DEG] = Phaser.Physics.Projection.Circle45Deg.Collide;
|
||||
this.circleTileProjections[Phaser.Physics.TileMapCell.CTYPE_67DEGs] = Phaser.Physics.Projection.Circle67Deg.CollideS;
|
||||
this.circleTileProjections[Phaser.Physics.TileMapCell.CTYPE_67DEGb] = Phaser.Physics.Projection.Circle67Deg.CollideB;
|
||||
this.circleTileProjections[Phaser.Physics.TileMapCell.CTYPE_CONCAVE] = Phaser.Physics.Projection.CircleConcave.Collide;
|
||||
this.circleTileProjections[Phaser.Physics.TileMapCell.CTYPE_CONVEX] = Phaser.Physics.Projection.CircleConvex.Collide;
|
||||
this.circleTileProjections[Phaser.Physics.TileMapCell.CTYPE_FULL] = Phaser.Physics.Projection.CircleFull.Collide;
|
||||
this.circleTileProjections[Phaser.Physics.TileMapCell.CTYPE_HALF] = Phaser.Physics.Projection.CircleHalf.Collide;
|
||||
|
||||
}
|
||||
|
||||
|
@ -35,11 +40,11 @@ module Phaser.Physics {
|
|||
public oldpos: Phaser.Vec2;
|
||||
public radius: number;
|
||||
public oH: number; // horizontal collision
|
||||
public oV: number;
|
||||
public oV: number; // vertical collision
|
||||
|
||||
private circleTileProjections;
|
||||
|
||||
public IntegrateVerlet() {
|
||||
public integrateVerlet() {
|
||||
|
||||
var d = 1; // drag
|
||||
var g = 0.2; // gravity
|
||||
|
@ -61,7 +66,9 @@ module Phaser.Physics {
|
|||
|
||||
}
|
||||
|
||||
public ReportCollisionVsWorld(px: number, py: number, dx: number, dy: number, obj: Phaser.Physics.TileMapCell) {
|
||||
// px projection vector
|
||||
// dx surface normal
|
||||
public reportCollisionVsWorld(px: number, py: number, dx: number, dy: number, obj: Phaser.Physics.TileMapCell = null) {
|
||||
|
||||
var p = this.pos;
|
||||
var o = this.oldpos;
|
||||
|
@ -109,7 +116,7 @@ module Phaser.Physics {
|
|||
|
||||
}
|
||||
|
||||
public CollideCircleVsWorldBounds() {
|
||||
public collideCircleVsWorldBounds() {
|
||||
|
||||
var p = this.pos;
|
||||
var r = this.radius;
|
||||
|
@ -125,7 +132,7 @@ module Phaser.Physics {
|
|||
if (0 < dx)
|
||||
{
|
||||
//object is colliding with XMIN
|
||||
this.ReportCollisionVsWorld(dx, 0, 1, 0, null);
|
||||
this.reportCollisionVsWorld(dx, 0, 1, 0, null);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -134,7 +141,7 @@ module Phaser.Physics {
|
|||
if (0 < dx)
|
||||
{
|
||||
//object is colliding with XMAX
|
||||
this.ReportCollisionVsWorld(-dx, 0, -1, 0, null);
|
||||
this.reportCollisionVsWorld(-dx, 0, -1, 0, null);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -145,7 +152,7 @@ module Phaser.Physics {
|
|||
if (0 < dy)
|
||||
{
|
||||
//object is colliding with YMIN
|
||||
this.ReportCollisionVsWorld(0, dy, 0, 1, null);
|
||||
this.reportCollisionVsWorld(0, dy, 0, 1, null);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -154,7 +161,7 @@ module Phaser.Physics {
|
|||
if (0 < dy)
|
||||
{
|
||||
//object is colliding with YMAX
|
||||
this.ReportCollisionVsWorld(0, -dy, 0, -1, null);
|
||||
this.reportCollisionVsWorld(0, -dy, 0, -1, null);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -207,7 +214,7 @@ module Phaser.Physics {
|
|||
|
||||
}
|
||||
|
||||
public CollideCircleVsTile(tile) {
|
||||
public collideCircleVsTile(tile) {
|
||||
|
||||
var pos = this.pos;
|
||||
var r = this.radius;
|
||||
|
@ -255,13 +262,13 @@ module Phaser.Physics {
|
|||
this.oV = 1;
|
||||
}
|
||||
|
||||
this.ResolveCircleTile(px, py, this.oH, this.oV, this, c);
|
||||
this.resolveCircleTile(px, py, this.oH, this.oV, this, c);
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public ResolveCircleTile(x, y, oH, oV, obj, t) {
|
||||
public resolveCircleTile(x, y, oH, oV, obj, t) {
|
||||
|
||||
if (0 < t.ID)
|
||||
{
|
||||
|
@ -269,7 +276,7 @@ module Phaser.Physics {
|
|||
}
|
||||
else
|
||||
{
|
||||
console.log("ResolveCircleTile() was called with an empty (or unknown) tile!: ID=" + t.ID + " (" + t.i + "," + t.j + ")");
|
||||
console.log("resolveCircleTile() was called with an empty (or unknown) tile!: ID=" + t.ID + " (" + t.i + "," + t.j + ")");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
|
19
Phaser/physics/aabb/ProjAABB22Deg.js
Normal file
19
Phaser/physics/aabb/ProjAABB22Deg.js
Normal file
|
@ -0,0 +1,19 @@
|
|||
var Shapes;
|
||||
(function (Shapes) {
|
||||
|
||||
var Point = Shapes.Point = (function () {
|
||||
function Point(x, y) {
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
}
|
||||
Point.prototype.getDist = function () {
|
||||
return Math.sqrt((this.x * this.x) + (this.y * this.y));
|
||||
};
|
||||
Point.origin = new Point(0, 0);
|
||||
return Point;
|
||||
})();
|
||||
|
||||
})(Shapes || (Shapes = {}));
|
||||
|
||||
var p = new Shapes.Point(3, 4);
|
||||
var dist = p.getDist();
|
128
Phaser/physics/aabb/ProjAABB22Deg.ts
Normal file
128
Phaser/physics/aabb/ProjAABB22Deg.ts
Normal file
|
@ -0,0 +1,128 @@
|
|||
/// <reference path="../../_definitions.ts" />
|
||||
|
||||
/**
|
||||
* Phaser - Physics - Projection
|
||||
*/
|
||||
|
||||
module Phaser.Physics.Projection {
|
||||
|
||||
export class AABB22Deg {
|
||||
|
||||
public static CollideS(x: number, y: number, obj: Phaser.Physics.AABB, t: Phaser.Physics.TileMapCell) {
|
||||
|
||||
var signx = t.signx;
|
||||
var signy = t.signy;
|
||||
|
||||
//first we need to check to make sure we're colliding with the slope at all
|
||||
var py = obj.pos.y - (signy * obj.yw);
|
||||
var penY = t.pos.y - py;//this is the vector from the innermost point on the box to the highest point on
|
||||
//the tile; if it is positive, this means the box is above the tile and
|
||||
//no collision is occuring
|
||||
|
||||
if (0 < (penY * signy))
|
||||
{
|
||||
|
||||
var ox = (obj.pos.x - (signx * obj.xw)) - (t.pos.x + (signx * t.xw));//this gives is the coordinates of the innermost
|
||||
var oy = (obj.pos.y - (signy * obj.yw)) - (t.pos.y - (signy * t.yw));//point on the AABB, relative to a point on the slope
|
||||
|
||||
var sx = t.sx;//get slope unit normal
|
||||
var sy = t.sy;
|
||||
|
||||
//if the dotprod of (ox,oy) and (sx,sy) is negative, the corner is in the slope
|
||||
//and we need toproject it out by the magnitude of the projection of (ox,oy) onto (sx,sy)
|
||||
var dp = (ox * sx) + (oy * sy);
|
||||
|
||||
if (dp < 0)
|
||||
{
|
||||
//collision; project delta onto slope and use this to displace the object
|
||||
sx *= -dp;//(sx,sy) is now the projection vector
|
||||
sy *= -dp;
|
||||
|
||||
var lenN = Math.sqrt(sx * sx + sy * sy);
|
||||
var lenP = Math.sqrt(x * x + y * y);
|
||||
|
||||
var aY = Math.abs(penY);
|
||||
if (lenP < lenN)
|
||||
{
|
||||
if (aY < lenP)
|
||||
{
|
||||
obj.reportCollisionVsWorld(0, penY, 0, penY / aY, t);
|
||||
|
||||
return Phaser.Physics.AABB.COL_OTHER;
|
||||
}
|
||||
else
|
||||
{
|
||||
obj.reportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
|
||||
return Phaser.Physics.AABB.COL_AXIS;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (aY < lenN)
|
||||
{
|
||||
obj.reportCollisionVsWorld(0, penY, 0, penY / aY, t);
|
||||
|
||||
return Phaser.Physics.AABB.COL_OTHER;
|
||||
}
|
||||
else
|
||||
{
|
||||
obj.reportCollisionVsWorld(sx, sy, t.sx, t.sy, t);
|
||||
|
||||
return Phaser.Physics.AABB.COL_OTHER;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//if we've reached this point, no collision has occured
|
||||
return Phaser.Physics.AABB.COL_NONE;
|
||||
|
||||
}
|
||||
|
||||
public static CollideB(x: number, y: number, obj: Phaser.Physics.AABB, t: Phaser.Physics.TileMapCell) {
|
||||
|
||||
var signx = t.signx;
|
||||
var signy = t.signy;
|
||||
|
||||
var ox = (obj.pos.x - (signx * obj.xw)) - (t.pos.x - (signx * t.xw));//this gives is the coordinates of the innermost
|
||||
var oy = (obj.pos.y - (signy * obj.yw)) - (t.pos.y + (signy * t.yw));//point on the AABB, relative to a point on the slope
|
||||
|
||||
var sx = t.sx;//get slope unit normal
|
||||
var sy = t.sy;
|
||||
|
||||
//if the dotprod of (ox,oy) and (sx,sy) is negative, the corner is in the slope
|
||||
//and we need toproject it out by the magnitude of the projection of (ox,oy) onto (sx,sy)
|
||||
var dp = (ox * sx) + (oy * sy);
|
||||
|
||||
if (dp < 0)
|
||||
{
|
||||
//collision; project delta onto slope and use this to displace the object
|
||||
sx *= -dp;//(sx,sy) is now the projection vector
|
||||
sy *= -dp;
|
||||
|
||||
var lenN = Math.sqrt(sx * sx + sy * sy);
|
||||
var lenP = Math.sqrt(x * x + y * y);
|
||||
|
||||
if (lenP < lenN)
|
||||
{
|
||||
obj.reportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
|
||||
return Phaser.Physics.AABB.COL_AXIS;
|
||||
}
|
||||
else
|
||||
{
|
||||
obj.reportCollisionVsWorld(sx, sy, t.sx, t.sy, t);
|
||||
|
||||
return Phaser.Physics.AABB.COL_OTHER;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return Phaser.Physics.AABB.COL_NONE;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
19
Phaser/physics/aabb/ProjAABB45Deg.js
Normal file
19
Phaser/physics/aabb/ProjAABB45Deg.js
Normal file
|
@ -0,0 +1,19 @@
|
|||
var Shapes;
|
||||
(function (Shapes) {
|
||||
|
||||
var Point = Shapes.Point = (function () {
|
||||
function Point(x, y) {
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
}
|
||||
Point.prototype.getDist = function () {
|
||||
return Math.sqrt((this.x * this.x) + (this.y * this.y));
|
||||
};
|
||||
Point.origin = new Point(0, 0);
|
||||
return Point;
|
||||
})();
|
||||
|
||||
})(Shapes || (Shapes = {}));
|
||||
|
||||
var p = new Shapes.Point(3, 4);
|
||||
var dist = p.getDist();
|
54
Phaser/physics/aabb/ProjAABB45Deg.ts
Normal file
54
Phaser/physics/aabb/ProjAABB45Deg.ts
Normal file
|
@ -0,0 +1,54 @@
|
|||
/// <reference path="../../_definitions.ts" />
|
||||
|
||||
/**
|
||||
* Phaser - Physics - Projection
|
||||
*/
|
||||
|
||||
module Phaser.Physics.Projection {
|
||||
|
||||
export class AABB45Deg {
|
||||
|
||||
public static Collide(x: number, y: number, obj: Phaser.Physics.AABB, t: Phaser.Physics.TileMapCell) {
|
||||
|
||||
var signx = t.signx;
|
||||
var signy = t.signy;
|
||||
|
||||
var ox = (obj.pos.x - (signx * obj.xw)) - t.pos.x;//this gives is the coordinates of the innermost
|
||||
var oy = (obj.pos.y - (signy * obj.yw)) - t.pos.y;//point on the AABB, relative to the tile center
|
||||
|
||||
var sx = t.sx;
|
||||
var sy = t.sy;
|
||||
|
||||
//if the dotprod of (ox,oy) and (sx,sy) is negative, the corner is in the slope
|
||||
//and we need toproject it out by the magnitude of the projection of (ox,oy) onto (sx,sy)
|
||||
var dp = (ox * sx) + (oy * sy);
|
||||
|
||||
if (dp < 0)
|
||||
{
|
||||
//collision; project delta onto slope and use this to displace the object
|
||||
sx *= -dp;//(sx,sy) is now the projection vector
|
||||
sy *= -dp;
|
||||
|
||||
var lenN = Math.sqrt(sx * sx + sy * sy);
|
||||
var lenP = Math.sqrt(x * x + y * y);
|
||||
|
||||
if (lenP < lenN)
|
||||
{
|
||||
//project along axis
|
||||
obj.reportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
|
||||
return Phaser.Physics.AABB.COL_AXIS;
|
||||
}
|
||||
else
|
||||
{
|
||||
//project along slope
|
||||
obj.reportCollisionVsWorld(sx, sy, t.sx, t.sy);
|
||||
|
||||
return Phaser.Physics.AABB.COL_OTHER;
|
||||
}
|
||||
}
|
||||
|
||||
return Phaser.Physics.AABB.COL_NONE;
|
||||
}
|
||||
}
|
||||
}
|
19
Phaser/physics/aabb/ProjAABB67Deg.js
Normal file
19
Phaser/physics/aabb/ProjAABB67Deg.js
Normal file
|
@ -0,0 +1,19 @@
|
|||
var Shapes;
|
||||
(function (Shapes) {
|
||||
|
||||
var Point = Shapes.Point = (function () {
|
||||
function Point(x, y) {
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
}
|
||||
Point.prototype.getDist = function () {
|
||||
return Math.sqrt((this.x * this.x) + (this.y * this.y));
|
||||
};
|
||||
Point.origin = new Point(0, 0);
|
||||
return Point;
|
||||
})();
|
||||
|
||||
})(Shapes || (Shapes = {}));
|
||||
|
||||
var p = new Shapes.Point(3, 4);
|
||||
var dist = p.getDist();
|
124
Phaser/physics/aabb/ProjAABB67Deg.ts
Normal file
124
Phaser/physics/aabb/ProjAABB67Deg.ts
Normal file
|
@ -0,0 +1,124 @@
|
|||
/// <reference path="../../_definitions.ts" />
|
||||
|
||||
/**
|
||||
* Phaser - Physics - Projection
|
||||
*/
|
||||
|
||||
module Phaser.Physics.Projection {
|
||||
|
||||
export class AABB67Deg {
|
||||
|
||||
public static CollideS(x: number, y: number, obj: Phaser.Physics.AABB, t: Phaser.Physics.TileMapCell) {
|
||||
|
||||
var signx = t.signx;
|
||||
var signy = t.signy;
|
||||
|
||||
var px = obj.pos.x - (signx * obj.xw);
|
||||
var penX = t.pos.x - px;
|
||||
|
||||
if (0 < (penX * signx))
|
||||
{
|
||||
|
||||
var ox = (obj.pos.x - (signx * obj.xw)) - (t.pos.x - (signx * t.xw));//this gives is the coordinates of the innermost
|
||||
var oy = (obj.pos.y - (signy * obj.yw)) - (t.pos.y + (signy * t.yw));//point on the AABB, relative to a point on the slope
|
||||
|
||||
var sx = t.sx;//get slope unit normal
|
||||
var sy = t.sy;
|
||||
|
||||
//if the dotprod of (ox,oy) and (sx,sy) is negative, the corner is in the slope
|
||||
//and we need to project it out by the magnitude of the projection of (ox,oy) onto (sx,sy)
|
||||
var dp = (ox * sx) + (oy * sy);
|
||||
if (dp < 0)
|
||||
{
|
||||
//collision; project delta onto slope and use this to displace the object
|
||||
sx *= -dp;//(sx,sy) is now the projection vector
|
||||
sy *= -dp;
|
||||
|
||||
var lenN = Math.sqrt(sx * sx + sy * sy);
|
||||
var lenP = Math.sqrt(x * x + y * y);
|
||||
|
||||
var aX = Math.abs(penX);
|
||||
if (lenP < lenN)
|
||||
{
|
||||
if (aX < lenP)
|
||||
{
|
||||
obj.reportCollisionVsWorld(penX, 0, penX / aX, 0, t);
|
||||
|
||||
return Phaser.Physics.AABB.COL_OTHER;
|
||||
}
|
||||
else
|
||||
{
|
||||
obj.reportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
|
||||
return Phaser.Physics.AABB.COL_AXIS;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (aX < lenN)
|
||||
{
|
||||
obj.reportCollisionVsWorld(penX, 0, penX / aX, 0, t);
|
||||
|
||||
return Phaser.Physics.AABB.COL_OTHER;
|
||||
}
|
||||
else
|
||||
{
|
||||
obj.reportCollisionVsWorld(sx, sy, t.sx, t.sy, t);
|
||||
|
||||
return Phaser.Physics.AABB.COL_OTHER;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//if we've reached this point, no collision has occured
|
||||
return Phaser.Physics.AABB.COL_NONE;
|
||||
|
||||
}
|
||||
|
||||
public static CollideB(x: number, y: number, obj: Phaser.Physics.AABB, t: Phaser.Physics.TileMapCell) {
|
||||
|
||||
var signx = t.signx;
|
||||
var signy = t.signy;
|
||||
|
||||
var ox = (obj.pos.x - (signx * obj.xw)) - (t.pos.x + (signx * t.xw));//this gives is the coordinates of the innermost
|
||||
var oy = (obj.pos.y - (signy * obj.yw)) - (t.pos.y - (signy * t.yw));//point on the AABB, relative to a point on the slope
|
||||
|
||||
var sx = t.sx;//get slope unit normal
|
||||
var sy = t.sy;
|
||||
|
||||
//if the dotprod of (ox,oy) and (sx,sy) is negative, the corner is in the slope
|
||||
//and we need toproject it out by the magnitude of the projection of (ox,oy) onto (sx,sy)
|
||||
var dp = (ox * sx) + (oy * sy);
|
||||
|
||||
if (dp < 0)
|
||||
{
|
||||
//collision; project delta onto slope and use this to displace the object
|
||||
sx *= -dp;//(sx,sy) is now the projection vector
|
||||
sy *= -dp;
|
||||
|
||||
var lenN = Math.sqrt(sx * sx + sy * sy);
|
||||
var lenP = Math.sqrt(x * x + y * y);
|
||||
|
||||
|
||||
if (lenP < lenN)
|
||||
{
|
||||
obj.reportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
|
||||
return Phaser.Physics.AABB.COL_AXIS;
|
||||
}
|
||||
else
|
||||
{
|
||||
obj.reportCollisionVsWorld(sx, sy, t.sx, t.sy, t);
|
||||
|
||||
return Phaser.Physics.AABB.COL_OTHER;
|
||||
}
|
||||
}
|
||||
|
||||
return Phaser.Physics.AABB.COL_NONE;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
|
@ -30,7 +30,7 @@ var Phaser;
|
|||
var lenP = Math.sqrt(x * x + y * y);
|
||||
if (lenP < pen) {
|
||||
//it's shorter to move along axis directions
|
||||
obj.ReportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
obj.reportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
|
||||
return Phaser.Physics.AABB.COL_AXIS;
|
||||
} else {
|
||||
|
@ -38,7 +38,7 @@ var Phaser;
|
|||
ox /= len;
|
||||
oy /= len;
|
||||
|
||||
obj.ReportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
|
||||
return Phaser.Physics.AABB.COL_OTHER;
|
||||
}
|
||||
|
|
|
@ -34,7 +34,7 @@ module Phaser.Physics.Projection {
|
|||
if (lenP < pen)
|
||||
{
|
||||
//it's shorter to move along axis directions
|
||||
obj.ReportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
obj.reportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
|
||||
return Phaser.Physics.AABB.COL_AXIS;
|
||||
}
|
||||
|
@ -44,7 +44,7 @@ module Phaser.Physics.Projection {
|
|||
ox /= len;//len should never be 0, since if it IS 0, rad should be > than len
|
||||
oy /= len;//and we should never reach here
|
||||
|
||||
obj.ReportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
|
||||
return Phaser.Physics.AABB.COL_OTHER;
|
||||
}
|
||||
|
|
|
@ -27,14 +27,14 @@ var Phaser;
|
|||
if (((signx * ox) < 0) || ((signy * oy) < 0)) {
|
||||
//the test corner is "outside" the 1/4 of the circle we're interested in
|
||||
var lenP = Math.sqrt(x * x + y * y);
|
||||
obj.ReportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
obj.reportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
|
||||
return Phaser.Physics.AABB.COL_AXIS;
|
||||
} else if (0 < pen) {
|
||||
//project along corner->circle vector
|
||||
ox /= len;
|
||||
oy /= len;
|
||||
obj.ReportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
|
||||
return Phaser.Physics.AABB.COL_OTHER;
|
||||
}
|
||||
|
|
|
@ -29,7 +29,7 @@ module Phaser.Physics.Projection {
|
|||
{
|
||||
//the test corner is "outside" the 1/4 of the circle we're interested in
|
||||
var lenP = Math.sqrt(x * x + y * y);
|
||||
obj.ReportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
obj.reportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
|
||||
return Phaser.Physics.AABB.COL_AXIS;//we need to report
|
||||
}
|
||||
|
@ -38,7 +38,7 @@ module Phaser.Physics.Projection {
|
|||
//project along corner->circle vector
|
||||
ox /= len;
|
||||
oy /= len;
|
||||
obj.ReportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
|
||||
return Phaser.Physics.AABB.COL_OTHER;
|
||||
}
|
||||
|
|
|
@ -12,7 +12,7 @@ var Phaser;
|
|||
AABBFull.Collide = function (x, y, obj, t) {
|
||||
var l = Math.sqrt(x * x + y * y);
|
||||
|
||||
obj.ReportCollisionVsWorld(x, y, x / l, y / l, t);
|
||||
obj.reportCollisionVsWorld(x, y, x / l, y / l, t);
|
||||
|
||||
return Phaser.Physics.AABB.COL_AXIS;
|
||||
};
|
||||
|
|
|
@ -12,7 +12,7 @@ module Phaser.Physics.Projection {
|
|||
|
||||
var l = Math.sqrt(x * x + y * y);
|
||||
|
||||
obj.ReportCollisionVsWorld(x, y, x / l, y / l, t);
|
||||
obj.reportCollisionVsWorld(x, y, x / l, y / l, t);
|
||||
|
||||
return Phaser.Physics.AABB.COL_AXIS;
|
||||
|
||||
|
|
19
Phaser/physics/aabb/ProjAABBHalf.js
Normal file
19
Phaser/physics/aabb/ProjAABBHalf.js
Normal file
|
@ -0,0 +1,19 @@
|
|||
var Shapes;
|
||||
(function (Shapes) {
|
||||
|
||||
var Point = Shapes.Point = (function () {
|
||||
function Point(x, y) {
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
}
|
||||
Point.prototype.getDist = function () {
|
||||
return Math.sqrt((this.x * this.x) + (this.y * this.y));
|
||||
};
|
||||
Point.origin = new Point(0, 0);
|
||||
return Point;
|
||||
})();
|
||||
|
||||
})(Shapes || (Shapes = {}));
|
||||
|
||||
var p = new Shapes.Point(3, 4);
|
||||
var dist = p.getDist();
|
60
Phaser/physics/aabb/ProjAABBHalf.ts
Normal file
60
Phaser/physics/aabb/ProjAABBHalf.ts
Normal file
|
@ -0,0 +1,60 @@
|
|||
/// <reference path="../../_definitions.ts" />
|
||||
|
||||
/**
|
||||
* Phaser - Physics - Projection
|
||||
*/
|
||||
|
||||
module Phaser.Physics.Projection {
|
||||
|
||||
export class AABBHalf {
|
||||
|
||||
public static Collide(x: number, y: number, obj: Phaser.Physics.AABB, t: Phaser.Physics.TileMapCell) {
|
||||
|
||||
//calculate the projection vector for the half-edge, and then
|
||||
//(if collision is occuring) pick the minimum
|
||||
|
||||
var sx = t.signx;
|
||||
var sy = t.signy;
|
||||
|
||||
var ox = (obj.pos.x - (sx * obj.xw)) - t.pos.x;//this gives is the coordinates of the innermost
|
||||
var oy = (obj.pos.y - (sy * obj.yw)) - t.pos.y;//point on the AABB, relative to the tile center
|
||||
|
||||
//we perform operations analogous to the 45deg tile, except we're using
|
||||
//an axis-aligned slope instead of an angled one..
|
||||
|
||||
//if the dotprod of (ox,oy) and (sx,sy) is negative, the corner is in the slope
|
||||
//and we need toproject it out by the magnitude of the projection of (ox,oy) onto (sx,sy)
|
||||
var dp = (ox * sx) + (oy * sy);
|
||||
if (dp < 0)
|
||||
{
|
||||
//collision; project delta onto slope and use this to displace the object
|
||||
sx *= -dp;//(sx,sy) is now the projection vector
|
||||
sy *= -dp;
|
||||
|
||||
var lenN = Math.sqrt(sx * sx + sy * sy);
|
||||
var lenP = Math.sqrt(x * x + y * y);
|
||||
|
||||
if (lenP < lenN)
|
||||
{
|
||||
//project along axis; note that we're assuming that this tile is horizontal OR vertical
|
||||
//relative to the AABB's current tile, and not diagonal OR the current tile.
|
||||
obj.reportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
|
||||
return Phaser.Physics.AABB.COL_AXIS;
|
||||
}
|
||||
else
|
||||
{
|
||||
//note that we could use -= instead of -dp
|
||||
obj.reportCollisionVsWorld(sx, sy, t.signx, t.signy, t);
|
||||
|
||||
return Phaser.Physics.AABB.COL_OTHER;
|
||||
}
|
||||
}
|
||||
|
||||
return Phaser.Physics.AABB.COL_NONE;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
19
Phaser/physics/circle/ProjCircle22Deg.js
Normal file
19
Phaser/physics/circle/ProjCircle22Deg.js
Normal file
|
@ -0,0 +1,19 @@
|
|||
var Shapes;
|
||||
(function (Shapes) {
|
||||
|
||||
var Point = Shapes.Point = (function () {
|
||||
function Point(x, y) {
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
}
|
||||
Point.prototype.getDist = function () {
|
||||
return Math.sqrt((this.x * this.x) + (this.y * this.y));
|
||||
};
|
||||
Point.origin = new Point(0, 0);
|
||||
return Point;
|
||||
})();
|
||||
|
||||
})(Shapes || (Shapes = {}));
|
||||
|
||||
var p = new Shapes.Point(3, 4);
|
||||
var dist = p.getDist();
|
597
Phaser/physics/circle/ProjCircle22Deg.ts
Normal file
597
Phaser/physics/circle/ProjCircle22Deg.ts
Normal file
|
@ -0,0 +1,597 @@
|
|||
/// <reference path="../../_definitions.ts" />
|
||||
|
||||
/**
|
||||
* Phaser - Physics - Projection
|
||||
*/
|
||||
|
||||
module Phaser.Physics.Projection {
|
||||
|
||||
export class Circle22Deg {
|
||||
|
||||
public static CollideS(x, y, oH, oV, obj: Phaser.Physics.Circle, t: Phaser.Physics.TileMapCell) {
|
||||
|
||||
//if the object is in a cell pointed at by signy, no collision will ever occur
|
||||
//otherwise,
|
||||
//
|
||||
//if we're colliding diagonally:
|
||||
// -collide vs. the appropriate vertex
|
||||
//if obj is in this tile: collide vs slope or vertex
|
||||
//if obj is horiz neighb in direction of slope: collide vs. slope or vertex
|
||||
//if obj is horiz neighb against the slope:
|
||||
// if(distance in y from circle to 90deg corner of tile < 1/2 tileheight, collide vs. face)
|
||||
// else(collide vs. corner of slope) (vert collision with a non-grid-aligned vert)
|
||||
//if obj is vert neighb against direction of slope: collide vs. face
|
||||
|
||||
var signx = t.signx;
|
||||
var signy = t.signy;
|
||||
|
||||
if (0 < (signy * oV))
|
||||
{
|
||||
//object will never collide vs tile, it can't reach that far
|
||||
return Phaser.Physics.Circle.COL_NONE;
|
||||
}
|
||||
else if (oH == 0)
|
||||
{
|
||||
if (oV == 0)
|
||||
{
|
||||
//colliding with current tile
|
||||
//we could only be colliding vs the slope OR a vertex
|
||||
//look at the vector form the closest vert to the circle to decide
|
||||
|
||||
var sx = t.sx;
|
||||
var sy = t.sy;
|
||||
|
||||
var r = obj.radius;
|
||||
var ox = obj.pos.x - (t.pos.x - (signx * t.xw));//this gives is the coordinates of the innermost
|
||||
var oy = obj.pos.y - t.pos.y;//point on the circle, relative to the tile corner
|
||||
|
||||
//if the component of (ox,oy) parallel to the normal's righthand normal
|
||||
//has the same sign as the slope of the slope (the sign of the slope's slope is signx*signy)
|
||||
//then we project by the vertex, otherwise by the normal or axially.
|
||||
//note that this is simply a VERY tricky/weird method of determining
|
||||
//if the circle is in side the slope/face's voronio region, or that of the vertex.
|
||||
|
||||
var perp = (ox * -sy) + (oy * sx);
|
||||
|
||||
if (0 < (perp * signx * signy))
|
||||
{
|
||||
//collide vs. vertex
|
||||
var len = Math.sqrt(ox * ox + oy * oy);
|
||||
var pen = r - len;
|
||||
|
||||
if (0 < pen)
|
||||
{
|
||||
//note: if len=0, then perp=0 and we'll never reach here, so don't worry about div-by-0
|
||||
ox /= len;
|
||||
oy /= len;
|
||||
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//collide vs. slope or vs axis
|
||||
ox -= r * sx;//this gives us the vector from
|
||||
oy -= r * sy;//a point on the slope to the innermost point on the circle
|
||||
|
||||
//if the dotprod of (ox,oy) and (sx,sy) is negative, the point on the circle is in the slope
|
||||
//and we need toproject it out by the magnitude of the projection of (ox,oy) onto (sx,sy)
|
||||
var dp = (ox * sx) + (oy * sy);
|
||||
|
||||
if (dp < 0)
|
||||
{
|
||||
//collision; project delta onto slope and use this to displace the object
|
||||
sx *= -dp;//(sx,sy) is now the projection vector
|
||||
sy *= -dp;
|
||||
|
||||
var lenN = Math.sqrt(sx * sx + sy * sy);
|
||||
var lenP;
|
||||
|
||||
//find the smallest axial projection vector
|
||||
if (x < y)
|
||||
{
|
||||
//penetration in x is smaller
|
||||
lenP = x;
|
||||
y = 0;
|
||||
//get sign for projection along x-axis
|
||||
if ((obj.pos.x - t.pos.x) < 0)
|
||||
{
|
||||
x *= -1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//penetration in y is smaller
|
||||
lenP = y;
|
||||
x = 0;
|
||||
//get sign for projection along y-axis
|
||||
if ((obj.pos.y - t.pos.y) < 0)
|
||||
{
|
||||
y *= -1;
|
||||
}
|
||||
}
|
||||
|
||||
if (lenP < lenN)
|
||||
{
|
||||
obj.reportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
else
|
||||
{
|
||||
obj.reportCollisionVsWorld(sx, sy, t.sx, t.sy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
//colliding vertically; we can assume that (signy*oV) < 0
|
||||
//due to the first conditional far above
|
||||
|
||||
obj.reportCollisionVsWorld(0, y * oV, 0, oV, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
}
|
||||
else if (oV == 0)
|
||||
{
|
||||
//colliding horizontally
|
||||
if ((signx * oH) < 0)
|
||||
{
|
||||
//colliding with face/edge OR with corner of wedge, depending on our position vertically
|
||||
|
||||
//collide vs. vertex
|
||||
//get diag vertex position
|
||||
var vx = t.pos.x - (signx * t.xw);
|
||||
var vy = t.pos.y;
|
||||
|
||||
var dx = obj.pos.x - vx;//calc vert->circle vector
|
||||
var dy = obj.pos.y - vy;
|
||||
|
||||
if ((dy * signy) < 0)
|
||||
{
|
||||
//colliding vs face
|
||||
obj.reportCollisionVsWorld(x * oH, 0, oH, 0, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
else
|
||||
{
|
||||
//colliding vs. vertex
|
||||
|
||||
var len = Math.sqrt(dx * dx + dy * dy);
|
||||
var pen = obj.radius - len;
|
||||
|
||||
if (0 < pen)
|
||||
{
|
||||
//vertex is in the circle; project outward
|
||||
if (len == 0)
|
||||
{
|
||||
//project out by 45deg
|
||||
dx = oH / Math.SQRT2;
|
||||
dy = oV / Math.SQRT2;
|
||||
}
|
||||
else
|
||||
{
|
||||
dx /= len;
|
||||
dy /= len;
|
||||
}
|
||||
|
||||
obj.reportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//we could only be colliding vs the slope OR a vertex
|
||||
//look at the vector form the closest vert to the circle to decide
|
||||
|
||||
var sx = t.sx;
|
||||
var sy = t.sy;
|
||||
|
||||
var ox = obj.pos.x - (t.pos.x + (oH * t.xw));//this gives is the coordinates of the innermost
|
||||
var oy = obj.pos.y - (t.pos.y - (signy * t.yw));//point on the circle, relative to the closest tile vert
|
||||
|
||||
//if the component of (ox,oy) parallel to the normal's righthand normal
|
||||
//has the same sign as the slope of the slope (the sign of the slope's slope is signx*signy)
|
||||
//then we project by the normal, otherwise by the vertex.
|
||||
//(NOTE: this is the opposite logic of the vertical case;
|
||||
// for vertical, if the perp prod and the slope's slope agree, it's outside.
|
||||
// for horizontal, if the perp prod and the slope's slope agree, circle is inside.
|
||||
// ..but this is only a property of flahs' coord system (i.e the rules might swap
|
||||
// in righthanded systems))
|
||||
//note that this is simply a VERY tricky/weird method of determining
|
||||
//if the circle is in side the slope/face's voronio region, or that of the vertex.
|
||||
var perp = (ox * -sy) + (oy * sx);
|
||||
|
||||
if ((perp * signx * signy) < 0)
|
||||
{
|
||||
//collide vs. vertex
|
||||
var len = Math.sqrt(ox * ox + oy * oy);
|
||||
var pen = obj.radius - len;
|
||||
|
||||
if (0 < pen)
|
||||
{
|
||||
//note: if len=0, then perp=0 and we'll never reach here, so don't worry about div-by-0
|
||||
ox /= len;
|
||||
oy /= len;
|
||||
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//collide vs. slope
|
||||
|
||||
//if the component of (ox,oy) parallel to the normal is less than the circle radius, we're
|
||||
//penetrating the slope. note that this method of penetration calculation doesn't hold
|
||||
//in general (i.e it won't work if the circle is in the slope), but works in this case
|
||||
//because we know the circle is in a neighboring cell
|
||||
var dp = (ox * sx) + (oy * sy);
|
||||
var pen = obj.radius - Math.abs(dp);//note: we don't need the abs because we know the dp will be positive, but just in case..
|
||||
|
||||
if (0 < pen)
|
||||
{
|
||||
//collision; circle out along normal by penetration amount
|
||||
obj.reportCollisionVsWorld(sx * pen, sy * pen, sx, sy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//colliding diagonally; due to the first conditional above,
|
||||
//obj is vertically offset against slope, and offset in either direction horizontally
|
||||
|
||||
//collide vs. vertex
|
||||
//get diag vertex position
|
||||
var vx = t.pos.x + (oH * t.xw);
|
||||
var vy = t.pos.y + (oV * t.yw);
|
||||
|
||||
var dx = obj.pos.x - vx;//calc vert->circle vector
|
||||
var dy = obj.pos.y - vy;
|
||||
|
||||
var len = Math.sqrt(dx * dx + dy * dy);
|
||||
var pen = obj.radius - len;
|
||||
|
||||
if (0 < pen)
|
||||
{
|
||||
//vertex is in the circle; project outward
|
||||
if (len == 0)
|
||||
{
|
||||
//project out by 45deg
|
||||
dx = oH / Math.SQRT2;
|
||||
dy = oV / Math.SQRT2;
|
||||
}
|
||||
else
|
||||
{
|
||||
dx /= len;
|
||||
dy /= len;
|
||||
}
|
||||
|
||||
obj.reportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
}
|
||||
|
||||
return Phaser.Physics.Circle.COL_NONE;
|
||||
|
||||
}
|
||||
|
||||
public static CollideB(x, y, oH, oV, obj: Phaser.Physics.Circle, t: Phaser.Physics.TileMapCell) {
|
||||
|
||||
//if we're colliding diagonally:
|
||||
// -if we're in the cell pointed at by the normal, collide vs slope, else
|
||||
// collide vs. the appropriate corner/vertex
|
||||
//
|
||||
//if obj is in this tile: collide as with aabb
|
||||
//
|
||||
//if obj is horiz or vertical neighbor AGAINST the slope: collide with edge
|
||||
//
|
||||
//if obj is horiz neighb in direction of slope: collide vs. slope or vertex or edge
|
||||
//
|
||||
//if obj is vert neighb in direction of slope: collide vs. slope or vertex
|
||||
|
||||
var signx = t.signx;
|
||||
var signy = t.signy;
|
||||
var sx: number;
|
||||
var sy: number;
|
||||
|
||||
if (oH == 0)
|
||||
{
|
||||
if (oV == 0)
|
||||
{
|
||||
//colliding with current cell
|
||||
|
||||
sx = t.sx;
|
||||
sy = t.sy;
|
||||
|
||||
var r = obj.radius;
|
||||
var ox = (obj.pos.x - (sx * r)) - (t.pos.x - (signx * t.xw));//this gives is the coordinates of the innermost
|
||||
var oy = (obj.pos.y - (sy * r)) - (t.pos.y + (signy * t.yw));//point on the AABB, relative to a point on the slope
|
||||
|
||||
//if the dotprod of (ox,oy) and (sx,sy) is negative, the point on the circle is in the slope
|
||||
//and we need toproject it out by the magnitude of the projection of (ox,oy) onto (sx,sy)
|
||||
var dp = (ox * sx) + (oy * sy);
|
||||
|
||||
if (dp < 0)
|
||||
{
|
||||
//collision; project delta onto slope and use this to displace the object
|
||||
sx *= -dp;//(sx,sy) is now the projection vector
|
||||
sy *= -dp;
|
||||
|
||||
var lenN = Math.sqrt(sx * sx + sy * sy);
|
||||
var lenP;
|
||||
|
||||
//find the smallest axial projection vector
|
||||
if (x < y)
|
||||
{
|
||||
//penetration in x is smaller
|
||||
lenP = x;
|
||||
y = 0;
|
||||
//get sign for projection along x-axis
|
||||
if ((obj.pos.x - t.pos.x) < 0)
|
||||
{
|
||||
x *= -1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//penetration in y is smaller
|
||||
lenP = y;
|
||||
x = 0;
|
||||
//get sign for projection along y-axis
|
||||
if ((obj.pos.y - t.pos.y) < 0)
|
||||
{
|
||||
y *= -1;
|
||||
}
|
||||
}
|
||||
|
||||
if (lenP < lenN)
|
||||
{
|
||||
obj.reportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
else
|
||||
{
|
||||
obj.reportCollisionVsWorld(sx, sy, t.sx, t.sy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//colliding vertically
|
||||
|
||||
if ((signy * oV) < 0)
|
||||
{
|
||||
//colliding with face/edge
|
||||
obj.reportCollisionVsWorld(0, y * oV, 0, oV, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
else
|
||||
{
|
||||
//we could only be colliding vs the slope OR a vertex
|
||||
//look at the vector form the closest vert to the circle to decide
|
||||
|
||||
sx = t.sx;
|
||||
sy = t.sy;
|
||||
|
||||
var ox = obj.pos.x - (t.pos.x - (signx * t.xw));//this gives is the coordinates of the innermost
|
||||
var oy = obj.pos.y - (t.pos.y + (signy * t.yw));//point on the circle, relative to the closest tile vert
|
||||
|
||||
//if the component of (ox,oy) parallel to the normal's righthand normal
|
||||
//has the same sign as the slope of the slope (the sign of the slope's slope is signx*signy)
|
||||
//then we project by the vertex, otherwise by the normal.
|
||||
//note that this is simply a VERY tricky/weird method of determining
|
||||
//if the circle is in side the slope/face's voronio region, or that of the vertex.
|
||||
var perp = (ox * -sy) + (oy * sx);
|
||||
|
||||
if (0 < (perp * signx * signy))
|
||||
{
|
||||
//collide vs. vertex
|
||||
var len = Math.sqrt(ox * ox + oy * oy);
|
||||
var pen = obj.radius - len;
|
||||
|
||||
if (0 < pen)
|
||||
{
|
||||
//note: if len=0, then perp=0 and we'll never reach here, so don't worry about div-by-0
|
||||
ox /= len;
|
||||
oy /= len;
|
||||
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//collide vs. slope
|
||||
|
||||
//if the component of (ox,oy) parallel to the normal is less than the circle radius, we're
|
||||
//penetrating the slope. note that this method of penetration calculation doesn't hold
|
||||
//in general (i.e it won't work if the circle is in the slope), but works in this case
|
||||
//because we know the circle is in a neighboring cell
|
||||
var dp = (ox * sx) + (oy * sy);
|
||||
var pen = obj.radius - Math.abs(dp);//note: we don't need the abs because we know the dp will be positive, but just in case..
|
||||
|
||||
if (0 < pen)
|
||||
{
|
||||
//collision; circle out along normal by penetration amount
|
||||
obj.reportCollisionVsWorld(sx * pen, sy * pen, sx, sy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (oV == 0)
|
||||
{
|
||||
//colliding horizontally
|
||||
|
||||
if ((signx * oH) < 0)
|
||||
{
|
||||
//colliding with face/edge
|
||||
obj.reportCollisionVsWorld(x * oH, 0, oH, 0, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
else
|
||||
{
|
||||
//colliding with edge, slope, or vertex
|
||||
|
||||
var ox = obj.pos.x - (t.pos.x + (signx * t.xw));//this gives is the coordinates of the innermost
|
||||
var oy = obj.pos.y - t.pos.y;//point on the circle, relative to the closest tile vert
|
||||
|
||||
if ((oy * signy) < 0)
|
||||
{
|
||||
//we're colliding with the halfface
|
||||
obj.reportCollisionVsWorld(x * oH, 0, oH, 0, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
else
|
||||
{
|
||||
//colliding with the vertex or slope
|
||||
|
||||
sx = t.sx;
|
||||
sy = t.sy;
|
||||
|
||||
//if the component of (ox,oy) parallel to the normal's righthand normal
|
||||
//has the same sign as the slope of the slope (the sign of the slope's slope is signx*signy)
|
||||
//then we project by the slope, otherwise by the vertex.
|
||||
//note that this is simply a VERY tricky/weird method of determining
|
||||
//if the circle is in side the slope/face's voronio region, or that of the vertex.
|
||||
var perp = (ox * -sy) + (oy * sx);
|
||||
|
||||
if ((perp * signx * signy) < 0)
|
||||
{
|
||||
//collide vs. vertex
|
||||
var len = Math.sqrt(ox * ox + oy * oy);
|
||||
var pen = obj.radius - len;
|
||||
|
||||
if (0 < pen)
|
||||
{
|
||||
//note: if len=0, then perp=0 and we'll never reach here, so don't worry about div-by-0
|
||||
ox /= len;
|
||||
oy /= len;
|
||||
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//collide vs. slope
|
||||
|
||||
//if the component of (ox,oy) parallel to the normal is less than the circle radius, we're
|
||||
//penetrating the slope. note that this method of penetration calculation doesn't hold
|
||||
//in general (i.e it won't work if the circle is in the slope), but works in this case
|
||||
//because we know the circle is in a neighboring cell
|
||||
var dp = (ox * sx) + (oy * sy);
|
||||
var pen = obj.radius - Math.abs(dp);//note: we don't need the abs because we know the dp will be positive, but just in case..
|
||||
|
||||
if (0 < pen)
|
||||
{
|
||||
//collision; circle out along normal by penetration amount
|
||||
obj.reportCollisionVsWorld(sx * pen, sy * pen, t.sx, t.sy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//colliding diagonally
|
||||
if (0 < ((signx * oH) + (signy * oV)))
|
||||
{
|
||||
//the dotprod of slope normal and cell offset is strictly positive,
|
||||
//therefore obj is in the diagonal neighb pointed at by the normal.
|
||||
|
||||
//collide vs slope
|
||||
|
||||
//we should really precalc this at compile time, but for now, fuck it
|
||||
var slen: number = Math.sqrt(2 * 2 + 1 * 1);//the raw slope is (-2,-1)
|
||||
sx = (signx * 1) / slen;//get slope _unit_ normal;
|
||||
sy = (signy * 2) / slen;//raw RH normal is (1,-2)
|
||||
|
||||
var r = obj.radius;
|
||||
var ox = (obj.pos.x - (sx * r)) - (t.pos.x - (signx * t.xw));//this gives is the coordinates of the innermost
|
||||
var oy = (obj.pos.y - (sy * r)) - (t.pos.y + (signy * t.yw));//point on the circle, relative to a point on the slope
|
||||
|
||||
//if the dotprod of (ox,oy) and (sx,sy) is negative, the point on the circle is in the slope
|
||||
//and we need toproject it out by the magnitude of the projection of (ox,oy) onto (sx,sy)
|
||||
var dp = (ox * sx) + (oy * sy);
|
||||
|
||||
if (dp < 0)
|
||||
{
|
||||
//collision; project delta onto slope and use this to displace the object
|
||||
//(sx,sy)*-dp is the projection vector
|
||||
obj.reportCollisionVsWorld(-sx * dp, -sy * dp, t.sx, t.sy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
return Phaser.Physics.Circle.COL_NONE;
|
||||
}
|
||||
else
|
||||
{
|
||||
//collide vs the appropriate vertex
|
||||
var vx = t.pos.x + (oH * t.xw);
|
||||
var vy = t.pos.y + (oV * t.yw);
|
||||
|
||||
var dx = obj.pos.x - vx;//calc vert->circle vector
|
||||
var dy = obj.pos.y - vy;
|
||||
|
||||
var len = Math.sqrt(dx * dx + dy * dy);
|
||||
var pen = obj.radius - len;
|
||||
|
||||
if (0 < pen)
|
||||
{
|
||||
//vertex is in the circle; project outward
|
||||
if (len == 0)
|
||||
{
|
||||
//project out by 45deg
|
||||
dx = oH / Math.SQRT2;
|
||||
dy = oV / Math.SQRT2;
|
||||
}
|
||||
else
|
||||
{
|
||||
dx /= len;
|
||||
dy /= len;
|
||||
}
|
||||
|
||||
obj.reportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
return Phaser.Physics.Circle.COL_NONE;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
|
@ -58,11 +58,11 @@ var Phaser;
|
|||
var lenN = Math.sqrt(sx * sx + sy * sy);
|
||||
|
||||
if (lenP < lenN) {
|
||||
obj.ReportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
obj.reportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
} else {
|
||||
obj.ReportCollisionVsWorld(sx, sy, t.sx, t.sy, t);
|
||||
obj.reportCollisionVsWorld(sx, sy, t.sx, t.sy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
@ -70,7 +70,7 @@ var Phaser;
|
|||
} else {
|
||||
if ((signy * oV) < 0) {
|
||||
//colliding with face/edge
|
||||
obj.ReportCollisionVsWorld(0, y * oV, 0, oV, t);
|
||||
obj.reportCollisionVsWorld(0, y * oV, 0, oV, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
} else {
|
||||
|
@ -97,7 +97,7 @@ var Phaser;
|
|||
ox /= len;
|
||||
oy /= len;
|
||||
|
||||
obj.ReportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
@ -111,7 +111,7 @@ var Phaser;
|
|||
var pen = obj.radius - Math.abs(dp);
|
||||
if (0 < pen) {
|
||||
//collision; circle out along normal by penetration amount
|
||||
obj.ReportCollisionVsWorld(sx * pen, sy * pen, sx, sy, t);
|
||||
obj.reportCollisionVsWorld(sx * pen, sy * pen, sx, sy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
@ -121,7 +121,7 @@ var Phaser;
|
|||
} else if (oV == 0) {
|
||||
if ((signx * oH) < 0) {
|
||||
//colliding with face/edge
|
||||
obj.ReportCollisionVsWorld(x * oH, 0, oH, 0, t);
|
||||
obj.reportCollisionVsWorld(x * oH, 0, oH, 0, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
} else {
|
||||
|
@ -153,7 +153,7 @@ var Phaser;
|
|||
ox /= len;
|
||||
oy /= len;
|
||||
|
||||
obj.ReportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
@ -167,7 +167,7 @@ var Phaser;
|
|||
var pen = obj.radius - Math.abs(dp);
|
||||
if (0 < pen) {
|
||||
//collision; circle out along normal by penetration amount
|
||||
obj.ReportCollisionVsWorld(sx * pen, sy * pen, sx, sy, t);
|
||||
obj.reportCollisionVsWorld(sx * pen, sy * pen, sx, sy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
@ -200,7 +200,7 @@ var Phaser;
|
|||
dy /= len;
|
||||
}
|
||||
|
||||
obj.ReportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
obj.reportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -72,13 +72,13 @@ module Phaser.Physics.Projection {
|
|||
|
||||
if (lenP < lenN)
|
||||
{
|
||||
obj.ReportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
obj.reportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
else
|
||||
{
|
||||
obj.ReportCollisionVsWorld(sx, sy, t.sx, t.sy, t);
|
||||
obj.reportCollisionVsWorld(sx, sy, t.sx, t.sy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
@ -91,7 +91,7 @@ module Phaser.Physics.Projection {
|
|||
if ((signy * oV) < 0)
|
||||
{
|
||||
//colliding with face/edge
|
||||
obj.ReportCollisionVsWorld(0, y * oV, 0, oV, t);
|
||||
obj.reportCollisionVsWorld(0, y * oV, 0, oV, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
|
@ -123,7 +123,7 @@ module Phaser.Physics.Projection {
|
|||
ox /= len;
|
||||
oy /= len;
|
||||
|
||||
obj.ReportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
@ -141,7 +141,7 @@ module Phaser.Physics.Projection {
|
|||
if (0 < pen)
|
||||
{
|
||||
//collision; circle out along normal by penetration amount
|
||||
obj.ReportCollisionVsWorld(sx * pen, sy * pen, sx, sy, t);
|
||||
obj.reportCollisionVsWorld(sx * pen, sy * pen, sx, sy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
@ -155,7 +155,7 @@ module Phaser.Physics.Projection {
|
|||
if ((signx * oH) < 0)
|
||||
{
|
||||
//colliding with face/edge
|
||||
obj.ReportCollisionVsWorld(x * oH, 0, oH, 0, t);
|
||||
obj.reportCollisionVsWorld(x * oH, 0, oH, 0, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
|
@ -192,7 +192,7 @@ module Phaser.Physics.Projection {
|
|||
ox /= len;
|
||||
oy /= len;
|
||||
|
||||
obj.ReportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
@ -210,7 +210,7 @@ module Phaser.Physics.Projection {
|
|||
if (0 < pen)
|
||||
{
|
||||
//collision; circle out along normal by penetration amount
|
||||
obj.ReportCollisionVsWorld(sx * pen, sy * pen, sx, sy, t);
|
||||
obj.reportCollisionVsWorld(sx * pen, sy * pen, sx, sy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
@ -254,7 +254,7 @@ module Phaser.Physics.Projection {
|
|||
dy /= len;
|
||||
}
|
||||
|
||||
obj.ReportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
obj.reportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
||||
|
|
19
Phaser/physics/circle/ProjCircle67Deg.js
Normal file
19
Phaser/physics/circle/ProjCircle67Deg.js
Normal file
|
@ -0,0 +1,19 @@
|
|||
var Shapes;
|
||||
(function (Shapes) {
|
||||
|
||||
var Point = Shapes.Point = (function () {
|
||||
function Point(x, y) {
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
}
|
||||
Point.prototype.getDist = function () {
|
||||
return Math.sqrt((this.x * this.x) + (this.y * this.y));
|
||||
};
|
||||
Point.origin = new Point(0, 0);
|
||||
return Point;
|
||||
})();
|
||||
|
||||
})(Shapes || (Shapes = {}));
|
||||
|
||||
var p = new Shapes.Point(3, 4);
|
||||
var dist = p.getDist();
|
591
Phaser/physics/circle/ProjCircle67Deg.ts
Normal file
591
Phaser/physics/circle/ProjCircle67Deg.ts
Normal file
|
@ -0,0 +1,591 @@
|
|||
/// <reference path="../../_definitions.ts" />
|
||||
|
||||
/**
|
||||
* Phaser - Physics - Projection
|
||||
*/
|
||||
|
||||
module Phaser.Physics.Projection {
|
||||
|
||||
export class Circle67Deg {
|
||||
|
||||
public static CollideS(x, y, oH, oV, obj: Phaser.Physics.Circle, t: Phaser.Physics.TileMapCell) {
|
||||
|
||||
//if the object is in a cell pointed at by signx, no collision will ever occur
|
||||
//otherwise,
|
||||
//
|
||||
//if we're colliding diagonally:
|
||||
// -collide vs. the appropriate vertex
|
||||
//if obj is in this tile: collide vs slope or vertex or axis
|
||||
//if obj is vert neighb in direction of slope: collide vs. slope or vertex
|
||||
//if obj is vert neighb against the slope:
|
||||
// if(distance in y from circle to 90deg corner of tile < 1/2 tileheight, collide vs. face)
|
||||
// else(collide vs. corner of slope) (vert collision with a non-grid-aligned vert)
|
||||
//if obj is horiz neighb against direction of slope: collide vs. face
|
||||
|
||||
var signx = t.signx;
|
||||
var signy = t.signy;
|
||||
var sx: number;
|
||||
var sy: number;
|
||||
|
||||
if (0 < (signx * oH))
|
||||
{
|
||||
//object will never collide vs tile, it can't reach that far
|
||||
return Phaser.Physics.Circle.COL_NONE;
|
||||
}
|
||||
else if (oH == 0)
|
||||
{
|
||||
if (oV == 0)
|
||||
{
|
||||
//colliding with current tile
|
||||
//we could only be colliding vs the slope OR a vertex
|
||||
//look at the vector form the closest vert to the circle to decide
|
||||
|
||||
sx = t.sx;
|
||||
sy = t.sy;
|
||||
|
||||
var r = obj.radius;
|
||||
var ox = obj.pos.x - t.pos.x;//this gives is the coordinates of the innermost
|
||||
var oy = obj.pos.y - (t.pos.y - (signy * t.yw));//point on the circle, relative to the tile corner
|
||||
|
||||
//if the component of (ox,oy) parallel to the normal's righthand normal
|
||||
//has the same sign as the slope of the slope (the sign of the slope's slope is signx*signy)
|
||||
//then we project by the normal or axis, otherwise by the corner/vertex
|
||||
//note that this is simply a VERY tricky/weird method of determining
|
||||
//if the circle is in side the slope/face's voronoi region, or that of the vertex.
|
||||
|
||||
var perp = (ox * -sy) + (oy * sx);
|
||||
|
||||
if ((perp * signx * signy) < 0)
|
||||
{
|
||||
//collide vs. vertex
|
||||
var len = Math.sqrt(ox * ox + oy * oy);
|
||||
var pen = r - len;
|
||||
|
||||
if (0 < pen)
|
||||
{
|
||||
//note: if len=0, then perp=0 and we'll never reach here, so don't worry about div-by-0
|
||||
ox /= len;
|
||||
oy /= len;
|
||||
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//collide vs. slope or vs axis
|
||||
ox -= r * sx;//this gives us the vector from
|
||||
oy -= r * sy;//a point on the slope to the innermost point on the circle
|
||||
|
||||
//if the dotprod of (ox,oy) and (sx,sy) is negative, the point on the circle is in the slope
|
||||
//and we need toproject it out by the magnitude of the projection of (ox,oy) onto (sx,sy)
|
||||
var dp = (ox * sx) + (oy * sy);
|
||||
var lenP;
|
||||
|
||||
if (dp < 0)
|
||||
{
|
||||
//collision; project delta onto slope and use this to displace the object
|
||||
sx *= -dp;//(sx,sy) is now the projection vector
|
||||
sy *= -dp;
|
||||
|
||||
var lenN = Math.sqrt(sx * sx + sy * sy);
|
||||
|
||||
//find the smallest axial projection vector
|
||||
if (x < y)
|
||||
{
|
||||
//penetration in x is smaller
|
||||
lenP = x;
|
||||
y = 0;
|
||||
//get sign for projection along x-axis
|
||||
if ((obj.pos.x - t.pos.x) < 0)
|
||||
{
|
||||
x *= -1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//penetration in y is smaller
|
||||
lenP = y;
|
||||
x = 0;
|
||||
//get sign for projection along y-axis
|
||||
if ((obj.pos.y - t.pos.y) < 0)
|
||||
{
|
||||
y *= -1;
|
||||
}
|
||||
}
|
||||
|
||||
if (lenP < lenN)
|
||||
{
|
||||
obj.reportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
return Phaser.Physics.Circle.COL_AXIS
|
||||
}
|
||||
else
|
||||
{
|
||||
obj.reportCollisionVsWorld(sx, sy, t.sx, t.sy, t);
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
//colliding vertically
|
||||
|
||||
if ((signy * oV) < 0)
|
||||
{
|
||||
//colliding with face/edge OR with corner of wedge, depending on our position vertically
|
||||
|
||||
//collide vs. vertex
|
||||
//get diag vertex position
|
||||
var vx = t.pos.x;
|
||||
var vy = t.pos.y - (signy * t.yw);
|
||||
|
||||
var dx = obj.pos.x - vx;//calc vert->circle vector
|
||||
var dy = obj.pos.y - vy;
|
||||
|
||||
if ((dx * signx) < 0)
|
||||
{
|
||||
//colliding vs face
|
||||
obj.reportCollisionVsWorld(0, y * oV, 0, oV, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
else
|
||||
{
|
||||
//colliding vs. vertex
|
||||
|
||||
var len = Math.sqrt(dx * dx + dy * dy);
|
||||
var pen = obj.radius - len;
|
||||
|
||||
if (0 < pen)
|
||||
{
|
||||
//vertex is in the circle; project outward
|
||||
if (len == 0)
|
||||
{
|
||||
//project out by 45deg
|
||||
dx = oH / Math.SQRT2;
|
||||
dy = oV / Math.SQRT2;
|
||||
}
|
||||
else
|
||||
{
|
||||
dx /= len;
|
||||
dy /= len;
|
||||
}
|
||||
|
||||
obj.reportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//we could only be colliding vs the slope OR a vertex
|
||||
//look at the vector form the closest vert to the circle to decide
|
||||
|
||||
sx = t.sx;
|
||||
sy = t.sy;
|
||||
|
||||
var ox = obj.pos.x - (t.pos.x - (signx * t.xw));//this gives is the coordinates of the innermost
|
||||
var oy = obj.pos.y - (t.pos.y + (oV * t.yw));//point on the circle, relative to the closest tile vert
|
||||
|
||||
//if the component of (ox,oy) parallel to the normal's righthand normal
|
||||
//has the same sign as the slope of the slope (the sign of the slope's slope is signx*signy)
|
||||
//then we project by the vertex, otherwise by the normal.
|
||||
//note that this is simply a VERY tricky/weird method of determining
|
||||
//if the circle is in side the slope/face's voronio region, or that of the vertex.
|
||||
var perp = (ox * -sy) + (oy * sx);
|
||||
|
||||
if (0 < (perp * signx * signy))
|
||||
{
|
||||
//collide vs. vertex
|
||||
var len = Math.sqrt(ox * ox + oy * oy);
|
||||
var pen = obj.radius - len;
|
||||
|
||||
if (0 < pen)
|
||||
{
|
||||
//note: if len=0, then perp=0 and we'll never reach here, so don't worry about div-by-0
|
||||
ox /= len;
|
||||
oy /= len;
|
||||
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//collide vs. slope
|
||||
|
||||
//if the component of (ox,oy) parallel to the normal is less than the circle radius, we're
|
||||
//penetrating the slope. note that this method of penetration calculation doesn't hold
|
||||
//in general (i.e it won't work if the circle is in the slope), but works in this case
|
||||
//because we know the circle is in a neighboring cell
|
||||
var dp = (ox * sx) + (oy * sy);
|
||||
var pen = obj.radius - Math.abs(dp);//note: we don't need the abs because we know the dp will be positive, but just in case..
|
||||
|
||||
if (0 < pen)
|
||||
{
|
||||
//collision; circle out along normal by penetration amount
|
||||
obj.reportCollisionVsWorld(sx * pen, sy * pen, t.sx, t.sy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (oV == 0)
|
||||
{
|
||||
//colliding horizontally; we can assume that (signy*oV) < 0
|
||||
//due to the first conditional far above
|
||||
|
||||
obj.reportCollisionVsWorld(x * oH, 0, oH, 0, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
else
|
||||
{
|
||||
//colliding diagonally; due to the first conditional above,
|
||||
//obj is vertically offset against slope, and offset in either direction horizontally
|
||||
|
||||
//collide vs. vertex
|
||||
//get diag vertex position
|
||||
var vx = t.pos.x + (oH * t.xw);
|
||||
var vy = t.pos.y + (oV * t.yw);
|
||||
|
||||
var dx = obj.pos.x - vx;//calc vert->circle vector
|
||||
var dy = obj.pos.y - vy;
|
||||
|
||||
var len = Math.sqrt(dx * dx + dy * dy);
|
||||
var pen = obj.radius - len;
|
||||
|
||||
if (0 < pen)
|
||||
{
|
||||
//vertex is in the circle; project outward
|
||||
if (len == 0)
|
||||
{
|
||||
//project out by 45deg
|
||||
dx = oH / Math.SQRT2;
|
||||
dy = oV / Math.SQRT2;
|
||||
}
|
||||
else
|
||||
{
|
||||
dx /= len;
|
||||
dy /= len;
|
||||
}
|
||||
|
||||
obj.reportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
}
|
||||
|
||||
return Phaser.Physics.Circle.COL_NONE;
|
||||
|
||||
}
|
||||
|
||||
public static CollideB(x, y, oH, oV, obj: Phaser.Physics.Circle, t: Phaser.Physics.TileMapCell) {
|
||||
|
||||
//if we're colliding diagonally:
|
||||
// -if we're in the cell pointed at by the normal, collide vs slope, else
|
||||
// collide vs. the appropriate corner/vertex
|
||||
//
|
||||
//if obj is in this tile: collide as with aabb
|
||||
//
|
||||
//if obj is horiz or vertical neighbor AGAINST the slope: collide with edge
|
||||
//
|
||||
//if obj is vert neighb in direction of slope: collide vs. slope or vertex or halfedge
|
||||
//
|
||||
//if obj is horiz neighb in direction of slope: collide vs. slope or vertex
|
||||
|
||||
var signx = t.signx;
|
||||
var signy = t.signy;
|
||||
var sx: number;
|
||||
var sy: number;
|
||||
|
||||
if (oH == 0)
|
||||
{
|
||||
if (oV == 0)
|
||||
{
|
||||
//colliding with current cell
|
||||
|
||||
sx = t.sx;
|
||||
sy = t.sy;
|
||||
|
||||
var r = obj.radius;
|
||||
var ox = (obj.pos.x - (sx * r)) - (t.pos.x + (signx * t.xw));//this gives is the coordinates of the innermost
|
||||
var oy = (obj.pos.y - (sy * r)) - (t.pos.y - (signy * t.yw));//point on the AABB, relative to a point on the slope
|
||||
|
||||
//if the dotprod of (ox,oy) and (sx,sy) is negative, the point on the circle is in the slope
|
||||
//and we need toproject it out by the magnitude of the projection of (ox,oy) onto (sx,sy)
|
||||
var dp = (ox * sx) + (oy * sy);
|
||||
var lenP;
|
||||
|
||||
if (dp < 0)
|
||||
{
|
||||
//collision; project delta onto slope and use this to displace the object
|
||||
sx *= -dp;//(sx,sy) is now the projection vector
|
||||
sy *= -dp;
|
||||
|
||||
var lenN = Math.sqrt(sx * sx + sy * sy);
|
||||
|
||||
//find the smallest axial projection vector
|
||||
if (x < y)
|
||||
{
|
||||
//penetration in x is smaller
|
||||
lenP = x;
|
||||
y = 0;
|
||||
//get sign for projection along x-axis
|
||||
if ((obj.pos.x - t.pos.x) < 0)
|
||||
{
|
||||
x *= -1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//penetration in y is smaller
|
||||
lenP = y;
|
||||
x = 0;
|
||||
//get sign for projection along y-axis
|
||||
if ((obj.pos.y - t.pos.y) < 0)
|
||||
{
|
||||
y *= -1;
|
||||
}
|
||||
}
|
||||
|
||||
if (lenP < lenN)
|
||||
{
|
||||
obj.reportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
else
|
||||
{
|
||||
obj.reportCollisionVsWorld(sx, sy, t.sx, t.sy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//colliding vertically
|
||||
|
||||
if ((signy * oV) < 0)
|
||||
{
|
||||
//colliding with face/edge
|
||||
obj.reportCollisionVsWorld(0, y * oV, 0, oV, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
else
|
||||
{
|
||||
//colliding with edge, slope, or vertex
|
||||
|
||||
var ox = obj.pos.x - t.pos.x;//this gives is the coordinates of the innermost
|
||||
var oy = obj.pos.y - (t.pos.y + (signy * t.yw));//point on the circle, relative to the closest tile vert
|
||||
|
||||
if ((ox * signx) < 0)
|
||||
{
|
||||
//we're colliding with the halfface
|
||||
obj.reportCollisionVsWorld(0, y * oV, 0, oV, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
else
|
||||
{
|
||||
//colliding with the vertex or slope
|
||||
|
||||
sx = t.sx;
|
||||
sy = t.sy;
|
||||
|
||||
//if the component of (ox,oy) parallel to the normal's righthand normal
|
||||
//has the same sign as the slope of the slope (the sign of the slope's slope is signx*signy)
|
||||
//then we project by the vertex, otherwise by the slope.
|
||||
//note that this is simply a VERY tricky/weird method of determining
|
||||
//if the circle is in side the slope/face's voronio region, or that of the vertex.
|
||||
var perp = (ox * -sy) + (oy * sx);
|
||||
|
||||
if (0 < (perp * signx * signy))
|
||||
{
|
||||
//collide vs. vertex
|
||||
var len = Math.sqrt(ox * ox + oy * oy);
|
||||
var pen = obj.radius - len;
|
||||
|
||||
if (0 < pen)
|
||||
{
|
||||
//note: if len=0, then perp=0 and we'll never reach here, so don't worry about div-by-0
|
||||
ox /= len;
|
||||
oy /= len;
|
||||
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//collide vs. slope
|
||||
|
||||
//if the component of (ox,oy) parallel to the normal is less than the circle radius, we're
|
||||
//penetrating the slope. note that this method of penetration calculation doesn't hold
|
||||
//in general (i.e it won't work if the circle is in the slope), but works in this case
|
||||
//because we know the circle is in a neighboring cell
|
||||
var dp = (ox * sx) + (oy * sy);
|
||||
var pen = obj.radius - Math.abs(dp);//note: we don't need the abs because we know the dp will be positive, but just in case..
|
||||
|
||||
if (0 < pen)
|
||||
{
|
||||
//collision; circle out along normal by penetration amount
|
||||
obj.reportCollisionVsWorld(sx * pen, sy * pen, sx, sy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (oV == 0)
|
||||
{
|
||||
//colliding horizontally
|
||||
|
||||
if ((signx * oH) < 0)
|
||||
{
|
||||
//colliding with face/edge
|
||||
obj.reportCollisionVsWorld(x * oH, 0, oH, 0, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
else
|
||||
{
|
||||
//we could only be colliding vs the slope OR a vertex
|
||||
//look at the vector form the closest vert to the circle to decide
|
||||
|
||||
var slen = Math.sqrt(2 * 2 + 1 * 1);//the raw slope is (-2,-1)
|
||||
var sx = (signx * 2) / slen;//get slope _unit_ normal;
|
||||
var sy = (signy * 1) / slen;//raw RH normal is (1,-2)
|
||||
|
||||
var ox = obj.pos.x - (t.pos.x + (signx * t.xw));//this gives is the coordinates of the innermost
|
||||
var oy = obj.pos.y - (t.pos.y - (signy * t.yw));//point on the circle, relative to the closest tile vert
|
||||
|
||||
//if the component of (ox,oy) parallel to the normal's righthand normal
|
||||
//has the same sign as the slope of the slope (the sign of the slope's slope is signx*signy)
|
||||
//then we project by the slope, otherwise by the vertex.
|
||||
//note that this is simply a VERY tricky/weird method of determining
|
||||
//if the circle is in side the slope/face's voronio region, or that of the vertex.
|
||||
var perp = (ox * -sy) + (oy * sx);
|
||||
|
||||
if ((perp * signx * signy) < 0)
|
||||
{
|
||||
//collide vs. vertex
|
||||
var len = Math.sqrt(ox * ox + oy * oy);
|
||||
var pen = obj.radius - len;
|
||||
if (0 < pen)
|
||||
{
|
||||
//note: if len=0, then perp=0 and we'll never reach here, so don't worry about div-by-0
|
||||
ox /= len;
|
||||
oy /= len;
|
||||
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//collide vs. slope
|
||||
|
||||
//if the component of (ox,oy) parallel to the normal is less than the circle radius, we're
|
||||
//penetrating the slope. note that this method of penetration calculation doesn't hold
|
||||
//in general (i.e it won't work if the circle is in the slope), but works in this case
|
||||
//because we know the circle is in a neighboring cell
|
||||
var dp = (ox * sx) + (oy * sy);
|
||||
var pen = obj.radius - Math.abs(dp);//note: we don't need the abs because we know the dp will be positive, but just in case..
|
||||
if (0 < pen)
|
||||
{
|
||||
//collision; circle out along normal by penetration amount
|
||||
obj.reportCollisionVsWorld(sx * pen, sy * pen, t.sx, t.sy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//colliding diagonally
|
||||
if (0 < ((signx * oH) + (signy * oV)))
|
||||
{
|
||||
//the dotprod of slope normal and cell offset is strictly positive,
|
||||
//therefore obj is in the diagonal neighb pointed at by the normal.
|
||||
|
||||
//collide vs slope
|
||||
|
||||
sx = t.sx;
|
||||
sy = t.sy;
|
||||
|
||||
var r = obj.radius;
|
||||
var ox = (obj.pos.x - (sx * r)) - (t.pos.x + (signx * t.xw));//this gives is the coordinates of the innermost
|
||||
var oy = (obj.pos.y - (sy * r)) - (t.pos.y - (signy * t.yw));//point on the circle, relative to a point on the slope
|
||||
|
||||
//if the dotprod of (ox,oy) and (sx,sy) is negative, the point on the circle is in the slope
|
||||
//and we need toproject it out by the magnitude of the projection of (ox,oy) onto (sx,sy)
|
||||
var dp = (ox * sx) + (oy * sy);
|
||||
|
||||
if (dp < 0)
|
||||
{
|
||||
//collision; project delta onto slope and use this to displace the object
|
||||
//(sx,sy)*-dp is the projection vector
|
||||
|
||||
obj.reportCollisionVsWorld(-sx * dp, -sy * dp, t.sx, t.sy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
return Phaser.Physics.Circle.COL_NONE;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
//collide vs the appropriate vertex
|
||||
var vx = t.pos.x + (oH * t.xw);
|
||||
var vy = t.pos.y + (oV * t.yw);
|
||||
|
||||
var dx = obj.pos.x - vx;//calc vert->circle vector
|
||||
var dy = obj.pos.y - vy;
|
||||
|
||||
var len = Math.sqrt(dx * dx + dy * dy);
|
||||
var pen = obj.radius - len;
|
||||
|
||||
if (0 < pen)
|
||||
{
|
||||
//vertex is in the circle; project outward
|
||||
if (len == 0)
|
||||
{
|
||||
//project out by 45deg
|
||||
dx = oH / Math.SQRT2;
|
||||
dy = oV / Math.SQRT2;
|
||||
}
|
||||
else
|
||||
{
|
||||
dx /= len;
|
||||
dy /= len;
|
||||
}
|
||||
|
||||
obj.reportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
return Phaser.Physics.Circle.COL_NONE;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
|
@ -53,7 +53,7 @@ var Phaser;
|
|||
}
|
||||
|
||||
if (lenP < pen) {
|
||||
obj.ReportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
obj.reportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
} else {
|
||||
|
@ -63,7 +63,7 @@ var Phaser;
|
|||
ox /= len;
|
||||
oy /= len;
|
||||
|
||||
obj.ReportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
@ -73,7 +73,7 @@ var Phaser;
|
|||
} else {
|
||||
if ((signy * oV) < 0) {
|
||||
//colliding with face/edge
|
||||
obj.ReportCollisionVsWorld(0, y * oV, 0, oV, t);
|
||||
obj.reportCollisionVsWorld(0, y * oV, 0, oV, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
} else {
|
||||
|
@ -97,7 +97,7 @@ var Phaser;
|
|||
dy /= len;
|
||||
}
|
||||
|
||||
obj.ReportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
obj.reportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
@ -106,7 +106,7 @@ var Phaser;
|
|||
} else if (oV == 0) {
|
||||
if ((signx * oH) < 0) {
|
||||
//colliding with face/edge
|
||||
obj.ReportCollisionVsWorld(x * oH, 0, oH, 0, t);
|
||||
obj.reportCollisionVsWorld(x * oH, 0, oH, 0, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
} else {
|
||||
|
@ -130,7 +130,7 @@ var Phaser;
|
|||
dy /= len;
|
||||
}
|
||||
|
||||
obj.ReportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
obj.reportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
@ -162,7 +162,7 @@ var Phaser;
|
|||
dy /= len;
|
||||
}
|
||||
|
||||
obj.ReportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
obj.reportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
|
|
@ -68,7 +68,7 @@ module Phaser.Physics.Projection {
|
|||
|
||||
if (lenP < pen)
|
||||
{
|
||||
obj.ReportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
obj.reportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
|
@ -80,7 +80,7 @@ module Phaser.Physics.Projection {
|
|||
ox /= len;
|
||||
oy /= len;
|
||||
|
||||
obj.ReportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
@ -97,7 +97,7 @@ module Phaser.Physics.Projection {
|
|||
if ((signy * oV) < 0)
|
||||
{
|
||||
//colliding with face/edge
|
||||
obj.ReportCollisionVsWorld(0, y * oV, 0, oV, t);
|
||||
obj.reportCollisionVsWorld(0, y * oV, 0, oV, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
|
@ -129,7 +129,7 @@ module Phaser.Physics.Projection {
|
|||
dy /= len;
|
||||
}
|
||||
|
||||
obj.ReportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
obj.reportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
@ -142,7 +142,7 @@ module Phaser.Physics.Projection {
|
|||
if ((signx * oH) < 0)
|
||||
{
|
||||
//colliding with face/edge
|
||||
obj.ReportCollisionVsWorld(x * oH, 0, oH, 0, t);
|
||||
obj.reportCollisionVsWorld(x * oH, 0, oH, 0, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
|
@ -174,7 +174,7 @@ module Phaser.Physics.Projection {
|
|||
dy /= len;
|
||||
}
|
||||
|
||||
obj.ReportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
obj.reportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
@ -217,7 +217,7 @@ module Phaser.Physics.Projection {
|
|||
dy /= len;
|
||||
}
|
||||
|
||||
obj.ReportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
obj.reportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
|
|
@ -53,7 +53,7 @@ var Phaser;
|
|||
}
|
||||
|
||||
if (lenP < pen) {
|
||||
obj.ReportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
obj.reportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
} else {
|
||||
|
@ -63,7 +63,7 @@ var Phaser;
|
|||
ox /= len;
|
||||
oy /= len;
|
||||
|
||||
obj.ReportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
@ -71,7 +71,7 @@ var Phaser;
|
|||
} else {
|
||||
if ((signy * oV) < 0) {
|
||||
//colliding with face/edge
|
||||
obj.ReportCollisionVsWorld(0, y * oV, 0, oV, t);
|
||||
obj.reportCollisionVsWorld(0, y * oV, 0, oV, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
} else {
|
||||
|
@ -93,7 +93,7 @@ var Phaser;
|
|||
ox /= len;
|
||||
oy /= len;
|
||||
|
||||
obj.ReportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
@ -102,7 +102,7 @@ var Phaser;
|
|||
} else if (oV == 0) {
|
||||
if ((signx * oH) < 0) {
|
||||
//colliding with face/edge
|
||||
obj.ReportCollisionVsWorld(x * oH, 0, oH, 0, t);
|
||||
obj.reportCollisionVsWorld(x * oH, 0, oH, 0, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
} else {
|
||||
|
@ -124,7 +124,7 @@ var Phaser;
|
|||
ox /= len;
|
||||
oy /= len;
|
||||
|
||||
obj.ReportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
@ -149,7 +149,7 @@ var Phaser;
|
|||
ox /= len;
|
||||
oy /= len;
|
||||
|
||||
obj.ReportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
@ -174,7 +174,7 @@ var Phaser;
|
|||
dy /= len;
|
||||
}
|
||||
|
||||
obj.ReportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
obj.reportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
|
|
@ -69,7 +69,7 @@ module Phaser.Physics.Projection {
|
|||
|
||||
if (lenP < pen)
|
||||
{
|
||||
obj.ReportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
obj.reportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
|
@ -81,7 +81,7 @@ module Phaser.Physics.Projection {
|
|||
ox /= len;
|
||||
oy /= len;
|
||||
|
||||
obj.ReportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
|
||||
|
@ -94,7 +94,7 @@ module Phaser.Physics.Projection {
|
|||
if ((signy * oV) < 0)
|
||||
{
|
||||
//colliding with face/edge
|
||||
obj.ReportCollisionVsWorld(0, y * oV, 0, oV, t);
|
||||
obj.reportCollisionVsWorld(0, y * oV, 0, oV, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
|
@ -121,7 +121,7 @@ module Phaser.Physics.Projection {
|
|||
ox /= len;
|
||||
oy /= len;
|
||||
|
||||
obj.ReportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
@ -134,7 +134,7 @@ module Phaser.Physics.Projection {
|
|||
if ((signx * oH) < 0)
|
||||
{
|
||||
//colliding with face/edge
|
||||
obj.ReportCollisionVsWorld(x * oH, 0, oH, 0, t);
|
||||
obj.reportCollisionVsWorld(x * oH, 0, oH, 0, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
|
@ -161,7 +161,7 @@ module Phaser.Physics.Projection {
|
|||
ox /= len;
|
||||
oy /= len;
|
||||
|
||||
obj.ReportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
@ -193,7 +193,7 @@ module Phaser.Physics.Projection {
|
|||
ox /= len;
|
||||
oy /= len;
|
||||
|
||||
obj.ReportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
obj.reportCollisionVsWorld(ox * pen, oy * pen, ox, oy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
@ -225,7 +225,7 @@ module Phaser.Physics.Projection {
|
|||
dy /= len;
|
||||
}
|
||||
|
||||
obj.ReportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
obj.reportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
|
|
@ -17,10 +17,10 @@ var Phaser;
|
|||
var dx = obj.pos.x - t.pos.x;
|
||||
|
||||
if (dx < 0) {
|
||||
obj.ReportCollisionVsWorld(-x, 0, -1, 0, t);
|
||||
obj.reportCollisionVsWorld(-x, 0, -1, 0, t);
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
} else {
|
||||
obj.ReportCollisionVsWorld(x, 0, 1, 0, t);
|
||||
obj.reportCollisionVsWorld(x, 0, 1, 0, t);
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
} else {
|
||||
|
@ -28,22 +28,22 @@ var Phaser;
|
|||
var dy = obj.pos.y - t.pos.y;
|
||||
|
||||
if (dy < 0) {
|
||||
obj.ReportCollisionVsWorld(0, -y, 0, -1, t);
|
||||
obj.reportCollisionVsWorld(0, -y, 0, -1, t);
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
} else {
|
||||
obj.ReportCollisionVsWorld(0, y, 0, 1, t);
|
||||
obj.reportCollisionVsWorld(0, y, 0, 1, t);
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
//collision with vertical neighbor
|
||||
obj.ReportCollisionVsWorld(0, y * oV, 0, oV, t);
|
||||
obj.reportCollisionVsWorld(0, y * oV, 0, oV, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
} else if (oV == 0) {
|
||||
//collision with horizontal neighbor
|
||||
obj.ReportCollisionVsWorld(x * oH, 0, oH, 0, t);
|
||||
obj.reportCollisionVsWorld(x * oH, 0, oH, 0, t);
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
} else {
|
||||
//diagonal collision
|
||||
|
@ -66,7 +66,7 @@ var Phaser;
|
|||
dy /= len;
|
||||
}
|
||||
|
||||
obj.ReportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
obj.reportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
|
|
@ -28,12 +28,12 @@ module Phaser.Physics.Projection {
|
|||
//NOTE: should we handle the delta == 0 case?! and how? (project towards oldpos?)
|
||||
if (dx < 0)
|
||||
{
|
||||
obj.ReportCollisionVsWorld(-x, 0, -1, 0, t);
|
||||
obj.reportCollisionVsWorld(-x, 0, -1, 0, t);
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
else
|
||||
{
|
||||
obj.ReportCollisionVsWorld(x, 0, 1, 0, t);
|
||||
obj.reportCollisionVsWorld(x, 0, 1, 0, t);
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
}
|
||||
|
@ -45,12 +45,12 @@ module Phaser.Physics.Projection {
|
|||
//NOTE: should we handle the delta == 0 case?! and how? (project towards oldpos?)
|
||||
if (dy < 0)
|
||||
{
|
||||
obj.ReportCollisionVsWorld(0, -y, 0, -1, t);
|
||||
obj.reportCollisionVsWorld(0, -y, 0, -1, t);
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
else
|
||||
{
|
||||
obj.ReportCollisionVsWorld(0, y, 0, 1, t);
|
||||
obj.reportCollisionVsWorld(0, y, 0, 1, t);
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
}
|
||||
|
@ -58,7 +58,7 @@ module Phaser.Physics.Projection {
|
|||
else
|
||||
{
|
||||
//collision with vertical neighbor
|
||||
obj.ReportCollisionVsWorld(0, y * oV, 0, oV, t);
|
||||
obj.reportCollisionVsWorld(0, y * oV, 0, oV, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
|
@ -66,7 +66,7 @@ module Phaser.Physics.Projection {
|
|||
else if (oV == 0)
|
||||
{
|
||||
//collision with horizontal neighbor
|
||||
obj.ReportCollisionVsWorld(x * oH, 0, oH, 0, t);
|
||||
obj.reportCollisionVsWorld(x * oH, 0, oH, 0, t);
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
else
|
||||
|
@ -97,7 +97,7 @@ module Phaser.Physics.Projection {
|
|||
dy /= len;
|
||||
}
|
||||
|
||||
obj.ReportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
obj.reportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
|
19
Phaser/physics/circle/ProjCircleHalf.js
Normal file
19
Phaser/physics/circle/ProjCircleHalf.js
Normal file
|
@ -0,0 +1,19 @@
|
|||
var Shapes;
|
||||
(function (Shapes) {
|
||||
|
||||
var Point = Shapes.Point = (function () {
|
||||
function Point(x, y) {
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
}
|
||||
Point.prototype.getDist = function () {
|
||||
return Math.sqrt((this.x * this.x) + (this.y * this.y));
|
||||
};
|
||||
Point.origin = new Point(0, 0);
|
||||
return Point;
|
||||
})();
|
||||
|
||||
})(Shapes || (Shapes = {}));
|
||||
|
||||
var p = new Shapes.Point(3, 4);
|
||||
var dist = p.getDist();
|
236
Phaser/physics/circle/ProjCircleHalf.ts
Normal file
236
Phaser/physics/circle/ProjCircleHalf.ts
Normal file
|
@ -0,0 +1,236 @@
|
|||
/// <reference path="../../_definitions.ts" />
|
||||
|
||||
/**
|
||||
* Phaser - Physics - Projection
|
||||
*/
|
||||
|
||||
module Phaser.Physics.Projection {
|
||||
|
||||
export class CircleHalf {
|
||||
|
||||
public static Collide(x, y, oH, oV, obj: Phaser.Physics.Circle, t: Phaser.Physics.TileMapCell) {
|
||||
|
||||
//if obj is in a neighbor pointed at by the halfedge normal,
|
||||
//we'll never collide (i.e if the normal is (0,1) and the obj is in the DL.D, or R neighbors)
|
||||
//
|
||||
//if obj is in a neigbor perpendicular to the halfedge normal, it might
|
||||
//collide with the halfedge-vertex, or with the halfedge side.
|
||||
//
|
||||
//if obj is in a neigb pointing opposite the halfedge normal, obj collides with edge
|
||||
//
|
||||
//if obj is in a diagonal (pointing away from the normal), obj collides vs vertex
|
||||
//
|
||||
//if obj is in the halfedge cell, it collides as with aabb
|
||||
|
||||
var signx = t.signx;
|
||||
var signy = t.signy;
|
||||
|
||||
var celldp = (oH * signx + oV * signy);//this tells us about the configuration of cell-offset relative to tile normal
|
||||
if (0 < celldp)
|
||||
{
|
||||
//obj is in "far" (pointed-at-by-normal) neighbor of halffull tile, and will never hit
|
||||
return Phaser.Physics.Circle.COL_NONE;
|
||||
}
|
||||
else if (oH == 0)
|
||||
{
|
||||
if (oV == 0)
|
||||
{
|
||||
//colliding with current tile
|
||||
var r = obj.radius;
|
||||
var ox = (obj.pos.x - (signx * r)) - t.pos.x;//this gives is the coordinates of the innermost
|
||||
var oy = (obj.pos.y - (signy * r)) - t.pos.y;//point on the circle, relative to the tile center
|
||||
|
||||
|
||||
//we perform operations analogous to the 45deg tile, except we're using
|
||||
//an axis-aligned slope instead of an angled one..
|
||||
var sx = signx;
|
||||
var sy = signy;
|
||||
|
||||
//if the dotprod of (ox,oy) and (sx,sy) is negative, the corner is in the slope
|
||||
//and we need toproject it out by the magnitude of the projection of (ox,oy) onto (sx,sy)
|
||||
var dp = (ox * sx) + (oy * sy);
|
||||
|
||||
if (dp < 0)
|
||||
{
|
||||
//collision; project delta onto slope and use this to displace the object
|
||||
sx *= -dp;//(sx,sy) is now the projection vector
|
||||
sy *= -dp;
|
||||
|
||||
var lenN = Math.sqrt(sx * sx + sy * sy);
|
||||
var lenP = Math.sqrt(x * x + y * y);
|
||||
|
||||
if (lenP < lenN)
|
||||
{
|
||||
obj.reportCollisionVsWorld(x, y, x / lenP, y / lenP, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
else
|
||||
{
|
||||
obj.reportCollisionVsWorld(sx, sy, t.signx, t.signy);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
//colliding vertically
|
||||
|
||||
if (celldp == 0)
|
||||
{
|
||||
var r = obj.radius;
|
||||
var dx = obj.pos.x - t.pos.x;
|
||||
|
||||
//we're in a cell perpendicular to the normal, and can collide vs. halfedge vertex
|
||||
//or halfedge side
|
||||
if ((dx * signx) < 0)
|
||||
{
|
||||
//collision with halfedge side
|
||||
obj.reportCollisionVsWorld(0, y * oV, 0, oV, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
else
|
||||
{
|
||||
//collision with halfedge vertex
|
||||
var dy = obj.pos.y - (t.pos.y + oV * t.yw);//(dx,dy) is now the vector from the appropriate halfedge vertex to the circle
|
||||
|
||||
var len = Math.sqrt(dx * dx + dy * dy);
|
||||
var pen = obj.radius - len;
|
||||
|
||||
if (0 < pen)
|
||||
{
|
||||
//vertex is in the circle; project outward
|
||||
if (len == 0)
|
||||
{
|
||||
//project out by 45deg
|
||||
dx = signx / Math.SQRT2;
|
||||
dy = oV / Math.SQRT2;
|
||||
}
|
||||
else
|
||||
{
|
||||
dx /= len;
|
||||
dy /= len;
|
||||
}
|
||||
|
||||
obj.reportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//due to the first conditional (celldp >0), we know we're in the cell "opposite" the normal, and so
|
||||
//we can only collide with the cell edge
|
||||
//collision with vertical neighbor
|
||||
obj.reportCollisionVsWorld(0, y * oV, 0, oV, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
else if (oV == 0)
|
||||
{
|
||||
//colliding horizontally
|
||||
if (celldp == 0)
|
||||
{
|
||||
var r = obj.radius;
|
||||
var dy = obj.pos.y - t.pos.y;
|
||||
|
||||
//we're in a cell perpendicular to the normal, and can collide vs. halfedge vertex
|
||||
//or halfedge side
|
||||
if ((dy * signy) < 0)
|
||||
{
|
||||
//collision with halfedge side
|
||||
obj.reportCollisionVsWorld(x * oH, 0, oH, 0, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
else
|
||||
{
|
||||
//collision with halfedge vertex
|
||||
var dx = obj.pos.x - (t.pos.x + oH * t.xw);//(dx,dy) is now the vector from the appropriate halfedge vertex to the circle
|
||||
|
||||
var len = Math.sqrt(dx * dx + dy * dy);
|
||||
var pen = obj.radius - len;
|
||||
if (0 < pen)
|
||||
{
|
||||
//vertex is in the circle; project outward
|
||||
if (len == 0)
|
||||
{
|
||||
//project out by 45deg
|
||||
dx = signx / Math.SQRT2;
|
||||
dy = oV / Math.SQRT2;
|
||||
}
|
||||
else
|
||||
{
|
||||
dx /= len;
|
||||
dy /= len;
|
||||
}
|
||||
|
||||
obj.reportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//due to the first conditional (celldp >0), we know w're in the cell "opposite" the normal, and so
|
||||
//we can only collide with the cell edge
|
||||
obj.reportCollisionVsWorld(x * oH, 0, oH, 0, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_AXIS;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//colliding diagonally; we know, due to the initial (celldp >0) test which has failed
|
||||
//if we've reached this point, that we're in a diagonal neighbor on the non-normal side, so
|
||||
//we could only be colliding with the cell vertex, if at all.
|
||||
|
||||
//get diag vertex position
|
||||
var vx = t.pos.x + (oH * t.xw);
|
||||
var vy = t.pos.y + (oV * t.yw);
|
||||
|
||||
var dx = obj.pos.x - vx;//calc vert->circle vector
|
||||
var dy = obj.pos.y - vy;
|
||||
|
||||
var len = Math.sqrt(dx * dx + dy * dy);
|
||||
var pen = obj.radius - len;
|
||||
if (0 < pen)
|
||||
{
|
||||
//vertex is in the circle; project outward
|
||||
if (len == 0)
|
||||
{
|
||||
//project out by 45deg
|
||||
dx = oH / Math.SQRT2;
|
||||
dy = oV / Math.SQRT2;
|
||||
}
|
||||
else
|
||||
{
|
||||
dx /= len;
|
||||
dy /= len;
|
||||
}
|
||||
|
||||
obj.reportCollisionVsWorld(dx * pen, dy * pen, dx, dy, t);
|
||||
|
||||
return Phaser.Physics.Circle.COL_OTHER;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return Phaser.Physics.Circle.COL_NONE;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
File diff suppressed because it is too large
Load diff
File diff suppressed because it is too large
Load diff
Loading…
Reference in a new issue