@@ -28,7 +28,7 @@
 from mhfu_studio.monster.panels import rows, triggers
 from mhfu_studio.monster.panels.common import kind
 from mhfu_studio.monster.panels.node_graph import GraphView, LinkSpec, NodeSpec
-from mhfu_studio.monster.panels.properties import Detail, Plays, PropertyBar
+from mhfu_studio.monster.panels.properties import Detail, Play, Plays, PropertyBar
 from mhfu_studio.monster.panels.widgets import NoScene
 from mhfu_studio.shell.overlay import Ink
 from mhfu_studio.ui import kit, theme
@@ -54,6 +54,7 @@
     " ports in All"
 )
 SCOPED = "Wire by dragging ports in All"
+UNPLACED = "A rule with no move yet is checked by nothing, so it has no place to move"
 
 
 class BehaviourPanel(kit.Panel):
@@ -78,6 +79,7 @@ def __init__(self, ws: MonsterWorkspace, studio: Studio) -> None:
         #: the rows now drawn (None: All), and what to pick once the next edit is drawn
         self._plan: rows.Plan | None = None
         self._after: tuple[str, str | None] | None = None
+        self._frame_after: str | None = None
         self._scope: str | None = None
         self._outlined: object = None
         self._palette = ALL
@@ -96,7 +98,6 @@ def __init__(self, ws: MonsterWorkspace, studio: Studio) -> None:
             tip="Adds a rule for this trigger. It is checked after every other rule: drag its"
             " frame up to raise it",
             on=self._add_rule,
-            icon="ph.plus",
         )
         self.spread = kit.button(
             "Spread out",
@@ -116,10 +117,12 @@ def __init__(self, ws: MonsterWorkspace, studio: Studio) -> None:
         v.picked.connect(self._picked)
         v.settled.connect(self._settle)
         v.menu_requested.connect(self._menu)
+        v.frame_moved.connect(self._frame_moved)
         self.bar = PropertyBar()
         self.bar.param_changed.connect(self._param)
         self.bar.label_changed.connect(self._label)
         self.bar.plays_changed.connect(self._plays)
+        self.bar.play_requested.connect(self._play)
 
         self.outline = triggers.Outline()
         self.outline.picked.connect(self._scoped)
@@ -177,6 +180,16 @@ def _plays(self, block: str, old: str | None, new: str | None) -> None:
         self._after = (block, new)
         self._settle()
 
+    def _play(self, move: str) -> None:
+        """Play in game, as the Moves panel does it, for `move`."""
+
+        def play() -> None:
+            if self.ws.move != move:
+                self.ws.select_move(move)
+            self.ws.play_move_in_game()
+
+        self.studio.act("play move in game", play)()
+
     def _add_rule(self) -> None:
         t, doc = self._current(), self.ws.doc
         if t is None or doc is None:
@@ -196,6 +209,9 @@ def _menu(self, node: str, menu: QMenu) -> None:
         row = plan.row_of(node) if plan is not None else None
         menu.setToolTipsVisible(True)
         if m is None or row is None:
+            move = graph.move_name(node)
+            if move is not None and plan is not None:
+                self._play_entry(menu, move)
             return
         ref = rows.ref_of(node)
         if ref is not None:  # a reference or the placeholder: before the play
@@ -205,6 +221,7 @@ def _menu(self, node: str, menu: QMenu) -> None:
                 menu.addAction("Delete the play").triggered.connect(
                     lambda: self._drop_play(block, move)
                 )
+                self._play_entry(menu, move)
             return
         shown = [n.id for n in row.nodes]
         k, block = shown.index(node), row.path.blocks[shown.index(node)]
@@ -227,6 +244,11 @@ def _insert_menu(
                 act.setToolTip(tip)
                 act.triggered.connect(lambda _=False, k=kind_: self._insert(after, k, to, play))
 
+    def _play_entry(self, menu: QMenu, move: str) -> None:
+        act = menu.addAction("Play in game")
+        act.setToolTip("Plays this move in the running game, as Play in game does in Moves")
+        act.triggered.connect(lambda: self._play(move))
+
     def _insert(self, after: str, kind_: str, to: str | None, play: str | None) -> None:
         doc = self.ws.doc
         if doc is None:
@@ -255,11 +277,7 @@ def _scope_all(self) -> bool:
 
     def _wire(self, edit: Callable[..., str], *wire: str) -> Callable[[graph.Edits], str]:
         """The edit of a wire intent, or the refusal a trigger's rows give for it."""
-        return (lambda e: edit(e, *wire)) if self._scope_all() else self._not_here
-
-    @staticmethod
-    def _not_here(_: graph.Edits) -> str:
-        raise ManifestError(SCOPED)
+        return (lambda e: edit(e, *wire)) if self._scope_all() else self._refuse(SCOPED)
 
     def _delete(self, ids: list[str]) -> None:
         plan = self._plan
@@ -288,6 +306,31 @@ def _delete(self, ids: list[str]) -> None:
             else:
                 self._collect(partial(graph.drop_block, block=rows.node_of(i)))
 
+    def _frame_moved(self, frame: str, x: float, y: float) -> None:
+        """A rule's frame dropped: the rule takes the place among its trigger's rules that the
+        drop is at, or the drop is refused and the frame goes back."""
+        plan = self._plan
+        row = next((r for r in plan.rows if r.id == frame), None) if plan is not None else None
+        if plan is None or row is None:
+            return
+        if row.rank is None:
+            self._collect(self._refuse(UNPLACED))
+            return
+        ranked = [r for r in plan.rows if r.rank is not None]
+        rects = self.view.frame_rects()
+        middle = rects[frame].center().y()
+        to = sum(1 for r in ranked if r is not row and rects[r.id].center().y() < middle)
+        paths = [r.path for r in ranked]
+        self._frame_after = f"{rows.FRAME}{ranked[to].rank}"  # the places are handed round
+        self._collect(lambda e: graph.move_rule(e, paths, ranked.index(row), to))
+
+    @staticmethod
+    def _refuse(why: str) -> Callable[[graph.Edits], str]:
+        def refuse(_: graph.Edits) -> str:
+            raise ManifestError(why)
+
+        return refuse
+
     def _delete_now(self, ids: list[str]) -> None:
         self._delete(ids)
         self._settle()
@@ -301,7 +344,7 @@ def _create(self, kind_: str, x: float, y: float) -> None:
         if doc is None:
             return
         if not self._scope_all():
-            self._collect(self._not_here)
+            self._collect(self._refuse(SCOPED))
             return
         self._made = model.new_id(doc.manifest.behaviour)
         self._collect(lambda e: graph.add_block(e, kind_, (x, y)))
@@ -311,14 +354,15 @@ def _settle(self) -> None:
         doc, gesture, dropped = self.ws.doc, self._gesture, self._dropped
         made, self._gesture, self._dropped, self._made = self._made, None, {}, None
         after, self._after = self._after, None
+        frame, self._frame_after = self._frame_after, None
         if doc is None:
             return
         if dropped:
             gesture = gesture or graph.Gesture(doc)
             gesture.run(lambda e: graph.move_nodes(e, dropped))
         if gesture is None:
             return
-        done = gesture
+        done, was = gesture, doc.manifest
 
         def edit() -> None:
             self.ws.edit("", done.commit)
@@ -329,6 +373,9 @@ def edit() -> None:
         if made is not None and m is not None and made in m.behaviour.blocks:
             self.view.select([made])
             self._show_bar()
+        elif frame is not None and m is not was and frame in self.view.frame_rects():
+            self.view.select([frame])
+            self._show_bar()
         elif after is not None and self._plan is not None:
             ends = [n.id for r in self._plan.rows for n in r.nodes if rows.ref_of(n.id) == after]
             if ends:
@@ -418,7 +465,7 @@ def _detail(self, m: Manifest, shown: str) -> Detail | None:
             mv = m.moves.get(name)
             if mv is None:
                 return None
-            return Detail(node, name, self._move_tip(mv), label=mv.label)
+            return Detail(node, name, self._move_tip(mv), label=mv.label, play=Play(name))
         blk = m.behaviour.blocks.get(node)
         if blk is None or self._read is None:
             return None
@@ -452,6 +499,7 @@ def _ref_detail(self, m: Manifest, shown: str, block: str, move: str | None) ->
             label=mv.label,
             note_tip="A note on this move, kept in the port manifest",
             plays=Plays(block, move, tuple(m.moves)),
+            play=Play(move),
         )
 
     @staticmethod
 
@@ -402,13 +402,15 @@ def set_palette(self, groups: Sequence[PaletteGroup]) -> None:
                 act.triggered.connect(lambda _=False, k=kind: self._create(k))
 
     def select(self, ids: Sequence[str]) -> None:
-        """Selects exactly these nodes, without a `picked`."""
+        """Selects exactly these nodes and frames, without a `picked`."""
         self._busy += 1
         try:
             self.viewer.scene().clearSelection()
             for i in ids:
                 if i in self._shown:
                     self._shown[i].view.setSelected(True)
+                elif i in self._backdrops:
+                    self._backdrops[i].view.setSelected(True)
         finally:
             self._busy -= 1
         self._pick = self._picked()
@@ -418,6 +420,10 @@ def selected(self) -> list[str]:
         picked = {n.id for n in self.viewer.selected_nodes()}
         return [n.id for n in self._nodes if n.id in picked]
 
+    def frame_rects(self) -> dict[str, QRectF]:
+        """Where each frame is now, in scene units."""
+        return {i: bd.view.sceneBoundingRect() for i, bd in self._backdrops.items()}
+
     def selected_frames(self) -> list[str]:
         """The selected frames' ids, in the order of the last `show`. Clicking a frame selects
         the nodes it holds as well."""
 
@@ -21,6 +21,7 @@
     QHBoxLayout,
     QLineEdit,
     QMenu,
+    QPushButton,
     QSpinBox,
     QToolButton,
     QWidget,
@@ -195,11 +196,18 @@ class Plays:
     none: str = "nothing"
 
 
+@dataclass(frozen=True)
+class Play:
+    """A Play in game button for `move`."""
+
+    move: str
+
+
 @dataclass(frozen=True)
 class Detail:
     """What the bar shows of one node: its kind, params with their `values` and `options` (a
     combo's or a multi-select's (label, value) list, else the param's `choices`), a `plays`
-    picker and its note. A node with no params and no `note` shows only
+    picker, its note and a Play in game button. A node with no params and no `note` shows only
     its title and tip."""
 
     id: str
@@ -212,6 +220,7 @@ class Detail:
     note: bool = True
     note_tip: str = "A note on this block, kept in the port manifest"
     plays: Plays | None = None
+    play: Play | None = None
 
 
 class PropertyBar(QWidget):
@@ -221,6 +230,7 @@ class PropertyBar(QWidget):
     label_changed = Signal(str, str)
     #: the block, the move it played (None: none yet), the move it plays now (None: none)
     plays_changed = Signal(str, object, object)
+    play_requested = Signal(str)
 
     def __init__(self) -> None:
         super().__init__()
@@ -236,6 +246,7 @@ def __init__(self) -> None:
         self.controls: dict[str, ParamControl] = {}
         self.note: ParamControl | None = None
         self.plays: ParamControl | None = None
+        self.play: QPushButton | None = None
         self._owned: list[QWidget] = []
 
     def show_detail(self, d: Detail | None) -> None:
@@ -250,6 +261,7 @@ def show_detail(self, d: Detail | None) -> None:
             d.note,
             tuple((p.name, p.type) for p in d.params),
             None if d.plays is None else d.plays.moves,
+            d.play,
         )
         if shape != self._shape:
             self._clear()
@@ -289,7 +301,7 @@ def _clear(self) -> None:
         ]:
             c.deleteLater()
         self._owned, self.controls, self.note, self._shape = [], {}, None, None
-        self.plays = None
+        self.plays, self.play = None, None
 
     def _add(self, w: QWidget, stretch: int = 0) -> None:
         self._lay.addWidget(w, stretch)
@@ -318,6 +330,15 @@ def _build(self, d: Detail) -> None:
             self._add(note.ctl, 1)
         else:
             self._add(kit.label(d.tip.split("\n")[0], role="muted", wrap=False), 1)
+        if d.play is not None:
+            move = d.play.move
+            self.play = kit.button(
+                "Play",
+                tip=f"Plays {move} in the running game, as Play in game does in Moves",
+                on=lambda: self.play_requested.emit(move),
+                icon="ph.play",
+            )
+            self._add(self.play)
 
     def _build_plays(self, plays: Plays) -> None:
         self._plays = plays