sword

How to use

requirerotate()

parameters

Parameter	Default Value	Type	Description
bladePos		vec2	vec2(38, 0)
jointPos		vec2	vec2(0, 0)
onGuardRotation		number	20
onGuardPos		vec2	vec2(28, 10)
onGuardSpeed		number	0.4
rotation		number	90
coolDownDelay		number	0.4
sprite		string	'sword'
tag		string	'*'
width		number	29
danger		boolean	true
flipX		boolean	true
danger		object	{}
duration		number	0.2
anchor		vec2	vec2(0, 0.8)
areaScale		vec2	vec2(0.8, 0.6)
areaOffset		vec2	vec2(0, -20)
bladeSwingAngle		number	0
bladeSwingAmp		number	0
bladeSwingDuration		number	0
wristSwingAngle		number	0
wristSwingAmp		number	0
wristSwingDuration		number	0
stabDistance		number	0
stabDuration		number	0
impactPower		number	6
impactDuration		number	0.15
aimAngle		number	0

example

sword({
  bladePos: vec2(38, 0),
  jointPos: vec2(0, 0),
  onGuardRotation: 20,
  onGuardPos: vec2(28, 10),
  onGuardSpeed: 0.4,
  rotation: 90,
  coolDownDelay: 0.4,
  sprite: 'sword',
  tag: '*',
  width: 29,
  danger: true,
  flipX: true,
  danger: {},
  duration: 0.2,
  anchor: vec2(0, 0.8),
  areaScale: vec2(0.8, 0.6),
  areaOffset: vec2(0, -20),
  bladeSwingAngle: 0,
  bladeSwingAmp: 0,
  bladeSwingDuration: 0,
  wristSwingAngle: 0,
  wristSwingAmp: 0,
  wristSwingDuration: 0,
  stabDistance: 0,
  stabDuration: 0,
  impactPower: 6,
  impactDuration: 0.15,
  aimAngle: 0
}),

Source

component.js

function sword(p) {
  const param = {
    bladePos: vec2(38, 0),
    jointPos: vec2(0, 0),
    onGuardRotation: 20,
    onGuardPos: vec2(28, 10),
    onGuardSpeed: 0.4,
    rotation: 90,
    coolDownDelay: 0.4,
    sprite: 'sword',
    tag: '*',
    width: 29,
    danger: true,
    flipX: true,
    danger: {},
    duration: 0.2,
    anchor: vec2(0, 0.8),
    areaScale: vec2(0.8, 0.6),
    areaOffset: vec2(0, -20),
    bladeSwingAngle: 0,
    bladeSwingAmp: 0,
    bladeSwingDuration: 0,
    wristSwingAngle: 0,
    wristSwingAmp: 0,
    wristSwingDuration: 0,
    stabDistance: 0,
    stabDuration: 0,
    impactPower: 6,
    impactDuration: 0.15,
    aimAngle: 0,
    ...p,
  };
  return {
    id: 'sword',
    require: ['rotate'],
    swordOn: false,
    add() {
      let angle = 0;
      let savedTime = time();
      let delay = 0;
      const joint = this.add([pos(param.jointPos), rotate()]);
      const blade = joint.add([
        sprite(param.sprite, {
          width: param.width,
        }),
        pos(vec2(param.onGuardPos)),
        anchor(param.anchor),
        rotate(param.onGuardRotation),
        danger({
          on: false,
          ...param.danger,
        }),
        area({
          scale: param.areaScale,
          offset: param.areaOffset,
          isSensor: true,
        }),
        'blade',
      ]);
      blade.onCollide('blade', (obj, col) => {
        if (blade.dangerOn && obj.dangerOn)
          obj.trigger('sword impact', {
            from: this.pos,
            col: col,
          });
      });
      blade.onCollide(param.tag, (obj) => {
        if (blade.dangerOn && obj.has('body') && !obj.isStatic)
          tween(
            obj.pos.sub(this.pos).scale(param.impactPower),
            vec2(0, 0),
            param.impactDuration,
            (v) => (obj.vel = v),
            easings.easeOutSine
          );
      });
      blade.on('sword impact', (p) =>
        tween(
          this.pos.sub(p.from).scale(param.impactPower),
          vec2(0, 0),
          param.impactDuration,
          (v) => (this.vel = v),
          easings.easeOutSine
        )
      );
      this.on('aiming', (p) => (angle = p));
      this.on('sword stroke', (p) => {
        const moveParam = {
          ...param,
          ...p,
        };
        const mirror = moveParam.flipX && Math.abs(angle) > 90 ? -1 : 1;
        blade.pos = vec2(moveParam.bladePos);
        blade.angle = moveParam.rotation;
        blade.dangerOn = true;
        tween(
          (-moveParam.bladeSwingAmp / 2 + moveParam.bladeSwingAngle) * mirror,
          (moveParam.bladeSwingAmp / 2 + moveParam.bladeSwingAngle) * mirror,
          moveParam.bladeSwingDuration,
          (v) => (blade.angle = param.rotation + v),
          easings.easeOutSine
        );
        tween(
          (-moveParam.wristSwingAmp / 2 + moveParam.wristSwingAngle) * mirror +
            joint.angle,
          (moveParam.wristSwingAmp / 2 + moveParam.wristSwingAngle) * mirror +
            joint.angle,
          moveParam.wristSwingDuration,
          (v) => (joint.angle = v),
          easings.easeOutSine
        );
        tween(
          0,
          moveParam.stabDistance,
          moveParam.stabDuration,
          (v) => (blade.pos.x = param.bladePos.x + v),
          easings.easeOutSine
        );
        delay = moveParam.duration;
        savedTime = time();
      });
      this.on('hit', () => (blade.dangerOn = false));
      onUpdate(() => {
        joint.angle = angle - this.angle;
        if (blade.dangerOn && time() - savedTime > delay)
          blade.dangerOn = false;
        if (!blade.dangerOn) {
          const mirror = param.flipX && Math.abs(joint.angle) > 90;
          const onGuardRotation = mirror
            ? 180 - param.onGuardRotation
            : param.onGuardRotation;
          const onGuardPos = mirror
            ? param.onGuardPos.scale(1, -1)
            : param.onGuardPos.scale(1, 1);
          blade.pos = lerp(blade.pos, vec2(onGuardPos), param.onGuardSpeed);
          blade.angle = lerp(blade.angle, onGuardRotation, param.onGuardSpeed);
          blade.dangerOn = false;
          blade.flipX = mirror;
        }
      });
    },
  };
}