summaryrefslogtreecommitdiff
path: root/public/assets/javascripts/rectangles/engine/rooms/mover.js
diff options
context:
space:
mode:
Diffstat (limited to 'public/assets/javascripts/rectangles/engine/rooms/mover.js')
-rw-r--r--public/assets/javascripts/rectangles/engine/rooms/mover.js219
1 files changed, 199 insertions, 20 deletions
diff --git a/public/assets/javascripts/rectangles/engine/rooms/mover.js b/public/assets/javascripts/rectangles/engine/rooms/mover.js
index 7195fcc..ac27aba 100644
--- a/public/assets/javascripts/rectangles/engine/rooms/mover.js
+++ b/public/assets/javascripts/rectangles/engine/rooms/mover.js
@@ -4,6 +4,15 @@ Rooms.mover = new function(){
base.room = null
base.noclip = false
+ var cursor = base.cursor = new Rect (0,0,0,0)
+ var cursor_copy = new Rect (0,0,0,0)
+ var wall_vec = new Rect (0,0,0,0)
+ var intersect = new vec2(0,0)
+
+ var origins = new Rect()
+ origins.x = cursor.x
+ origins.y = wall_vec.x
+
base.init = function(){
base.bind()
base.update(scene.camera)
@@ -11,7 +20,8 @@ Rooms.mover = new function(){
base.bind = function(){
app.on("move", base.update)
- keys.on("backslash", function(){
+ keys.on("backslash", function(e){
+ if ( ! (e.ctrlKey || e.metaKey) ) return
base.noclip = ! base.noclip
base.room = null
app.movements.gravity( ! base.noclip )
@@ -19,15 +29,9 @@ Rooms.mover = new function(){
}
base.update = function(pos){
+ var intersect, collision, distance
var radius = scene.camera.radius
- if (base.noclip) {
- cam.x = pos.x
- cam.y = pos.y
- cam.z = pos.z
- return
- }
-
cam.y = pos.y
// if we were in a room already..
@@ -39,17 +43,41 @@ Rooms.mover = new function(){
return
}
- // check if we've breached one of the walls.. clamp position if so
- var collision = base.room.collidesDisc(pos.x, pos.z, radius)
-
- if (collision) {
- cam.x = (collision & LEFT_RIGHT) ? base.room.rect.x.clampDisc(pos.x, radius) : pos.x
- cam.z = (collision & FRONT_BACK) ? base.room.rect.y.clampDisc(pos.z, radius) : pos.z
- return
+ distance = sqrt(pow(cam.x-pos.x, 2), pow(cam.z-pos.z, 2))
+
+ // check if we've breached one of the walls.. clamp position if so.
+ // there are two algorithms for this now, ridiculously..
+ // - the first one is smoother, best for keyboard use
+ // but if the distance travelled is greater than the min. distance from the wall,
+ // then there is a possibility of ejection from the room. so is bad for phone/mousewheel.
+
+ // - the second one determines fortuitously if we have breached any of the walls
+ // however it can get jumpy if you run into a wall.. thus it is best for devices like phone or mousewheel
+ // the benefit is you will never leave the room.
+ if (base.noclip) {
+ // in no-clip mode we walk through walls.
}
+ else if (distance < radius) {
+ collision = base.room.collidesDisc(cam, pos, radius)
+
+ if (collision) {
+ cam.x = (collision & LEFT_RIGHT) ? base.room.rect.x.clampDisc(pos.x, radius) : pos.x
+ cam.z = (collision & FRONT_BACK) ? base.room.rect.y.clampDisc(pos.z, radius) : pos.z
+ return
+ }
+ }
+ else {
+ intersect = base.intersect(pos)
+ if (intersect) {
+ cam.x = intersect.a
+ cam.z = intersect.b
+ return
+ }
+ }
// in this case, we appear to have left the room..
- $(".face.active").removeClass("active")
+ // $(".face.active").removeClass("active")
+ Walls.clearBodyColor()
base.room = null
}
@@ -65,11 +93,162 @@ Rooms.mover = new function(){
// did we actually enter a room?
if (intersects.length) {
base.room = intersects[0]
- base.room.mx_floor.forEach(function(w){ $(w.el).addClass("active") })
- base.room.mx_ceiling.forEach(function(w){ $(w.el).addClass("active") })
- base.room.mx_walls.forEach(function(w){ $(w.el).addClass("active") })
+ if (! base.noclip) {
+ Walls.setBodyColor()
+ }
+ app.tube("change-room", { room: base.room })
}
-
}
+ base.intersect = function(pos){
+ var closest_intersect, closest_wall, new_t, wall_t, t, min_t = 1
+
+ cursor_copy.x.a = cursor.x.a = cam.x
+ cursor_copy.x.b = cursor.x.b = cam.z
+ cursor_copy.y.a = cursor.y.a = pos.x
+ cursor_copy.y.b = cursor.y.b = pos.z
+
+ cursor_copy.extend_ends(scene.camera.radius)
+
+ origins.x = cursor_copy.x
+ origins.y = wall_vec.x
+
+ Walls.list.forEach(function(wall, i){
+ var actually_intersects = false, intersecting_face
+
+ wall.get_points(wall_vec)
+
+ t = perp(origins, wall_vec) / ( perp(cursor_copy, wall_vec) || 0.0000001 )
+
+ if ( min_t < t || t < 0 || 1 < t ) return
+
+ intersect.a = cursor_copy.x.a + ( cursor_copy.y.a - cursor_copy.x.a ) * t
+ intersect.b = cursor_copy.x.b + ( cursor_copy.y.b - cursor_copy.x.b ) * t
+
+ if ( ! is_collinear( intersect, wall_vec ) ) return
+
+ if (wall.side & LEFT_RIGHT) {
+ intersecting_face = wall.surface.face_for_x(intersect.b)
+ }
+ else {
+ intersecting_face = wall.surface.face_for_x(intersect.a)
+ }
+
+ actually_intersects = !! (intersecting_face && intersecting_face.y.a == 0)
+ if (actually_intersects) {
+ closest_intersect = intersect.clone()
+ closest_wall = wall_vec.clone()
+ min_t = t
+ }
+ })
+
+ if (closest_intersect) {
+
+ var aw, len, dd
+ aw = angle(closest_wall)
+ wall_vec.assign(closest_wall)
+ wall_vec.x.a -= scene.camera.radius * sin(aw)
+ wall_vec.x.b += scene.camera.radius * cos(aw)
+ wall_vec.y.a -= scene.camera.radius * sin(aw)
+ wall_vec.y.b += scene.camera.radius * cos(aw)
+
+ origins.x = cursor.x
+ origins.y = wall_vec.x
+
+ new_t = perp(origins, wall_vec) / ( perp(cursor, wall_vec) || 0.0000001 )
+ wall_t = perp(origins, cursor) / ( perp(wall_vec, cursor) || 0.0000001 )
+
+ intersect.a = cursor.x.a + ( cursor.y.a - cursor.x.a ) * new_t
+ intersect.b = cursor.x.b + ( cursor.y.b - cursor.x.b ) * new_t
+
+ // here compare len to the length of the wall in the direction we are travelling
+ dd = dot2(diff(closest_wall), diff(cursor))
+ len = sqrt(dot(wall_vec, wall_vec))
+ if (dd > 0) {
+ len *= 1-abs(wall_t)
+ }
+ else {
+ len *= abs(wall_t)
+ aw += PI
+ }
+
+ len = clamp(len, 0, (1-min_t) * sqrt(dot(cursor, cursor)))
+
+ intersect.a += len * cos(aw)
+ intersect.b += len * sin(aw)
+
+ wall_vec.normalize()
+ intersect.a = clamp(intersect.a, wall_vec.x.a, wall_vec.y.a)
+ intersect.b = clamp(intersect.b, wall_vec.x.b, wall_vec.y.b)
+
+ return intersect
+ }
+ else {
+ return cursor.y
+ }
+ }
+ function diff (v) {
+ return new vec2(v.y.a - v.x.a, v.y.b - v.x.b)
+ }
+ function angle (va) {
+ return atan2(va.y.b - va.x.b, va.y.a - va.x.a)
+ }
+ function angle2 (pa, pb) {
+ return atan2(pb.b - pa.b, pb.a - pa.a)
+ }
+ function normal (va) {
+ return atan2(va.x.a - va.y.a, va.y.b - va.x.b)
+ }
+ function dot (va, vb) {
+ return (va.y.a - va.x.a) * (vb.y.a - vb.x.a) + (va.y.b - va.x.b) * (vb.y.b - vb.x.b)
+ }
+ function dot2 (pa, pb) {
+ return pa.a * pb.a + pa.b * pb.b
+ }
+ function perp (va, vb) {
+ return (va.y.a - va.x.a) * (vb.y.b - vb.x.b) - (va.y.b - va.x.b) * (vb.y.a - vb.x.a)
+ }
+ function is_collinear (p, vec) {
+ var on_x, on_y
+ var pa = round(p.a), pb = round(p.b)
+
+ if (vec.x.a < vec.y.a) {
+ on_x = vec.x.a <= pa && pa <= vec.y.a
+ }
+ else {
+ on_x = vec.x.a >= pa && pa >= vec.y.a
+ }
+
+ if (vec.x.b < vec.y.b) {
+ on_y = vec.x.b <= pb && pb <= vec.y.b
+ }
+ else {
+ on_y = vec.x.b >= pb && pb >= vec.y.b
+ }
+
+ return !! (on_x && on_y)
+ }
+ cursor_copy.extend_ends = function(n){
+ var a = angle(this)
+ this.x.a -= n*cos(a)
+ this.x.b -= n*sin(a)
+ this.y.a += n*cos(a)
+ this.y.b += n*sin(a)
+ return this
+ }
+ wall_vec.normalize = function(){
+ var carry
+ if (this.x.a > this.y.a) {
+// console.log("SWAP X")
+ carry = this.x.a
+ this.x.a = this.y.a
+ this.y.a = carry
+ }
+ if (this.x.b > this.y.b) {
+// console.log("SWAP Y")
+ carry = this.x.b
+ this.x.b = this.y.b
+ this.y.b = carry
+ }
+ }
}
generated by cgit v1.2.3-70-g09d2 (git 2.51.0) at 2025-12-16 08:35:04 +0000