GameplayTestObjectSnapshot: {
    angle: float;
    animation?: string;
    behaviors: {
        [behaviorName: string]: {
            act: boolean;
            state: GameplayTestEvaluatedState;
        };
    };
    centerX: float;
    centerY: float;
    centerZ?: float;
    children?: {
        [objectName: string]: GameplayTestObjectSnapshot[];
    };
    depth?: float;
    flippedX?: boolean;
    flippedY?: boolean;
    height: float;
    hidden: boolean;
    id: integer;
    isLocalGeometry?: boolean;
    layer: string;
    name: string;
    opacity?: float;
    rotationX?: float;
    rotationY?: float;
    state: GameplayTestEvaluatedState;
    text?: string;
    variables: Object[];
    width: float;
    worldBounds?: GameplayTestWorldBounds;
    x: float;
    y: float;
    z?: float;
}

Type declaration

  • angle: float
  • Optional animation?: string
  • behaviors: {
        [behaviorName: string]: {
            act: boolean;
            state: GameplayTestEvaluatedState;
        };
    }
    • [behaviorName: string]: {
          act: boolean;
          state: GameplayTestEvaluatedState;
      }
      • act: boolean
      • state: GameplayTestEvaluatedState

        The behavior's conditions/expressions, evaluated: current state and configuration, under their event-sheet names (e.g. behaviors.PlatformerObject.state.IsOnFloor). Prefer these over inferring state from coordinates.

  • centerX: float
  • centerY: float
  • Optional centerZ?: float
  • Optional children?: {
        [objectName: string]: GameplayTestObjectSnapshot[];
    }

    For a custom object, the snapshots of its children - children of the default depth 1; pass childrenDepth to go deeper (max 8) and reach the children of nested custom objects.

    The positions (x, y, z, centerX, centerY, centerZ) of a descendant are in scene coordinates: they are computed with the COMPLETE transformation (pivots, rotations around X/Y/Z, scales, flips) of every custom object above it. Its worldBounds is its box in scene coordinates. The sizes and angles (width, height, depth, angle, rotationX, rotationY) stay as the child reports them in the local space of its parent (isLocalGeometry), and the layer is the one of the top custom object.

  • Optional depth?: float
  • Optional flippedX?: boolean
  • Optional flippedY?: boolean
  • height: float
  • hidden: boolean
  • id: integer
  • Optional isLocalGeometry?: boolean

    Only on the snapshot of a CHILD of a custom object: a reminder that width, height, depth, angle, rotationX and rotationY are the child's OWN values, in the local space of its parent (they are neither scaled nor rotated by it), while the positions (x, y, z, centerX, centerY, centerZ) and worldBounds are in scene coordinates.

  • layer: string
  • name: string
  • Optional opacity?: float
  • Optional rotationX?: float
  • Optional rotationY?: float
  • state: GameplayTestEvaluatedState

    The object's own conditions/expressions, evaluated (see GameplayTestEvaluatedState).

  • Optional text?: string
  • variables: Object[]
  • width: float
  • Optional worldBounds?: GameplayTestWorldBounds

    Only on the snapshot of a CHILD of a custom object: its box in SCENE coordinates (see GameplayTestWorldBounds) - the only size information of a child that accounts for its own complete transformation (rotations around X, Y and Z, flips) and for the transformations of its parents.

  • x: float
  • y: float
  • Optional z?: float