# Overview

MovaInteract is a **Blueprint-friendly, data-driven interaction system** for Unreal
Engine 5. Add one component to any actor and set up what it does entirely from a
custom editor panel, no interaction Blueprint graph required.

## The problem it solves

Most interaction kits ask you to wire a Blueprint graph per object: an Event
Interact node, a branch on which key was pressed, a timeline to drive the door,
another for the sound, a third for the light. It works, but it does not scale: a
level with 200 interactive props means 200 graphs to maintain, and
every designer change is a recompile.

MovaInteract inverts this. An interaction is **data**: a set of named poses
(*States*), sequenced by time into *Actions*, grouped and gated into *Groups*, and
stepped by *Cycles*. You set all of it up visually, previewing live, and the
runtime executes the data, no graph, no recompile, and the same setup surface
whether you are a programmer or a designer with zero C++ experience.

## What one component gives you

Adding a {cpp:class}`UMovaIxComponent` ("the IC") to an actor turns each of its
scene components into an addressable, animatable target. A single state can, at
once:

- move / rotate / scale / hide a component,
- play a one-shot or looping **sound**,
- spawn a **Niagara** effect (burst or attached-while-active),
- apply an **impulse**, a **continuous force**, or **procedural vibration**,
- drive **light color / intensity / temperature** and **material** overrides,
- play an **AnimSequence** or **AnimMontage** on a rigged target,
- carry a **gameplay payload** (number / tag / text) for your own logic, and
- act as a **gate**: a lock or condition another interaction checks.

A plain `StaticMeshActor` can open, slide, spin, light up, play a sound, and react to
the player with zero Blueprint nodes.

## How it is triggered

Three independent trigger paths, all sharing one addressing grammar
({doc}`../concepts/tag-grammar`):

1. **Tags**: a component or actor tag like `!Open @Panel` describes a complete
   interaction: flow, verb, target(s), optional gate.
2. **Proximity**: the IC can own a Box / Sphere / tagged-Volume trigger with Enter
   / Leave tag lists, so presence alone fires an interaction (a light that turns on
   as you approach).
3. **The player Interactor**: {cpp:class}`UMovaIxInteractorComponent` on a pawn
   finds the closest interactable in view and calls `TargetInteraction()`, raising
   events your HUD listens to.

## Design principles

- **One grammar everywhere.** The same address syntax (`@`, `%`, `#`, `^`, `:`, `?`)
  is used for targets, conditions, filters and gates. Learn it once.
- **Set it up, don't code.** The [IC Control Panel](../guides/control-panel) replaces
  the stock Details panel with a purpose-built tree, a scrubbable timeline, field
  pickers and live validation.
- **Record instead of hand-writing.** Press **Rec**, move the object in the
  viewport, press **Stop**: MovaInteract generates the group, keyframes and states
  for you.
- **Multiplayer from the start.** Actions replicate out of the box. Every
  client-facing entry point routes via the player-owned Interactor, not a
  world-placed actor (see {doc}`../guides/multiplayer` for why).
- **Blueprint-first, C++-available.** Every trigger, query and event is exposed to
  Blueprint. A pure-Blueprint project can drive the whole system. C++ projects get
  the same API plus `BlueprintNativeEvent` decision hooks to override.

## Where to go next

- {doc}`installation`: add the plugin to a project.
- {doc}`quickstart`: three short recipes covering the whole system.
- {doc}`../concepts/model`: the five concepts (State → KeyFrame → Action → Group →
  Cycle) in depth.