prismarine-physics 1.7.0 → 1.9.0

package/.github/workflows/commands.yml

@@ -0,0 +1,22 @@
+name: Repo Commands
+
+on:
+  issue_comment:        # Handle comment commands
+    types: [created]
+  pull_request:         # Handle renamed PRs
+    types: [edited]
+
+jobs:
+  comment-trigger:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Check out repository
+      uses: actions/checkout@v3
+    - name: Run command handlers
+      uses: PrismarineJS/prismarine-repo-actions@master
+      with:
+        # NOTE: You must specify a Personal Access Token (PAT) with repo access here. While you can use the default GITHUB_TOKEN, actions taken with it will not trigger other actions, so if you have a CI workflow, commits created by this action will not trigger it.
+        token: ${{ secrets.PAT_PASSWORD }}
+        # See `Options` section below for more info on these options
+        install-command: npm install
+        /fixlint.fix-command: npm run fix

package/HISTORY.md

@@ -1,5 +1,16 @@
 ## History
 
+### 1.9.0
+* [add 1.21 to proportionalliquidgravity setting (#117)](https://github.com/PrismarineJS/prismarine-physics/commit/4986c8e395773e770d461db06bce38f9faed0757) (thanks @Madlykeanu)
+
+### 1.8.0
+* [Add support for elytra and rockets (#106)](https://github.com/PrismarineJS/prismarine-physics/commit/04351b4c5fa73e9eb7ca79b88c63f5bef59b5645) (thanks @lkwilson)
+* [Fix "flowing" liquids not being included (#105)](https://github.com/PrismarineJS/prismarine-physics/commit/1f95aaad67684b381aedeb0a990e93dbb03025d0) (thanks @Flonja)
+* [Update index.js (#104)](https://github.com/PrismarineJS/prismarine-physics/commit/dd159da044af4959f9fd8d7d97c14921e7288c1e) (thanks @Vakore)
+* [Fixed airborne movement factor for sprinting (#75)](https://github.com/PrismarineJS/prismarine-physics/commit/116bb6fe3ae5066d53cedb69683a5fdb497c470d) (thanks @olie304)
+* [Add command gh workflow allowing to use release command in comments (#102)](https://github.com/PrismarineJS/prismarine-physics/commit/6797491346be0ef1572aac94c78b2a1377982d54) (thanks @rom1504)
+* [Fix 1.17 & 1.18 effect names (#101)](https://github.com/PrismarineJS/prismarine-physics/commit/cc7ae73d6929689645e77c7ba26bf0dcc4bc1e01) (thanks @killbinvlog)
+
 ### 1.7.0
 
 * 1.20

package/README.md

@@ -39,10 +39,13 @@ const player = {
       isInWeb: false,
       isCollidedHorizontally: false,
       isCollidedVertically: false,
-      yaw: 0
+      elytraFlying: false,
+      yaw: 0,
+      pitch: 0
     },
     jumpTicks: 0,
-    jumpQueued: false
+    jumpQueued: false,
+    fireworkRocketDuration: 0
   }
 const playerState = new PlayerState(player, controls)
 
@@ -76,8 +79,10 @@ Read / Write properties:
 - isInWeb : (boolean) is the player in a web ?
 - isCollidedHorizontally : (boolean) is the player collided horizontally with a solid block ?
 - isCollidedVertically : (boolean) is the player collided vertically with a solid block ?
+- elytraFlying : (boolean) is the player elytra flying ?
 - jumpTicks : (integer) number of ticks before the player can auto-jump again
 - jumpQueued : (boolean) true if the jump control state was true between the last tick and the current one
+- fireworkRocketDuration : (number) how many ticks of firework boost are remaining ?
 
 Read only properties:
 - yaw : (float) the yaw angle, in radians, of the player entity

package/examples/basic.js

@@ -22,9 +22,11 @@ function fakePlayer (pos, baseVersion) {
       isInWater: false,
       isInLava: false,
       isInWeb: false,
+      elytraFlying: false,
       isCollidedHorizontally: false,
       isCollidedVertically: false,
       yaw: 0,
+      pitch: 0,
       effects: []
     },
     inventory: {
@@ -32,6 +34,7 @@ function fakePlayer (pos, baseVersion) {
     },
     jumpTicks: 0,
     jumpQueued: false,
+    fireworkRocketDuration: 0,
     version: baseVersion
   }
 }

package/index.js

@@ -30,14 +30,15 @@ function Physics (mcData, world) {
   const soulsandId = blocksByName.soul_sand.id
   const honeyblockId = blocksByName.honey_block ? blocksByName.honey_block.id : -1 // 1.15+
   const webId = blocksByName.cobweb ? blocksByName.cobweb.id : blocksByName.web.id
-  const waterId = blocksByName.water.id
-  const lavaId = blocksByName.lava.id
+  const waterIds = [blocksByName.water.id, blocksByName.flowing_water ? blocksByName.flowing_water.id : -1]
+  const lavaIds = [blocksByName.lava.id, blocksByName.flowing_lava ? blocksByName.flowing_lava.id : -1]
   const ladderId = blocksByName.ladder.id
   const vineId = blocksByName.vine.id
   const waterLike = new Set()
   if (blocksByName.seagrass) waterLike.add(blocksByName.seagrass.id) // 1.13+
   if (blocksByName.tall_seagrass) waterLike.add(blocksByName.tall_seagrass.id) // 1.13+
   if (blocksByName.kelp) waterLike.add(blocksByName.kelp.id) // 1.13+
+  if (blocksByName.kelp_plant) waterLike.add(blocksByName.kelp_plant.id) // 1.13+
   const bubblecolumnId = blocksByName.bubble_column ? blocksByName.bubble_column.id : -1 // 1.13+
   if (blocksByName.bubble_column) waterLike.add(bubblecolumnId)
 
@@ -342,6 +343,64 @@ function Physics (mcData, world) {
     }
   }
 
+  function getLookingVector (entity) {
+    // given a yaw pitch, we need the looking vector
+
+    // yaw is right handed rotation about y (up) starting from -z (north)
+    // pitch is -90 looking down, 90 looking up, 0 looking at horizon
+    // lets get its coordinate system.
+    // let x' = -z (north)
+    // let y' = -x (west)
+    // let z' = y (up)
+
+    // the non normalized looking vector in x', y', z' space is
+    // x' is cos(yaw)
+    // y' is sin(yaw)
+    // z' is tan(pitch)
+
+    // substituting back in x, y, z, we get the looking vector in the normal x, y, z space
+    // -z = cos(yaw) => z = -cos(yaw)
+    // -x = sin(yaw) => x = -sin(yaw)
+    // y = tan(pitch)
+
+    // normalizing the vectors, we divide each by |sqrt(x*x + y*y + z*z)|
+    // x*x + z*z = sin^2 + cos^2 = 1
+    // so |sqrt(xx+yy+zz)| = |sqrt(1+tan^2(pitch))|
+    //     = |sqrt(1+sin^2(pitch)/cos^2(pitch))|
+    //     = |sqrt((cos^2+sin^2)/cos^2(pitch))|
+    //     = |sqrt(1/cos^2(pitch))|
+    //     = |+/- 1/cos(pitch)|
+    //     = 1/cos(pitch) since pitch in [-90, 90]
+
+    // the looking vector is therefore
+    // x = -sin(yaw) * cos(pitch)
+    // y = tan(pitch) * cos(pitch) = sin(pitch)
+    // z = -cos(yaw) * cos(pitch)
+
+    const yaw = entity.yaw
+    const pitch = entity.pitch
+    const sinYaw = Math.sin(yaw)
+    const cosYaw = Math.cos(yaw)
+    const sinPitch = Math.sin(pitch)
+    const cosPitch = Math.cos(pitch)
+    const lookX = -sinYaw * cosPitch
+    const lookY = sinPitch
+    const lookZ = -cosYaw * cosPitch
+    const lookDir = new Vec3(lookX, lookY, lookZ)
+    return {
+      yaw,
+      pitch,
+      sinYaw,
+      cosYaw,
+      sinPitch,
+      cosPitch,
+      lookX,
+      lookY,
+      lookZ,
+      lookDir
+    }
+  }
+
   function applyHeading (entity, strafe, forward, multiplier) {
     let speed = Math.sqrt(strafe * strafe + forward * forward)
     if (speed < 0.01) return new Vec3(0, 0, 0)
@@ -376,10 +435,79 @@ function Physics (mcData, world) {
 
     const gravityMultiplier = (vel.y <= 0 && entity.slowFalling > 0) ? physics.slowFalling : 1
 
-    if (!entity.isInWater && !entity.isInLava) {
+    if (entity.isInWater || entity.isInLava) {
+      // Water / Lava movement
+      const lastY = pos.y
+      let acceleration = physics.liquidAcceleration
+      const inertia = entity.isInWater ? physics.waterInertia : physics.lavaInertia
+      let horizontalInertia = inertia
+
+      if (entity.isInWater) {
+        let strider = Math.min(entity.depthStrider, 3)
+        if (!entity.onGround) {
+          strider *= 0.5
+        }
+        if (strider > 0) {
+          horizontalInertia += (0.546 - horizontalInertia) * strider / 3
+          acceleration += (0.7 - acceleration) * strider / 3
+        }
+
+        if (entity.dolphinsGrace > 0) horizontalInertia = 0.96
+      }
+
+      applyHeading(entity, strafe, forward, acceleration)
+      moveEntity(entity, world, vel.x, vel.y, vel.z)
+      vel.y *= inertia
+      vel.y -= (entity.isInWater ? physics.waterGravity : physics.lavaGravity) * gravityMultiplier
+      vel.x *= horizontalInertia
+      vel.z *= horizontalInertia
+
+      if (entity.isCollidedHorizontally && doesNotCollide(world, pos.offset(vel.x, vel.y + 0.6 - pos.y + lastY, vel.z))) {
+        vel.y = physics.outOfLiquidImpulse // jump out of liquid
+      }
+    } else if (entity.elytraFlying) {
+      const {
+        pitch,
+        sinPitch,
+        cosPitch,
+        lookDir
+      } = getLookingVector(entity)
+      const horizontalSpeed = Math.sqrt(vel.x * vel.x + vel.z * vel.z)
+      const cosPitchSquared = cosPitch * cosPitch
+      vel.y += physics.gravity * gravityMultiplier * (-1.0 + cosPitchSquared * 0.75)
+      // cosPitch is in [0, 1], so cosPitch > 0.0 is just to protect against
+      // divide by zero errors
+      if (vel.y < 0.0 && cosPitch > 0.0) {
+        const movingDownSpeedModifier = vel.y * (-0.1) * cosPitchSquared
+        vel.x += lookDir.x * movingDownSpeedModifier / cosPitch
+        vel.y += movingDownSpeedModifier
+        vel.z += lookDir.z * movingDownSpeedModifier / cosPitch
+      }
+
+      if (pitch < 0.0 && cosPitch > 0.0) {
+        const lookDownSpeedModifier = horizontalSpeed * (-sinPitch) * 0.04
+        vel.x += -lookDir.x * lookDownSpeedModifier / cosPitch
+        vel.y += lookDownSpeedModifier * 3.2
+        vel.z += -lookDir.z * lookDownSpeedModifier / cosPitch
+      }
+
+      if (cosPitch > 0.0) {
+        vel.x += (lookDir.x / cosPitch * horizontalSpeed - vel.x) * 0.1
+        vel.z += (lookDir.z / cosPitch * horizontalSpeed - vel.z) * 0.1
+      }
+
+      vel.x *= 0.99
+      vel.y *= 0.98
+      vel.z *= 0.99
+      moveEntity(entity, world, vel.x, vel.y, vel.z)
+
+      if (entity.onGround) {
+        entity.elytraFlying = false
+      }
+    } else {
       // Normal movement
-      let acceleration = physics.airborneAcceleration
-      let inertia = physics.airborneInertia
+      let acceleration = 0.0
+      let inertia = 0.0
       const blockUnder = world.getBlock(pos.offset(0, -1, 0))
       if (entity.onGround && blockUnder) {
         let playerSpeedAttribute
@@ -407,6 +535,14 @@ function Physics (mcData, world) {
         inertia = (blockSlipperiness[blockUnder.type] || physics.defaultSlipperiness) * 0.91
         acceleration = attributeSpeed * (0.1627714 / (inertia * inertia * inertia))
         if (acceleration < 0) acceleration = 0 // acceleration should not be negative
+      } else {
+        acceleration = physics.airborneAcceleration
+        inertia = physics.airborneInertia
+
+        if (entity.control.sprint) {
+          const airSprintFactor = physics.airborneAcceleration * 0.3
+          acceleration += airSprintFactor
+        }
       }
 
       applyHeading(entity, strafe, forward, acceleration)
@@ -433,46 +569,16 @@ function Physics (mcData, world) {
       vel.y *= physics.airdrag
       vel.x *= inertia
       vel.z *= inertia
-    } else {
-      // Water / Lava movement
-      const lastY = pos.y
-      let acceleration = physics.liquidAcceleration
-      const inertia = entity.isInWater ? physics.waterInertia : physics.lavaInertia
-      let horizontalInertia = inertia
-
-      if (entity.isInWater) {
-        let strider = Math.min(entity.depthStrider, 3)
-        if (!entity.onGround) {
-          strider *= 0.5
-        }
-        if (strider > 0) {
-          horizontalInertia += (0.546 - horizontalInertia) * strider / 3
-          acceleration += (0.7 - acceleration) * strider / 3
-        }
-
-        if (entity.dolphinsGrace > 0) horizontalInertia = 0.96
-      }
-
-      applyHeading(entity, strafe, forward, acceleration)
-      moveEntity(entity, world, vel.x, vel.y, vel.z)
-      vel.y *= inertia
-      vel.y -= (entity.isInWater ? physics.waterGravity : physics.lavaGravity) * gravityMultiplier
-      vel.x *= horizontalInertia
-      vel.z *= horizontalInertia
-
-      if (entity.isCollidedHorizontally && doesNotCollide(world, pos.offset(vel.x, vel.y + 0.6 - pos.y + lastY, vel.z))) {
-        vel.y = physics.outOfLiquidImpulse // jump out of liquid
-      }
     }
   }
 
-  function isMaterialInBB (world, queryBB, type) {
+  function isMaterialInBB (world, queryBB, types) {
     const cursor = new Vec3(0, 0, 0)
     for (cursor.y = Math.floor(queryBB.minY); cursor.y <= Math.floor(queryBB.maxY); cursor.y++) {
       for (cursor.z = Math.floor(queryBB.minZ); cursor.z <= Math.floor(queryBB.maxZ); cursor.z++) {
         for (cursor.x = Math.floor(queryBB.minX); cursor.x <= Math.floor(queryBB.maxX); cursor.x++) {
           const block = world.getBlock(cursor)
-          if (block && block.type === type) return true
+          if (block && types.includes(block.type)) return true
         }
       }
     }
@@ -487,7 +593,7 @@ function Physics (mcData, world) {
     if (!block) return -1
     if (waterLike.has(block.type)) return 0
     if (block.getProperties().waterlogged) return 0
-    if (block.type !== waterId) return -1
+    if (!waterIds.includes(block.type)) return -1
     const meta = block.metadata
     return meta >= 8 ? 0 : meta
   }
@@ -534,7 +640,7 @@ function Physics (mcData, world) {
       for (cursor.z = Math.floor(bb.minZ); cursor.z <= Math.floor(bb.maxZ); cursor.z++) {
         for (cursor.x = Math.floor(bb.minX); cursor.x <= Math.floor(bb.maxX); cursor.x++) {
           const block = world.getBlock(cursor)
-          if (block && (block.type === waterId || waterLike.has(block.type) || block.getProperties().waterlogged)) {
+          if (block && (waterIds.includes(block.type) || waterLike.has(block.type) || block.getProperties().waterlogged)) {
             const waterLevel = cursor.y + 1 - getLiquidHeightPcent(block)
             if (Math.ceil(bb.maxY) >= waterLevel) waterBlocks.push(block)
           }
@@ -570,7 +676,7 @@ function Physics (mcData, world) {
     const lavaBB = getPlayerBB(pos).contract(0.1, 0.4, 0.1)
 
     entity.isInWater = isInWaterApplyCurrent(world, waterBB, vel)
-    entity.isInLava = isMaterialInBB(world, lavaBB, lavaId)
+    entity.isInLava = isMaterialInBB(world, lavaBB, lavaIds)
 
     // Reset velocity component if it falls under the threshold
     if (Math.abs(vel.x) < physics.negligeableVelocity) vel.x = 0
@@ -608,6 +714,20 @@ function Physics (mcData, world) {
       forward *= physics.sneakSpeed
     }
 
+    entity.elytraFlying = entity.elytraFlying && entity.elytraEquipped && !entity.onGround && !entity.levitation
+
+    if (entity.fireworkRocketDuration > 0) {
+      if (!entity.elytraFlying) {
+        entity.fireworkRocketDuration = 0
+      } else {
+        const { lookDir } = getLookingVector(entity)
+        vel.x += lookDir.x * 0.1 + (lookDir.x * 1.5 - vel.x) * 0.5
+        vel.y += lookDir.y * 0.1 + (lookDir.y * 1.5 - vel.y) * 0.5
+        vel.z += lookDir.z * 0.1 + (lookDir.z * 1.5 - vel.z) * 0.5
+        --entity.fireworkRocketDuration
+      }
+    }
+
     moveEntityWithHeading(entity, world, strafe, forward)
 
     return entity
@@ -646,33 +766,10 @@ function getEnchantmentLevel (mcData, enchantmentName, enchantments) {
   return 0
 }
 
-function getStatusEffectNamesForVersion (supportFeature) {
-  if (supportFeature('effectNamesAreRegistryNames')) {
-    return {
-      jumpBoostEffectName: 'jump_boost',
-      speedEffectName: 'speed',
-      slownessEffectName: 'slowness',
-      dolphinsGraceEffectName: 'dolphins_grace',
-      slowFallingEffectName: 'slow_falling',
-      levitationEffectName: 'levitation'
-    }
-  } else {
-    return {
-      jumpBoostEffectName: 'JumpBoost',
-      speedEffectName: 'Speed',
-      slownessEffectName: 'Slowness',
-      dolphinsGraceEffectName: 'DolphinsGrace',
-      slowFallingEffectName: 'SlowFalling',
-      levitationEffectName: 'Levitation'
-    }
-  }
-}
-
 class PlayerState {
   constructor (bot, control) {
     const mcData = require('minecraft-data')(bot.version)
     const nbt = require('prismarine-nbt')
-    const supportFeature = makeSupportFeature(mcData)
 
     // Input / Outputs
     this.pos = bot.entity.position.clone()
@@ -683,8 +780,10 @@ class PlayerState {
     this.isInWeb = bot.entity.isInWeb
     this.isCollidedHorizontally = bot.entity.isCollidedHorizontally
     this.isCollidedVertically = bot.entity.isCollidedVertically
+    this.elytraFlying = bot.entity.elytraFlying
     this.jumpTicks = bot.jumpTicks
     this.jumpQueued = bot.jumpQueued
+    this.fireworkRocketDuration = bot.fireworkRocketDuration
 
     // Input only (not modified)
     this.attributes = bot.entity.attributes
@@ -694,15 +793,14 @@ class PlayerState {
 
     // effects
     const effects = bot.entity.effects
-    const statusEffectNames = getStatusEffectNamesForVersion(supportFeature)
 
-    this.jumpBoost = getEffectLevel(mcData, statusEffectNames.jumpBoostEffectName, effects)
-    this.speed = getEffectLevel(mcData, statusEffectNames.speedEffectName, effects)
-    this.slowness = getEffectLevel(mcData, statusEffectNames.slownessEffectName, effects)
+    this.jumpBoost = getEffectLevel(mcData, 'JumpBoost', effects)
+    this.speed = getEffectLevel(mcData, 'Speed', effects)
+    this.slowness = getEffectLevel(mcData, 'Slowness', effects)
 
-    this.dolphinsGrace = getEffectLevel(mcData, statusEffectNames.dolphinsGraceEffectName, effects)
-    this.slowFalling = getEffectLevel(mcData, statusEffectNames.slowFallingEffectName, effects)
-    this.levitation = getEffectLevel(mcData, statusEffectNames.levitationEffectName, effects)
+    this.dolphinsGrace = getEffectLevel(mcData, 'DolphinsGrace', effects)
+    this.slowFalling = getEffectLevel(mcData, 'SlowFalling', effects)
+    this.levitation = getEffectLevel(mcData, 'Levitation', effects)
 
     // armour enchantments
     const boots = bot.inventory.slots[8]
@@ -713,6 +811,10 @@ class PlayerState {
     } else {
       this.depthStrider = 0
     }
+
+    // extra elytra requirements
+    const item = bot.inventory.slots[6]
+    this.elytraEquipped = item != null && item.name === 'elytra'
   }
 
   apply (bot) {
@@ -724,8 +826,10 @@ class PlayerState {
     bot.entity.isInWeb = this.isInWeb
     bot.entity.isCollidedHorizontally = this.isCollidedHorizontally
     bot.entity.isCollidedVertically = this.isCollidedVertically
+    bot.entity.elytraFlying = this.elytraFlying
     bot.jumpTicks = this.jumpTicks
     bot.jumpQueued = this.jumpQueued
+    bot.fireworkRocketDuration = this.fireworkRocketDuration
   }
 }
 

package/lib/features.json

@@ -7,7 +7,7 @@
   {
     "name": "proportionalLiquidGravity",
     "description": "Liquid gravity is a proportion of normal gravity",
-    "versions": ["1.13", "1.14", "1.15", "1.16", "1.17", "1.18", "1.19", "1.20"]
+    "versions": ["1.13", "1.14", "1.15", "1.16", "1.17", "1.18", "1.19", "1.20", "1.21"]
   },
   {
     "name": "velocityBlocksOnCollision",
@@ -23,10 +23,5 @@
     "name": "climbUsingJump",
     "description": "Entity can climb ladders and vines by pressing jump",
     "versions": ["1.14", "1.15", "1.17", "1.18"]
-  },
-  {
-    "name": "effectNamesAreRegistryNames",
-    "description": "Status effect names equal to their registry names",
-    "versions": ["1.17", "1.18"]
   }
 ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prismarine-physics",
-  "version": "1.7.0",
+  "version": "1.9.0",
   "description": "Provide the physics engine for minecraft entities",
   "main": "index.js",
   "directories": {

package/test/basic.test.js

@@ -27,11 +27,14 @@ function fakePlayer (pos) {
       isInWeb: false,
       isCollidedHorizontally: false,
       isCollidedVertically: false,
+      elytraFlying: false,
       yaw: 0,
+      pitch: 0,
       effects: {}
     },
     jumpTicks: 0,
     jumpQueued: false,
+    fireworkRocketDuration: 0,
     version: '1.13.2',
     inventory: {
       slots: []

package/test/elytra.test.js

@@ -0,0 +1,692 @@
+/* eslint-env mocha */
+
+const { Physics, PlayerState } = require('prismarine-physics')
+const { Vec3 } = require('vec3')
+const expect = require('expect')
+
+const mcData = require('minecraft-data')('1.13.2')
+const Block = require('prismarine-block')('1.13.2')
+
+const fakeWorld = {
+  getBlock: (pos) => {
+    const type = (pos.y < 60) ? mcData.blocksByName.stone.id : mcData.blocksByName.air.id
+    const b = new Block(type, 0, 0)
+    b.position = pos
+    return b
+  }
+}
+
+const fakeWallWorld = {
+  getBlock: (pos) => {
+    const type = (pos.y < 60 || pos.x > 50) ? mcData.blocksByName.stone.id : mcData.blocksByName.air.id
+    const b = new Block(type, 0, 0)
+    b.position = pos
+    return b
+  }
+}
+
+const fakeWebWorld = {
+  getBlock: (pos) => {
+    const type = (pos.y < 60) ? mcData.blocksByName.stone.id : mcData.blocksByName.cobweb.id
+    const b = new Block(type, 0, 0)
+    b.position = pos
+    return b
+  }
+}
+
+const waterWorld = {
+  getBlock: (pos) => {
+    const type = (pos.y < 60) ? mcData.blocksByName.water.id : mcData.blocksByName.air.id
+    const b = new Block(type, 0, 0)
+    b.position = pos
+    return b
+  }
+}
+
+const lavaWorld = {
+  getBlock: (pos) => {
+    const type = (pos.y < 60) ? mcData.blocksByName.lava.id : mcData.blocksByName.air.id
+    const b = new Block(type, 0, 0)
+    b.position = pos
+    return b
+  }
+}
+
+function fakePlayer (pos) {
+  return {
+    entity: {
+      position: pos,
+      velocity: new Vec3(0, 0, 0),
+      onGround: false,
+      isInWater: false,
+      isInLava: false,
+      isInWeb: false,
+      isCollidedHorizontally: false,
+      isCollidedVertically: false,
+      elytraFlying: false,
+      yaw: Math.PI * 3 / 2, // east (+x)
+      pitch: 20 * Math.PI / 180,
+      effects: {}
+    },
+    jumpTicks: 0,
+    jumpQueued: false,
+    fireworkRocketDuration: 0,
+    version: '1.13.2',
+    inventory: {
+      slots: []
+    }
+  }
+}
+
+function untilIdle (player, physics, world, controls) {
+  const playerState = new PlayerState(player, controls)
+  while (!playerState.onGround || playerState.vel.x !== 0 || playerState.vel.z !== 0) {
+    physics.simulatePlayer(playerState, world)
+  }
+  playerState.apply(player)
+}
+
+function passTicks (ticks, player, physics, world, controls) {
+  const playerState = new PlayerState(player, controls)
+  for (let i = 0; i < ticks; ++i) {
+    physics.simulatePlayer(playerState, world)
+  }
+  playerState.apply(player)
+}
+
+function mpsToTps (mps) {
+  // 20 ticks per second
+  return mps / 20
+}
+
+describe('Elytra tests', () => {
+  it('flies east and then back', () => {
+    const physics = Physics(mcData, fakeWorld)
+    const controls = {
+      forward: false,
+      back: false,
+      left: false,
+      right: false,
+      jump: false,
+      sprint: false,
+      sneak: false
+    }
+    const player = fakePlayer(new Vec3(0, 61, 0))
+    player.inventory.slots[6] = { name: 'elytra' }
+
+    // wait til on ground
+    untilIdle(player, physics, fakeWorld, controls)
+
+    expect(player.entity.position).toEqual(new Vec3(0, 60, 0))
+
+    // jump
+    player.jumpQueued = true
+    passTicks(10, player, physics, fakeWorld, controls)
+    expect(player.entity.onGround).toBeFalsy()
+
+    // fly
+    player.entity.elytraFlying = true
+    passTicks(1, player, physics, fakeWorld, controls)
+
+    // boost
+    player.fireworkRocketDuration = 20
+
+    // wait til on ground
+    untilIdle(player, physics, fakeWorld, controls)
+
+    expect(player.entity.elytraFlying).toBeFalsy()
+    expect(player.fireworkRocketDuration).toEqual(0)
+
+    expect(player.entity.position.x).toBeGreaterThan(140)
+    expect(player.entity.position.y).toEqual(60)
+    expect(player.entity.position.z).toBeCloseTo(0)
+
+    // turn around
+    player.entity.yaw = Math.PI / 2 // west (-x)
+
+    // jump
+    player.jumpQueued = true
+    passTicks(10, player, physics, fakeWorld, controls)
+
+    expect(player.entity.onGround).toBeFalsy()
+
+    // fly
+    player.entity.elytraFlying = true
+    passTicks(1, player, physics, fakeWorld, controls)
+    expect(player.entity.elytraFlying).toBeTruthy()
+
+    // boost
+    player.fireworkRocketDuration = 20
+
+    // wait til on ground
+    untilIdle(player, physics, fakeWorld, controls)
+
+    expect(player.entity.elytraFlying).toBeFalsy()
+    expect(player.fireworkRocketDuration).toEqual(0)
+
+    // should be back at start
+    expect(player.entity.position.x).toBeCloseTo(0)
+    expect(player.entity.position.y).toEqual(60)
+    expect(player.entity.position.z).toBeCloseTo(0)
+  })
+
+  it('flies south and then back', () => {
+    const physics = Physics(mcData, fakeWorld)
+    const controls = {
+      forward: false,
+      back: false,
+      left: false,
+      right: false,
+      jump: false,
+      sprint: false,
+      sneak: false
+    }
+    const player = fakePlayer(new Vec3(0, 61, 0))
+    player.inventory.slots[6] = { name: 'elytra' }
+    player.entity.yaw = 0 // north (-z)
+
+    // wait til on ground
+    untilIdle(player, physics, fakeWorld, controls)
+
+    expect(player.entity.position).toEqual(new Vec3(0, 60, 0))
+
+    // jump
+    player.jumpQueued = true
+    passTicks(10, player, physics, fakeWorld, controls)
+    expect(player.entity.onGround).toBeFalsy()
+
+    // fly
+    player.entity.elytraFlying = true
+    passTicks(1, player, physics, fakeWorld, controls)
+
+    // boost
+    player.fireworkRocketDuration = 20
+
+    // wait til on ground
+    untilIdle(player, physics, fakeWorld, controls)
+
+    expect(player.entity.elytraFlying).toBeFalsy()
+    expect(player.fireworkRocketDuration).toEqual(0)
+
+    expect(player.entity.position.x).toBeCloseTo(0)
+    expect(player.entity.position.y).toEqual(60)
+    expect(player.entity.position.z).toBeLessThan(-140)
+
+    // turn around
+    player.entity.yaw = Math.PI // south (z)
+
+    // jump
+    player.jumpQueued = true
+    passTicks(10, player, physics, fakeWorld, controls)
+
+    expect(player.entity.onGround).toBeFalsy()
+
+    // fly
+    player.entity.elytraFlying = true
+    passTicks(1, player, physics, fakeWorld, controls)
+    expect(player.entity.elytraFlying).toBeTruthy()
+
+    // boost
+    player.fireworkRocketDuration = 20
+
+    // wait til on ground
+    untilIdle(player, physics, fakeWorld, controls)
+
+    expect(player.entity.elytraFlying).toBeFalsy()
+    expect(player.fireworkRocketDuration).toEqual(0)
+
+    // should be back at start
+    expect(player.entity.position.x).toBeCloseTo(0)
+    expect(player.entity.position.y).toEqual(60)
+    expect(player.entity.position.z).toBeCloseTo(0)
+  })
+
+  it('flies north east and then back', () => {
+    const physics = Physics(mcData, fakeWorld)
+    const controls = {
+      forward: false,
+      back: false,
+      left: false,
+      right: false,
+      jump: false,
+      sprint: false,
+      sneak: false
+    }
+    const player = fakePlayer(new Vec3(0, 61, 0))
+    player.inventory.slots[6] = { name: 'elytra' }
+    // facing positive z, to the left is positive x
+    player.entity.yaw = -Math.PI / 4 + 2 * Math.PI // right 45 degrees of north (-z), towards east (+x)
+
+    // wait til on ground
+    untilIdle(player, physics, fakeWorld, controls)
+
+    expect(player.entity.position).toEqual(new Vec3(0, 60, 0))
+
+    // jump
+    player.jumpQueued = true
+    passTicks(10, player, physics, fakeWorld, controls)
+    expect(player.entity.onGround).toBeFalsy()
+
+    // fly
+    player.entity.elytraFlying = true
+    passTicks(1, player, physics, fakeWorld, controls)
+
+    // boost
+    player.fireworkRocketDuration = 20
+
+    // wait til on ground
+    untilIdle(player, physics, fakeWorld, controls)
+
+    expect(player.entity.elytraFlying).toBeFalsy()
+    expect(player.fireworkRocketDuration).toEqual(0)
+
+    expect(player.entity.position.x).toBeGreaterThan(140 * Math.sin(Math.PI / 4))
+    expect(player.entity.position.y).toEqual(60)
+    expect(player.entity.position.z).toBeLessThan(-140 * Math.sin(Math.PI / 4))
+
+    // turn around
+    player.entity.yaw = -Math.PI / 4 + Math.PI // south (z)
+
+    // jump
+    player.jumpQueued = true
+    passTicks(10, player, physics, fakeWorld, controls)
+
+    expect(player.entity.onGround).toBeFalsy()
+
+    // fly
+    player.entity.elytraFlying = true
+    passTicks(1, player, physics, fakeWorld, controls)
+    expect(player.entity.elytraFlying).toBeTruthy()
+
+    // boost
+    player.fireworkRocketDuration = 20
+
+    // wait til on ground
+    untilIdle(player, physics, fakeWorld, controls)
+
+    expect(player.entity.elytraFlying).toBeFalsy()
+    expect(player.fireworkRocketDuration).toEqual(0)
+
+    // should be back at start
+    expect(player.entity.position.x).toBeCloseTo(0)
+    expect(player.entity.position.y).toEqual(60)
+    expect(player.entity.position.z).toBeCloseTo(0)
+  })
+
+  it('stops flight without elytra', () => {
+    const physics = Physics(mcData, fakeWorld)
+    const controls = {
+      forward: false,
+      back: false,
+      left: false,
+      right: false,
+      jump: false,
+      sprint: false,
+      sneak: false
+    }
+    const player = fakePlayer(new Vec3(0, 80, 0))
+    player.inventory.slots[6] = { name: 'elytra' }
+
+    player.entity.elytraFlying = true
+    player.fireworkRocketDuration = 20
+    physics.simulatePlayer(new PlayerState(player, controls), fakeWorld).apply(player)
+    expect(player.entity.elytraFlying).toBeTruthy()
+    expect(player.fireworkRocketDuration).toEqual(19)
+    player.inventory.slots[6] = undefined
+    physics.simulatePlayer(new PlayerState(player, controls), fakeWorld).apply(player)
+    expect(player.entity.elytraFlying).toBeFalsy()
+    expect(player.fireworkRocketDuration).toEqual(0)
+  })
+
+  it('can fly out of water', () => {
+    const physics = Physics(mcData, waterWorld)
+    const controls = {
+      forward: false,
+      back: false,
+      left: false,
+      right: false,
+      jump: false,
+      sprint: false,
+      sneak: false
+    }
+    const player = fakePlayer(new Vec3(0, 40, 0))
+    player.inventory.slots[6] = { name: 'elytra' }
+    player.entity.pitch = 80 * Math.PI / 180
+
+    player.entity.elytraFlying = true
+    physics.simulatePlayer(new PlayerState(player, controls), waterWorld).apply(player)
+    expect(player.entity.isInWater).toBeTruthy()
+    expect(player.entity.elytraFlying).toBeTruthy()
+    physics.simulatePlayer(new PlayerState(player, controls), waterWorld).apply(player)
+    expect(player.entity.isInWater).toBeTruthy()
+    expect(player.entity.elytraFlying).toBeTruthy()
+
+    player.fireworkRocketDuration = 20
+    physics.simulatePlayer(new PlayerState(player, controls), waterWorld).apply(player)
+    expect(player.entity.elytraFlying).toBeTruthy()
+    expect(player.fireworkRocketDuration).toEqual(19)
+
+    const playerState = new PlayerState(player, controls)
+    while (playerState.isInWater) {
+      playerState.fireworkRocketDuration = 1
+      physics.simulatePlayer(playerState, waterWorld)
+    }
+    playerState.apply(player)
+    expect(player.fireworkRocketDuration).toEqual(0)
+    expect(player.entity.position.y).toBeGreaterThan(59)
+  })
+
+  it('can fly out of lava', () => {
+    const physics = Physics(mcData, lavaWorld)
+    const controls = {
+      forward: false,
+      back: false,
+      left: false,
+      right: false,
+      jump: false,
+      sprint: false,
+      sneak: false
+    }
+    const player = fakePlayer(new Vec3(0, 40, 0))
+    player.inventory.slots[6] = { name: 'elytra' }
+    player.entity.pitch = 80 * Math.PI / 180
+
+    player.entity.elytraFlying = true
+    physics.simulatePlayer(new PlayerState(player, controls), lavaWorld).apply(player)
+    expect(player.entity.isInLava).toBeTruthy()
+    expect(player.entity.elytraFlying).toBeTruthy()
+    physics.simulatePlayer(new PlayerState(player, controls), lavaWorld).apply(player)
+    expect(player.entity.isInLava).toBeTruthy()
+    expect(player.entity.elytraFlying).toBeTruthy()
+
+    player.fireworkRocketDuration = 20
+    physics.simulatePlayer(new PlayerState(player, controls), lavaWorld).apply(player)
+    expect(player.entity.elytraFlying).toBeTruthy()
+    expect(player.fireworkRocketDuration).toEqual(19)
+
+    const playerState = new PlayerState(player, controls)
+    while (playerState.isInLava) {
+      playerState.fireworkRocketDuration = 1
+      physics.simulatePlayer(playerState, lavaWorld)
+    }
+    playerState.apply(player)
+    expect(player.fireworkRocketDuration).toEqual(0)
+    expect(player.entity.position.y).toBeGreaterThan(59)
+  })
+
+  it('landing while jumping stops flight', () => {
+    const physics = Physics(mcData, fakeWorld)
+    const controls = {
+      forward: false,
+      back: false,
+      left: false,
+      right: false,
+      jump: false,
+      sprint: false,
+      sneak: false
+    }
+    const player = fakePlayer(new Vec3(0, 61, 0))
+    player.inventory.slots[6] = { name: 'elytra' }
+
+    // wait til on ground
+    untilIdle(player, physics, fakeWorld, controls)
+    expect(player.entity.position).toEqual(new Vec3(0, 60, 0))
+
+    // jump
+    player.jumpQueued = true
+    passTicks(10, player, physics, fakeWorld, controls)
+    expect(player.entity.onGround).toBeFalsy()
+
+    // fly
+    player.entity.elytraFlying = true
+    passTicks(1, player, physics, fakeWorld, controls)
+
+    // boost
+    player.fireworkRocketDuration = 20
+    passTicks(10, player, physics, fakeWorld, controls)
+    expect(player.entity.onGround).toBeFalsy()
+
+    controls.jump = true
+    const playerState = new PlayerState(player, controls)
+    while (!playerState.onGround) {
+      expect(playerState.elytraFlying).toBeTruthy()
+      physics.simulatePlayer(playerState, fakeWorld)
+    }
+    playerState.apply(player)
+    expect(player.entity.onGround).toBeTruthy()
+    expect(player.entity.elytraFlying).toBeFalsy()
+
+    // let jump controls cause a jump
+    passTicks(10, player, physics, fakeWorld, controls)
+    expect(player.entity.onGround).toBeFalsy()
+    expect(player.entity.elytraFlying).toBeFalsy()
+  })
+
+  it('cant fly in webs', () => {
+    const webPhysics = Physics(mcData, fakeWebWorld)
+    const airPhysics = Physics(mcData, fakeWorld)
+    const controls = {
+      forward: false,
+      back: false,
+      left: false,
+      right: false,
+      jump: false,
+      sprint: false,
+      sneak: false
+    }
+    const airPlayer = fakePlayer(new Vec3(0, 150, 0))
+    airPlayer.inventory.slots[6] = { name: 'elytra' }
+    airPlayer.entity.elytraFlying = true
+    passTicks(20 * 10, airPlayer, airPhysics, fakeWorld, controls)
+
+    const webPlayer = fakePlayer(new Vec3(0, 150, 0))
+    webPlayer.inventory.slots[6] = { name: 'elytra' }
+    webPlayer.entity.elytraFlying = true
+    passTicks(20 * 10, webPlayer, webPhysics, fakeWebWorld, controls)
+
+    // web player should have barely moved
+    expect(webPlayer.entity.position.x).toBeGreaterThan(0)
+    expect(webPlayer.entity.position.x).toBeLessThan(1)
+    expect(webPlayer.entity.position.y).toBeGreaterThan(149)
+
+    // elytra player should be far away and much lower
+    expect(airPlayer.entity.position.x).toBeGreaterThan(200)
+    expect(airPlayer.entity.position.y).toBeLessThan(110)
+  })
+
+  it('can hit a wall', () => {
+    const physics = Physics(mcData, fakeWallWorld)
+    const controls = {
+      forward: false,
+      back: false,
+      left: false,
+      right: false,
+      jump: false,
+      sprint: false,
+      sneak: false
+    }
+    const player = fakePlayer(new Vec3(0, 100, 0))
+    player.inventory.slots[6] = { name: 'elytra' }
+    player.entity.elytraFlying = true
+    player.fireworkRocketDuration = 100
+
+    // let bot accelerate from firework
+    passTicks(10, player, physics, fakeWallWorld, controls)
+
+    // should be moving 30 m/s (30 / 20 m/tick)
+    expect(player.entity.velocity.x).toBeGreaterThan(mpsToTps(30))
+
+    // until near wall
+    const playerState = new PlayerState(player, controls)
+    while (playerState.pos.x < 49) {
+      physics.simulatePlayer(playerState, fakeWallWorld)
+    }
+    playerState.apply(player)
+
+    // should still be moving fast
+    expect(player.entity.velocity.x).toBeGreaterThan(mpsToTps(30))
+
+    // 1 / (30/20) = 2/3, so 1 tick should be enough to hit the wall
+    passTicks(1, player, physics, fakeWallWorld, controls)
+
+    // it should have stopped in the x direction
+    expect(player.entity.velocity.x).toBeCloseTo(0)
+  })
+
+  it('can flight straight up', () => {
+    const physics = Physics(mcData, fakeWallWorld)
+    const controls = {
+      forward: false,
+      back: false,
+      left: false,
+      right: false,
+      jump: false,
+      sprint: false,
+      sneak: false
+    }
+    const player = fakePlayer(new Vec3(0, 100, 0))
+    player.inventory.slots[6] = { name: 'elytra' }
+    player.entity.elytraFlying = true
+    player.entity.pitch = Math.PI / 2
+    player.fireworkRocketDuration = 20
+
+    // let bot accelerate from firework
+    passTicks(20, player, physics, fakeWallWorld, controls)
+
+    // should be moving very fast
+    expect(player.entity.velocity.y).toBeGreaterThan(mpsToTps(25))
+    expect(player.entity.position.x).toBeCloseTo(0)
+    expect(player.entity.position.z).toBeCloseTo(0)
+
+    passTicks(20, player, physics, fakeWallWorld, controls)
+    expect(player.entity.velocity.y).toBeLessThan(mpsToTps(10))
+    expect(player.entity.position.x).toBeCloseTo(0)
+    expect(player.entity.position.z).toBeCloseTo(0)
+
+    passTicks(20, player, physics, fakeWallWorld, controls)
+    expect(player.entity.velocity.y).toBeLessThan(0)
+    expect(player.entity.position.x).toBeCloseTo(0)
+    expect(player.entity.position.z).toBeCloseTo(0)
+
+    passTicks(20, player, physics, fakeWallWorld, controls)
+    expect(player.entity.velocity.y).toBeLessThan(mpsToTps(20))
+    expect(player.entity.position.x).toBeCloseTo(0)
+    expect(player.entity.position.z).toBeCloseTo(0)
+  })
+
+  it('can flight straight down', () => {
+    const physics = Physics(mcData, fakeWallWorld)
+    const controls = {
+      forward: false,
+      back: false,
+      left: false,
+      right: false,
+      jump: false,
+      sprint: false,
+      sneak: false
+    }
+    const player = fakePlayer(new Vec3(0, 1000, 0))
+    player.inventory.slots[6] = { name: 'elytra' }
+    player.entity.elytraFlying = true
+    player.entity.pitch = -Math.PI / 2
+    player.fireworkRocketDuration = 20
+
+    // let bot accelerate from firework
+    passTicks(200, player, physics, fakeWallWorld, controls)
+
+    // should be moving very fast
+    expect(player.entity.position.y).toBeGreaterThan(100)
+    expect(player.entity.velocity.y).toBeLessThan(mpsToTps(-60))
+    expect(player.entity.position.x).toBeCloseTo(0)
+    expect(player.entity.position.z).toBeCloseTo(0)
+
+    // using firework actually slows the bot down
+    player.fireworkRocketDuration = 20
+    passTicks(10, player, physics, fakeWallWorld, controls)
+
+    // should be slower now
+    expect(player.entity.position.y).toBeGreaterThan(100)
+    expect(player.entity.velocity.y).toBeGreaterThan(mpsToTps(-40))
+    expect(player.entity.position.x).toBeCloseTo(0)
+    expect(player.entity.position.z).toBeCloseTo(0)
+  })
+
+  it('flies to point and then back', () => {
+    const physics = Physics(mcData, fakeWorld)
+    const controls = {
+      forward: false,
+      back: false,
+      left: false,
+      right: false,
+      jump: false,
+      sprint: false,
+      sneak: false
+    }
+    const player = fakePlayer(new Vec3(0, 61, 0))
+    player.inventory.slots[6] = { name: 'elytra' }
+
+    // wait til on ground
+    untilIdle(player, physics, fakeWorld, controls)
+
+    expect(player.entity.position).toEqual(new Vec3(0, 60, 0))
+
+    const unNormedFacing = new Vec3(300, 60, 400)
+    const facing = unNormedFacing.scale(1 / unNormedFacing.xzDistanceTo(new Vec3(0, 60, 0)))
+
+    // yaw is facing north (-z) and rotating to the left, west (-z), so
+    // atan2(-x, -z) is yaw
+    const yaw = Math.atan2(-facing.x, -facing.z)
+    player.entity.yaw = yaw
+
+    // jump
+    player.jumpQueued = true
+    passTicks(10, player, physics, fakeWorld, controls)
+    expect(player.entity.onGround).toBeFalsy()
+
+    // fly
+    player.entity.elytraFlying = true
+    passTicks(1, player, physics, fakeWorld, controls)
+
+    // boost
+    player.fireworkRocketDuration = 20
+
+    // wait til on ground
+    untilIdle(player, physics, fakeWorld, controls)
+
+    expect(player.entity.elytraFlying).toBeFalsy()
+    expect(player.fireworkRocketDuration).toEqual(0)
+
+    facing.scale(player.entity.position.xzDistanceTo(new Vec3(0, 60, 0)))
+    expect(player.entity.position.x).toBeCloseTo(facing.x)
+    expect(player.entity.position.y).toBeCloseTo(60)
+    expect(player.entity.position.z).toBeCloseTo(facing.z)
+
+    // turn around
+    player.entity.yaw += Math.PI
+
+    // jump
+    player.jumpQueued = true
+    passTicks(10, player, physics, fakeWorld, controls)
+
+    expect(player.entity.onGround).toBeFalsy()
+
+    // fly
+    player.entity.elytraFlying = true
+    passTicks(1, player, physics, fakeWorld, controls)
+    expect(player.entity.elytraFlying).toBeTruthy()
+
+    // boost
+    player.fireworkRocketDuration = 20
+
+    // wait til on ground
+    untilIdle(player, physics, fakeWorld, controls)
+
+    expect(player.entity.elytraFlying).toBeFalsy()
+    expect(player.fireworkRocketDuration).toEqual(0)
+
+    // should be back at start
+    expect(player.entity.position.x).toBeCloseTo(0)
+    expect(player.entity.position.y).toEqual(60)
+    expect(player.entity.position.z).toBeCloseTo(0)
+  })
+})