@swf2es/player 0.0.0-stage → 0.1.1

package/src/avm1/input.ts

@@ -0,0 +1,556 @@
+// An AVM1 movie's input as its scripts see it: Key's state and its
+// listeners, keyPress's buttons and clips, Mouse's listeners and wheel,
+// and the pointer's button events to buttons and to clips in button mode,
+// in Ruffle's (https://github.com/ruffle-rs/ruffle) order (Avm1Button,
+// MovieClip's event_dispatch: MIT OR Apache-2.0, Copyright (c) 2018-2022
+// Ruffle LLC and Ruffle contributors). avm1/keyboard.ts and
+// avm1/pointer.ts turn the host's events into these.
+import { ButtonCondition, ClipEvent } from "@swf2es/format";
+import { avm1 } from "@swf2es/runtime";
+import { ButtonObject, Container, type DisplayObject, MovieClip } from "../display/display.js";
+import type { Avm1 } from "./avm1.js";
+import type { InputState } from "./globals/Key.js";
+import { ClipNative, nativeOf } from "./globals/MovieClip.js";
+import { BLOCK, NO_ARGS, NO_BLOCKS, NORMAL, NOTIFY, Queued } from "./queue.js";
+import { handlersOfButton, NO_HANDLERS } from "./swf.js";
+
+/** The pointer's events that make a clip a button where its clip actions have one (Ruffle's BUTTON_EVENT_FLAGS). */
+const BUTTON_EVENTS =
+  ClipEvent.press |
+  ClipEvent.release |
+  ClipEvent.releaseOutside |
+  ClipEvent.rollOver |
+  ClipEvent.rollOut |
+  ClipEvent.dragOver |
+  ClipEvent.dragOut |
+  ClipEvent.keyPress;
+
+/** The AS2 methods that make a clip a button where its object, or what it inherits, has one. */
+const BUTTON_METHODS = [
+  "onPress",
+  "onRelease",
+  "onReleaseOutside",
+  "onRollOver",
+  "onRollOut",
+  "onDragOver",
+  "onDragOut",
+];
+
+/** BUTTON_METHODS as a SWF from 7 names them, and as one up to 6 does, folded. */
+const BUTTON_NAMES = new Set(BUTTON_METHODS);
+const BUTTON_NAMES_FOLDED = new Set(BUTTON_METHODS.map((name) => avm1.fold(name)));
+
+// Objects never given one of them are passed by (buttonMode).
+avm1.markNames(BUTTON_METHODS);
+
+/** The most prototypes a lookup walks, as the runtime's. */
+const DEPTH = 255;
+
+/** The button transition each of the pointer's events is, by the event's bit (Ruffle's Avm1Button). */
+const CONDITIONS = new Map<number, number>([
+  [ClipEvent.rollOver, ButtonCondition.idleToOverUp],
+  [ClipEvent.rollOut, ButtonCondition.overUpToIdle],
+  [ClipEvent.press, ButtonCondition.overUpToOverDown],
+  [ClipEvent.release, ButtonCondition.overDownToOverUp],
+  [ClipEvent.releaseOutside, ButtonCondition.outDownToIdle],
+  [ClipEvent.dragOut, ButtonCondition.overDownToOutDown],
+  [ClipEvent.dragOver, ButtonCondition.outDownToOverDown],
+]);
+
+/** The frame label a clip in button mode goes to and stops at on each of the pointer's events. */
+const LABELS = new Map<number, string>([
+  [ClipEvent.rollOut, "_up"],
+  [ClipEvent.releaseOutside, "_up"],
+  [ClipEvent.rollOver, "_over"],
+  [ClipEvent.release, "_over"],
+  [ClipEvent.dragOut, "_over"],
+  [ClipEvent.press, "_down"],
+  [ClipEvent.dragOver, "_down"],
+]);
+
+/** What Mouse's listeners hear of the pointer's clip events. */
+const MOUSE_MESSAGES = new Map<number, string>([
+  [ClipEvent.mouseMove, "onMouseMove"],
+  [ClipEvent.mouseDown, "onMouseDown"],
+  [ClipEvent.mouseUp, "onMouseUp"],
+]);
+
+/** The state a button goes to on each of the pointer's events (Ruffle's Avm1Button: a drag out shows over). */
+const BUTTON_STATES = new Map<number, "up" | "over" | "down">([
+  [ClipEvent.rollOver, "over"],
+  [ClipEvent.rollOut, "up"],
+  [ClipEvent.press, "down"],
+  [ClipEvent.release, "over"],
+  [ClipEvent.releaseOutside, "up"],
+  [ClipEvent.dragOut, "over"],
+  [ClipEvent.dragOver, "down"],
+]);
+
+/** The movie's keys and pointer, as its scripts see them. */
+export class Avm1Input implements InputState {
+  /** The keys down by Flash's codes, the mouse's buttons among them as 1, 2 and 4. */
+  private readonly keysDown = new Set<number>();
+  /**
+   * The keys toggled on, by their codes: each press of a key, a mouse
+   * button's too, turns it on or off, Caps Lock's as any other's (the
+   * corpus's `key_isToggled`).
+   */
+  private readonly toggled = new Set<number>();
+  keyCode = 0;
+  keyAscii = 0;
+  private shown = true;
+  /** `_global.Key` and `_global.Mouse`, whose listeners the player sends their messages. */
+  keyFace: avm1.Avm1Object | null = null;
+  mouseFace: avm1.Avm1Object | null = null;
+
+  constructor(private readonly movie: Avm1) {}
+
+  keyIsDown(code: number): boolean {
+    return this.keysDown.has(code);
+  }
+
+  keyToggled(code: number): boolean {
+    return this.toggled.has(code);
+  }
+
+  /**
+   * Every key let go, with no event, as the player loses focus
+   * (Player.setActive): their releases go elsewhere and never come. The
+   * mouse's buttons, 1, 2 and 4, stay the pointer's, which tells their
+   * releases. What is toggled stays, as a release toggles nothing.
+   */
+  releaseKeys(): void {
+    for (const code of this.keysDown) {
+      if (code !== 1 && code !== 2 && code !== 4) {
+        this.keysDown.delete(code);
+      }
+    }
+  }
+
+  get mouseShown(): boolean {
+    return this.shown;
+  }
+
+  set mouseShown(shown: boolean) {
+    this.shown = shown;
+    this.movie.pointer?.updateCursor();
+  }
+
+  /** A mouse button, as the pointer gives it (0 left, 1 middle, 2 right), down or up: Key's 1, 4 or 2. */
+  mouseButton(button: number, down: boolean): void {
+    const code = button === 0 ? 1 : button === 1 ? 4 : button === 2 ? 2 : 0;
+    if (code === 0) {
+      return;
+    }
+
+    this.keyState(code, down);
+  }
+
+  /**
+   * A key down or up in Key's state: the last key, a press toggling it
+   * unless it was already down (a held key's repeats do not), as Ruffle's
+   * input state has it.
+   */
+  private keyState(code: number, down: boolean): void {
+    this.keyCode = code;
+    if (code === 0) {
+      return;
+    }
+
+    if (!down) {
+      this.keysDown.delete(code);
+      return;
+    }
+
+    if (!this.keysDown.has(code) && !this.toggled.delete(code)) {
+      this.toggled.add(code);
+    }
+
+    this.keysDown.add(code);
+  }
+
+  /**
+   * A key pressed or let go (avm1/keyboard.ts), as Ruffle orders it:
+   * every clip's keyDown or keyUp clip actions, as they are drawn, then Key's
+   * listeners' onKeyDown or onKeyUp; then, for a press of a key that
+   * `press` is a keyPress of, the first button or clip in the order they
+   * are drawn whose keyPress it is runs its actions for it. The queue runs
+   * once. Whether a keyPress ran.
+   */
+  key(
+    down: boolean,
+    keyCode: number,
+    charCode: number,
+    press: number,
+    typed = 0,
+    shift = false,
+  ): boolean {
+    if (this.movie.halted || !this.movie.loaded) {
+      return false;
+    }
+
+    this.keyState(keyCode, down);
+    this.keyAscii = charCode;
+    this.movie.timers.begin();
+    try {
+      // To the clips as they are drawn, the lowest first, what is in one before it (Ruffle's order).
+      // What has the focus also hears onKeyDown or onKeyUp, from SWF 6, while the highlight is active.
+      const event = down ? ClipEvent.keyDown : ClipEvent.keyUp;
+      const focused = this.movie.focusTracker.focusedObject;
+      const heard =
+        this.movie.version >= 6 &&
+        this.movie.focusTracker.highlight !== "inactive" &&
+        focused !== null &&
+        this.flag(focused, "enabled")
+          ? focused
+          : null;
+      const visit = (d: DisplayObject) => {
+        if (d instanceof Container) {
+          for (const child of d.children) {
+            visit(child);
+          }
+        }
+
+        if (d instanceof MovieClip) {
+          this.movie.dispatch(d, event, d === heard);
+        } else if (d instanceof ButtonObject && d === heard) {
+          this.movie.method(d, event, false);
+        }
+      };
+      for (const level of this.movie.levelClips()) {
+        visit(level);
+      }
+
+      this.notify(this.keyFace, down ? "onKeyDown" : "onKeyUp");
+      const pressed = down && press !== 0 && this.queueKeyPress(press);
+
+      // A key no keyPress took: Tab moves the focus, after what is queued runs; Enter and Space
+      // press what has it.
+      let used = pressed;
+      if (down && !pressed && keyCode === 9) {
+        this.movie.queue.run();
+        // A movie with nothing to tab to leaves Tab to the page.
+        used = this.movie.focusTracker.tab(shift);
+      } else if (down && !pressed && (keyCode === 13 || typed === 32)) {
+        // A press it made keeps the page from acting on the key too: Space would scroll it.
+        used = this.movie.focusTracker.activate();
+      }
+
+      this.movie.queue.run();
+      return used;
+    } finally {
+      this.movie.timers.end();
+    }
+  }
+
+  /** Text typed with no key events (avm1/keyboard.ts): a keyPress of its character, as `key` runs one. */
+  keyPress(press: number): boolean {
+    if (this.movie.halted || !this.movie.loaded || press === 0) {
+      return false;
+    }
+
+    this.movie.timers.begin();
+    try {
+      const pressed =
+        this.queueKeyPress(press) || (press === 32 && this.movie.focusTracker.activate());
+      this.movie.queue.run();
+      return pressed;
+    } finally {
+      this.movie.timers.end();
+    }
+  }
+
+  /**
+   * The first button or clip, as they are drawn, the lowest first and what
+   * is in one before it, whose keyPress is `press`: a button's condition
+   * blocks with that key, enabled or not, with its parent as target; a
+   * clip's `on (keyPress)` clip actions. A hidden clip takes none, nor what
+   * is in it, a hidden button none while it is up, and a button in a button
+   * none. Whether one was queued.
+   */
+  private queueKeyPress(press: number): boolean {
+    const visit = (d: DisplayObject, inButton: boolean): boolean => {
+      const button = d instanceof ButtonObject ? d : null;
+      if (!d.visible && (button === null || button.state === "up")) {
+        return false;
+      }
+
+      if (d instanceof Container) {
+        for (const child of d.children) {
+          if (visit(child, inButton || button !== null)) {
+            return true;
+          }
+        }
+      }
+
+      if (button) {
+        const id = button.character?.id;
+        let found = false;
+        if (!inButton && button.parent !== null && id !== undefined) {
+          const swf = this.movie.swfOf(button);
+          for (const h of handlersOfButton(swf, id)) {
+            if (h.key === press) {
+              this.movie.queue.enqueue(NORMAL, new Queued(BLOCK, button.parent, swf, h.block));
+              found = true;
+            }
+          }
+        }
+
+        return found;
+      }
+
+      const native = d instanceof MovieClip ? nativeOf(d) : null;
+      if (native !== null && this.movie.swfOf(d).version >= 5) {
+        let found = false;
+        for (const h of native.handlers ?? NO_HANDLERS) {
+          if (h.events & ClipEvent.keyPress && h.key === press) {
+            this.movie.queue.enqueue(NORMAL, new Queued(BLOCK, d, native.swf, h.block));
+            found = true;
+          }
+        }
+
+        return found;
+      }
+
+      return false;
+    };
+
+    return this.movie.levelClips().some((level) => visit(level, false));
+  }
+
+  /** `object`'s listeners told `name` with `args`, queued after what is queued now. */
+  private notify(object: avm1.Avm1Object | null, name: string, args: avm1.Value[] = NO_ARGS): void {
+    if (object !== null && this.movie.root !== null) {
+      this.movie.queue.enqueue(
+        NORMAL,
+        new Queued(NOTIFY, this.movie.root, null, 0, 0, false, name, NO_BLOCKS, object, args),
+      );
+    }
+  }
+
+  /** Whether Mouse has listeners, which the wheel would tell: the page keeps it otherwise. */
+  get mouseHeard(): boolean {
+    const face = this.mouseFace;
+    const listeners = face === null ? undefined : avm1.get(face, "_listeners", this.movie.version);
+    return (
+      listeners instanceof avm1.Avm1Object &&
+      avm1.toNumber(avm1.get(listeners, "length", this.movie.version), this.movie.version) > 0
+    );
+  }
+
+  /** The wheel turned by `delta` lines over `target`: Mouse's listeners' onMouseWheel, then the queue runs. */
+  mouseWheel(delta: number, target: DisplayObject | null): void {
+    if (this.movie.halted || !this.movie.loaded) {
+      return;
+    }
+
+    this.movie.timers.begin();
+    try {
+      this.notify(this.mouseFace, "onMouseWheel", [delta, target?.avm1 ?? undefined]);
+      this.movie.queue.run();
+    } finally {
+      this.movie.timers.end();
+    }
+  }
+
+  /**
+   * Whether the pointer takes `clip` as a button (Ruffle's is_button_mode):
+   * its clip actions have one of the pointer's button events, or, below
+   * the root, its object has one of their AS2 methods, its own or
+   * inherited, a class's among them.
+   */
+  buttonMode(clip: MovieClip): boolean {
+    const native = nativeOf(clip);
+    for (const h of native?.handlers ?? NO_HANDLERS) {
+      if (h.events & BUTTON_EVENTS) {
+        return true;
+      }
+    }
+
+    const face = clip.avm1;
+    const version = this.movie.version;
+    if (face === null || clip === this.movie.root || version < 6) {
+      return false;
+    }
+
+    // avm1.has for each name, the pointer asking it of every clip it passes:
+    // the clip's children by name, which its object finds after its own
+    // properties, looked over once for all the names; then along the chain
+    // only the objects ever given one of them, and any with locals it
+    // makes as asked, an activation's, or a display object's own side.
+    const names = version > 6 ? BUTTON_NAMES : BUTTON_NAMES_FOLDED;
+    if (face.display !== null) {
+      for (const child of clip.children) {
+        const name = child.name;
+        if (name !== "" && names.has(version > 6 ? name : avm1.fold(name))) {
+          return true;
+        }
+      }
+    }
+
+    let o: avm1.Value = face;
+    for (let depth = 0; o instanceof avm1.Avm1Object && depth < DEPTH; depth++) {
+      if (o.marked || o.lazy !== null) {
+        for (const name of BUTTON_METHODS) {
+          if (o.own(name, version) !== undefined) {
+            return true;
+          }
+        }
+      }
+
+      if (depth > 0 && o.display !== null) {
+        for (const name of BUTTON_METHODS) {
+          if (o.display.get(name, version) !== avm1.ABSENT) {
+            return true;
+          }
+        }
+      }
+
+      o = o.protoFor(version);
+    }
+
+    return false;
+  }
+
+  /** A button's or clip's AS2 flag, `enabled` or `useHandCursor`: true where it is undefined, as Flash reads it. */
+  flag(d: DisplayObject, name: "enabled" | "useHandCursor"): boolean {
+    const value = this.read(d, name);
+    return value === undefined || avm1.toBoolean(value, this.movie.version);
+  }
+
+  /** What a clip's `hitArea` names, a clip or button the pointer tests in its place; null for none. */
+  hitArea(clip: MovieClip): DisplayObject | null {
+    if (this.movie.version < 6) {
+      return null;
+    }
+
+    const area = this.read(clip, "hitArea");
+    const display = area instanceof avm1.Avm1Object ? area.display : null;
+    return display instanceof ClipNative ? display.target : null;
+  }
+
+  /**
+   * `d`'s AVM1 object's property `name`, read as code reads it, in an
+   * activation of `d`'s, as a getter `addProperty` gave it may be AVM1
+   * code; undefined where it has no object, or the read throws. Within
+   * a script, the begin and end go for nothing: the script's own hold.
+   */
+  read(d: DisplayObject, name: string): avm1.Value {
+    const face = d.avm1;
+    const cx = this.movie.halted ? null : this.movie.activationOf(d);
+    if (face === null || cx === null) {
+      return undefined;
+    }
+
+    let value: avm1.Value;
+    this.movie.timers.begin();
+    try {
+      this.movie.rt.call(cx, () => {
+        value = avm1.get(face, name, this.movie.version);
+      });
+    } finally {
+      this.movie.timers.end();
+    }
+
+    return value;
+  }
+
+  /**
+   * The pointer's button events, each to its object, in the order given,
+   * then the queue runs once. A button runs its condition blocks for the
+   * transition, with its parent as target, plays the transition's sound
+   * and changes state, then, from SWF 6, its AS2 method; a clip in button
+   * mode goes to the event's frame label, if it has one, and stops, then
+   * runs its clip actions and method for it. Ruffle's order (Avm1Button
+   * and MovieClip's event_dispatch).
+   */
+  buttonEvents(events: readonly (readonly [DisplayObject, number])[]): void {
+    if (this.movie.halted || !this.movie.loaded || events.length === 0) {
+      return;
+    }
+
+    this.movie.timers.begin();
+    try {
+      for (const [d, event] of events) {
+        this.buttonDispatch(d, event);
+      }
+
+      this.movie.queue.run();
+    } finally {
+      this.movie.timers.end();
+    }
+  }
+
+  /** One of the pointer's button events to `d`, a button or a clip in button mode, queued. */
+  buttonDispatch(d: DisplayObject, event: number): void {
+    if (this.movie.removed(d)) {
+      return;
+    }
+
+    if (d instanceof ButtonObject) {
+      this.buttonEvent(d, event);
+    } else if (d instanceof MovieClip) {
+      const label = LABELS.get(event);
+      const timeline = this.movie.timeline(d);
+      const frame = label === undefined ? undefined : timeline.labelFrame(label);
+      if (frame !== undefined) {
+        timeline.goto(frame, false);
+      }
+
+      this.movie.dispatch(d, event);
+    }
+  }
+
+  private buttonEvent(button: ButtonObject, event: number): void {
+    const condition = CONDITIONS.get(event) ?? 0;
+    const parent = button.parent;
+    const id = button.character?.id;
+    if (parent !== null && id !== undefined) {
+      const swf = this.movie.swfOf(button);
+      for (const h of handlersOfButton(swf, id)) {
+        if (h.conditions & condition) {
+          this.movie.queue.enqueue(NORMAL, new Queued(BLOCK, parent, swf, h.block));
+        }
+      }
+    }
+
+    const state = BUTTON_STATES.get(event);
+    if (state !== undefined && state !== button.state) {
+      // A drag's transitions are silent.
+      button.setState(state, event !== ClipEvent.dragOut && event !== ClipEvent.dragOver);
+    }
+
+    this.movie.method(button, event, false);
+  }
+
+  /**
+   * Broadcast a pointer's event (avm1/pointer.ts): every clip's clip
+   * actions for it, the newest first, then Mouse's listeners, then the
+   * queue runs. A key's go by `key`.
+   */
+  clipEvent(event: number): void {
+    if (this.movie.halted || !this.movie.loaded) {
+      return;
+    }
+
+    this.movie.timers.begin();
+    try {
+      for (let i = this.movie.clips.length - 1; i >= 0; i--) {
+        const clip = this.movie.clips[i];
+        if (!this.movie.removed(clip)) {
+          this.movie.dispatch(clip, event);
+        }
+      }
+
+      // Mouse's listeners after every clip's, as Ruffle queues them.
+      const message = MOUSE_MESSAGES.get(event);
+      if (message !== undefined) {
+        this.notify(this.mouseFace, message);
+      }
+
+      this.movie.queue.run();
+    } finally {
+      this.movie.timers.end();
+    }
+  }
+}

package/src/avm1/keyboard.ts

@@ -0,0 +1,133 @@
+// The keyboard of an AVM1 movie: each key goes to Key, its clips' keyDown
+// and keyUp clip actions, and a press to the first button or clip whose
+// keyPress it is (input.ts's key). A keyPress's key is Flash's own code, as
+// Ruffle's ButtonKeyCode has it (https://github.com/ruffle-rs/ruffle,
+// core/src/events.rs: MIT OR Apache-2.0, Copyright (c) 2018-2022 Ruffle
+// LLC and Ruffle contributors): a printable character's ASCII code, or one
+// of the editing keys' below 20. A host whose text comes apart from its
+// keys (the corpus's replay) gives the character by `text`.
+
+import { TextObject } from "../display/display.js";
+import type { ClipboardText } from "../hosts.js";
+import type { Keyboard, KeyState } from "../input/keyboard.js";
+import { pasteable, TextEditor } from "../input/text-editor.js";
+import type { Avm1 } from "./avm1.js";
+
+/** The editing keys' keyPress codes, by Flash's key codes. */
+const KEY_PRESSES = new Map<number, number>([
+  [37, 1], // Left
+  [39, 2], // Right
+  [36, 3], // Home
+  [35, 4], // End
+  [45, 5], // Insert
+  [46, 6], // Delete
+  [8, 8], // Backspace
+  [13, 13], // Enter
+  [38, 14], // Up
+  [40, 15], // Down
+  [33, 16], // Page Up
+  [34, 17], // Page Down
+  [9, 18], // Tab
+  [27, 19], // Escape
+]);
+
+/** A printable ASCII character's keyPress code, its own; 0 for any other. */
+const printable = (charCode: number) => (charCode >= 32 && charCode <= 126 ? charCode : 0);
+
+export class Avm1Keyboard implements Keyboard {
+  handled = 0;
+  private readonly editor = new TextEditor((field) => {
+    const movie = this.avm1;
+    movie.timers.begin();
+    try {
+      field.fit();
+      movie.textChanged(field);
+      if (field.avm1) {
+        movie.callback(field.avm1, "broadcastMessage", ["onChanged", field.avm1]);
+      }
+
+      movie.queue.run();
+    } finally {
+      movie.timers.end();
+    }
+  });
+
+  constructor(private readonly avm1: Avm1) {}
+
+  /** A key: its keyPress, where it is one, the editing key's, else, with edits, its character's. */
+  handle(type: "down" | "up", k: KeyState, edits = true): boolean {
+    this.handled++;
+    if (type === "up") {
+      this.avm1.input.key(false, k.keyCode, k.charCode, 0);
+      return false;
+    }
+
+    const typed = edits ? printable(k.charCode) : 0;
+    const press = KEY_PRESSES.get(k.keyCode) ?? typed;
+    const used = this.avm1.input.key(true, k.keyCode, k.charCode, press, typed, !!k.shiftKey);
+    return used || (edits && k.keyCode !== 9 && this.edit(k));
+  }
+
+  text(k: KeyState): boolean {
+    this.handled++;
+    const used = this.avm1.input.keyPress(printable(k.charCode));
+    return used || this.edit(k);
+  }
+
+  private field(): TextObject | null {
+    const d = this.avm1.focused;
+    return !this.avm1.halted && d instanceof TextObject && !this.avm1.removed(d) ? d : null;
+  }
+
+  private edit(k: KeyState): boolean {
+    const field = this.field();
+    if (!field || (field.type !== "input" && !field.selectable)) {
+      return false;
+    }
+
+    if (k.ctrlKey && !k.altKey && k.keyCode === 65) {
+      if (field.selectable) {
+        field.select(0, field.model.text.length);
+      }
+
+      return true;
+    }
+
+    return this.editor.edit(field, k);
+  }
+
+  copy(cut = false): ClipboardText | null {
+    this.handled++;
+    const field = this.field();
+    if (!field || field.displayAsPassword || (cut && field.type !== "input")) {
+      return null;
+    }
+
+    const [from, to] = field.selection;
+    if (from === to) {
+      return null;
+    }
+
+    const data = { text: field.model.text.slice(from, to).replace(/\r\n?/g, "\n") };
+    if (cut) {
+      this.editor.replace(field, from, to, "");
+    }
+
+    return data;
+  }
+
+  paste(data: ClipboardText | null = null): boolean {
+    this.handled++;
+    const field = this.field();
+    if (field?.type !== "input" || !data) {
+      return false;
+    }
+
+    const text = pasteable(field.multiline, data.text);
+    if (text !== "") {
+      this.editor.type(field, text);
+    }
+
+    return true;
+  }
+}