7a89051384
harmonic field now has no cooldown after blocking negative mass field accelerates slower, but with a higher top speed negative mass field harm reduction is now 60% and always on mod degenerate matter increases the damage reduction from 60% to 80% falling damage and damage from blocks have been removed (I'm trying it out, let me know if you want it back)
258 lines
10 KiB
JavaScript
258 lines
10 KiB
JavaScript
//matter.js ***********************************************************
|
|
// module aliases
|
|
const Engine = Matter.Engine,
|
|
World = Matter.World,
|
|
Events = Matter.Events,
|
|
Composites = Matter.Composites,
|
|
Composite = Matter.Composite,
|
|
Constraint = Matter.Constraint,
|
|
Vertices = Matter.Vertices,
|
|
Query = Matter.Query,
|
|
Body = Matter.Body,
|
|
Bodies = Matter.Bodies,
|
|
Vector = Matter.Vector;
|
|
|
|
// create an engine
|
|
const engine = Engine.create();
|
|
engine.world.gravity.scale = 0; //turn off gravity (it's added back in later)
|
|
// engine.velocityIterations = 100
|
|
// engine.positionIterations = 100
|
|
// engine.enableSleeping = true
|
|
|
|
// matter events
|
|
function playerOnGroundCheck(event) {
|
|
//runs on collisions events
|
|
function enter() {
|
|
mech.numTouching++;
|
|
if (!mech.onGround) mech.enterLand();
|
|
}
|
|
const pairs = event.pairs;
|
|
for (let i = 0, j = pairs.length; i != j; ++i) {
|
|
let pair = pairs[i];
|
|
if (pair.bodyA === jumpSensor) {
|
|
mech.standingOn = pair.bodyB; //keeping track to correctly provide recoil on jump
|
|
if (mech.standingOn.alive !== true) enter();
|
|
} else if (pair.bodyB === jumpSensor) {
|
|
mech.standingOn = pair.bodyA; //keeping track to correctly provide recoil on jump
|
|
if (mech.standingOn.alive !== true) enter();
|
|
}
|
|
}
|
|
mech.numTouching = 0;
|
|
}
|
|
|
|
function playerOffGroundCheck(event) {
|
|
//runs on collisions events
|
|
function enter() {
|
|
if (mech.onGround && mech.numTouching === 0) mech.enterAir();
|
|
}
|
|
const pairs = event.pairs;
|
|
for (let i = 0, j = pairs.length; i != j; ++i) {
|
|
if (pairs[i].bodyA === jumpSensor) {
|
|
enter();
|
|
} else if (pairs[i].bodyB === jumpSensor) {
|
|
enter();
|
|
}
|
|
}
|
|
}
|
|
|
|
// function playerHeadCheck(event) {
|
|
// //runs on collisions events
|
|
// if (mech.crouch) {
|
|
// mech.isHeadClear = true;
|
|
// const pairs = event.pairs;
|
|
// for (let i = 0, j = pairs.length; i != j; ++i) {
|
|
// if (pairs[i].bodyA === headSensor) {
|
|
// mech.isHeadClear = false;
|
|
// } else if (pairs[i].bodyB === headSensor) {
|
|
// mech.isHeadClear = false;
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
function collisionChecks(event) {
|
|
const pairs = event.pairs;
|
|
for (let i = 0, j = pairs.length; i != j; i++) {
|
|
|
|
// //map + bullet collisions
|
|
// if (pairs[i].bodyA.collisionFilter.category === cat.map && pairs[i].bodyB.collisionFilter.category === cat.bullet) {
|
|
// collideBulletStatic(pairs[i].bodyB)
|
|
// } else if (pairs[i].bodyB.collisionFilter.category === cat.map && pairs[i].bodyA.collisionFilter.category === cat.bullet) {
|
|
// collideBulletStatic(pairs[i].bodyA)
|
|
// }
|
|
// //triggers when the bullets hits something static
|
|
// function collideBulletStatic(obj, speedThreshold = 12, massThreshold = 2) {
|
|
// if (obj.onWallHit) obj.onWallHit();
|
|
// }
|
|
|
|
|
|
//body + player collision
|
|
// if (game.isBodyDamage) {
|
|
// if (pairs[i].bodyA === playerBody || pairs[i].bodyA === playerHead) {
|
|
// collidePlayer(pairs[i].bodyB)
|
|
// } else if (pairs[i].bodyB === playerBody || pairs[i].bodyB === playerHead) {
|
|
// collidePlayer(pairs[i].bodyA)
|
|
// }
|
|
// }
|
|
|
|
// function collidePlayer(obj) {
|
|
// //player dmg from hitting a body
|
|
// if (obj.classType === "body" && obj.speed > 10 && mech.immuneCycle < mech.cycle) {
|
|
// const velocityThreshold = 30 //keep this lines up with player.enterLand numbers (130/5 = 26)
|
|
// if (player.position.y > obj.position.y) { //block is above the player look at total momentum difference
|
|
// const velocityDiffMag = Vector.magnitude(Vector.sub(player.velocity, obj.velocity))
|
|
// if (velocityDiffMag > velocityThreshold) hit(velocityDiffMag - velocityThreshold)
|
|
// } else { //block is below player only look at horizontal momentum difference
|
|
// const velocityDiffMagX = Math.abs(obj.velocity.x - player.velocity.x)
|
|
// if (velocityDiffMagX > velocityThreshold) hit(velocityDiffMagX - velocityThreshold)
|
|
// }
|
|
|
|
// function hit(dmg) {
|
|
// mech.immuneCycle = mech.cycle + mod.collisionImmuneCycles; //player is immune to collision damage for 30 cycles
|
|
// dmg = Math.min(Math.max(Math.sqrt(dmg) * obj.mass * 0.01, 0.02), 0.15);
|
|
// mech.damage(dmg);
|
|
// game.drawList.push({ //add dmg to draw queue
|
|
// x: pairs[i].activeContacts[0].vertex.x,
|
|
// y: pairs[i].activeContacts[0].vertex.y,
|
|
// radius: dmg * 500,
|
|
// color: game.mobDmgColor,
|
|
// time: game.drawTime
|
|
// });
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
//mob + (player,bullet,body) collisions
|
|
for (let k = 0; k < mob.length; k++) {
|
|
if (mob[k].alive && mech.alive) {
|
|
if (pairs[i].bodyA === mob[k]) {
|
|
collideMob(pairs[i].bodyB);
|
|
break;
|
|
} else if (pairs[i].bodyB === mob[k]) {
|
|
collideMob(pairs[i].bodyA);
|
|
break;
|
|
}
|
|
|
|
function collideMob(obj) {
|
|
//player + mob collision
|
|
if (mech.immuneCycle < mech.cycle && (obj === playerBody || obj === playerHead)) {
|
|
// const a = Object.values(event.pairs[0].contacts)
|
|
// contains = Matter.Bounds.contains({
|
|
// max: {
|
|
// x: player.position.x + 60,
|
|
// y: player.position.y + 120
|
|
// },
|
|
// min: {
|
|
// x: player.position.x - 60,
|
|
// y: player.position.y + 40
|
|
// }
|
|
// }, {
|
|
// x: a[0].vertex.x,
|
|
// y: a[0].vertex.y
|
|
// })
|
|
// // Matter.Query.point([jumpSensor], point)
|
|
// console.log(contains)
|
|
// if (!contains) {
|
|
|
|
mech.immuneCycle = mech.cycle + mod.collisionImmuneCycles; //player is immune to collision damage for 30 cycles
|
|
mob[k].foundPlayer();
|
|
let dmg = Math.min(Math.max(0.025 * Math.sqrt(mob[k].mass), 0.05), 0.3) * game.dmgScale; //player damage is capped at 0.3*dmgScale of 1.0
|
|
if (mod.isPiezo) {
|
|
mech.energy = mech.maxEnergy;
|
|
dmg *= 0.85
|
|
}
|
|
mech.damage(dmg);
|
|
if (mob[k].onHit) mob[k].onHit(k);
|
|
|
|
//extra kick between player and mob //this section would be better with forces but they don't work...
|
|
let angle = Math.atan2(player.position.y - mob[k].position.y, player.position.x - mob[k].position.x);
|
|
Matter.Body.setVelocity(player, {
|
|
x: player.velocity.x + 8 * Math.cos(angle),
|
|
y: player.velocity.y + 8 * Math.sin(angle)
|
|
});
|
|
Matter.Body.setVelocity(mob[k], {
|
|
x: mob[k].velocity.x - 8 * Math.cos(angle),
|
|
y: mob[k].velocity.y - 8 * Math.sin(angle)
|
|
});
|
|
|
|
if (mod.isAnnihilation && !mob[k].shield && !mob[k].isShielded) {
|
|
mob[k].death();
|
|
game.drawList.push({
|
|
//add dmg to draw queue
|
|
x: pairs[i].activeContacts[0].vertex.x,
|
|
y: pairs[i].activeContacts[0].vertex.y,
|
|
radius: dmg * 2000,
|
|
color: "rgba(255,0,255,0.2)",
|
|
time: game.drawTime
|
|
});
|
|
} else {
|
|
game.drawList.push({
|
|
//add dmg to draw queue
|
|
x: pairs[i].activeContacts[0].vertex.x,
|
|
y: pairs[i].activeContacts[0].vertex.y,
|
|
radius: dmg * 500,
|
|
color: game.mobDmgColor,
|
|
time: game.drawTime
|
|
});
|
|
|
|
}
|
|
return;
|
|
// }
|
|
}
|
|
//mob + bullet collisions
|
|
if (obj.classType === "bullet" && obj.speed > obj.minDmgSpeed) {
|
|
// const dmg = b.dmgScale * (obj.dmg + 0.15 * obj.mass * Vector.magnitude(Vector.sub(mob[k].velocity, obj.velocity)));
|
|
let dmg = b.dmgScale * (obj.dmg + mod.acidDmg + 0.15 * obj.mass * Vector.magnitude(Vector.sub(mob[k].velocity, obj.velocity)))
|
|
// console.log(obj.dmg, 0.15 * obj.mass * Vector.magnitude(Vector.sub(mob[k].velocity, obj.velocity)))
|
|
// console.log(obj.dmg / (0.15 * obj.mass * Vector.magnitude(Vector.sub(mob[k].velocity, obj.velocity))))
|
|
if (mod.isCrit && !mob[k].seePlayer.recall && !mob[k].shield) dmg *= 5
|
|
mob[k].foundPlayer();
|
|
mob[k].damage(dmg);
|
|
obj.onDmg(mob[k]); //some bullets do actions when they hits things, like despawn
|
|
game.drawList.push({ //add dmg to draw queue
|
|
x: pairs[i].activeContacts[0].vertex.x,
|
|
y: pairs[i].activeContacts[0].vertex.y,
|
|
radius: Math.log(2 * dmg + 1.1) * 40,
|
|
color: game.playerDmgColor,
|
|
time: game.drawTime
|
|
});
|
|
return;
|
|
}
|
|
//mob + body collisions
|
|
if (obj.classType === "body" && obj.speed > 6) {
|
|
const v = Vector.magnitude(Vector.sub(mob[k].velocity, obj.velocity));
|
|
if (v > 9) {
|
|
let dmg = b.dmgScale * (v * obj.mass * 0.07) * mod.throwChargeRate;
|
|
if (mod.isCrit && !mob[k].seePlayer.recall && !mob[k].shield) dmg *= 5
|
|
if (mob[k].isShielded) dmg *= 0.5
|
|
mob[k].damage(dmg, true);
|
|
if (mob[k].distanceToPlayer2() < 1000000) mob[k].foundPlayer();
|
|
game.drawList.push({
|
|
x: pairs[i].activeContacts[0].vertex.x,
|
|
y: pairs[i].activeContacts[0].vertex.y,
|
|
radius: Math.log(2 * dmg + 1.1) * 40,
|
|
color: game.playerDmgColor,
|
|
time: game.drawTime
|
|
});
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//determine if player is on the ground
|
|
Events.on(engine, "collisionStart", function (event) {
|
|
playerOnGroundCheck(event);
|
|
// playerHeadCheck(event);
|
|
collisionChecks(event);
|
|
});
|
|
Events.on(engine, "collisionActive", function (event) {
|
|
playerOnGroundCheck(event);
|
|
// playerHeadCheck(event);
|
|
});
|
|
Events.on(engine, "collisionEnd", function (event) {
|
|
playerOffGroundCheck(event);
|
|
}); |