# Map Objects The game objects of the loaded map, read straight out of the game cache: where each one stands, what it's called, what it can be clicked for, and what it looks like. Everything comes from the same cache the map itself is drawn from, so it's always in step with the game, and the objects of a region are only read once that region is part of the map. Example: ```pascal {$I WaspLib/main.simba} var booths: TObjectArray; begin Map.Setup([EChunk.VARROCK]); booths := TObjectArray.Create(Map.Walker, MapObjects.GetByAction('Bank')); end. ``` - - - ## TMapObjectData One kind of object and every place it stands on the loaded map. - `ID`, `Name`, `Category` and `Actions` come from the object's definition. `Actions` are the ones its right-click menu shows, in menu order. - `Typ` is the shape it's placed as: `10` is an ordinary object, `0` to `3` walls, `4` to `8` wall decorations and `22` ground decorations. - `Coordinates` and `Rotations` are where it stands, as {ref}`Global points`, and which way each of those copies is turned, `0` to `3`. - `Size` is its footprint in tiles and `Height` how tall it is, in the game's units: a tile is `128`. - `Colors` are the colours it is drawn in, most common first. `Height` and `Colors` come from the object's models, which are only built when the object is asked for - see {ref}`MapObjects.Build`. - - - ## TMapObjects Record holding the {ref}`TMapObjectData` of every object on the loaded map. - `Definitions` are the definitions of `Data`, in the same order, for building their models. - `Lookup` turns an object id into its place in `Data`, stored one higher so `0` means none. - `Loaded` holds the chunks already read, as `x, y` with the plane packed in with them. - - - ## MapObjects.Coordinate ```pascal function TMapObjects.Coordinate(tile: TPoint; size: TPoint; plane: Integer): TPoint; static; ``` The {ref}`Global point` an object whose south west tile is `tile`, and which covers `size` tiles once turned, is stored at. Vertically it is the middle of the object. Horizontally it is half a tile west of the middle, which is where the object data WaspLib used to download put it. It is kept that way so objects line up exactly where they always have. - - - ## MapObjects.Resolve ```pascal function TMapObjects.Resolve(constref objects: TObjectDefinitionArray; id: Integer; out def: TObjectDefinition): Boolean; static; ``` The definition object `id` is shown as, if it's one a script can interact with. Some objects change with the player's progress and are placed as a stand-in whose definition only lists what it can turn into. Those are shown as the first of their forms that has a name. Objects without a name, or that can't be interacted with, like most decorations, are left out. - - - ## MapObjects.Actions ```pascal function TMapObjects.Actions(constref def: TObjectDefinition): TStringArray; static; ``` The actions `def`'s right-click menu shows, in the order it shows them. - - - ## MapObjects.Add ```pascal procedure TMapObjects.Add(constref def: TObjectDefinition; locType, rotation: Integer; coordinate: TPoint); ``` Internal method that records one placement of `def`, adding the object if it's the first one. - - - ## MapObjects.DrawnPlane ```pascal function TMapObjects.DrawnPlane(constref region: TRegion; constref loc: TWorldLocation): Integer; static; ``` The plane `loc` is drawn on, and so the one it's seen and clicked on, which isn't always the one it's stored on. The same rule the client uses: under a bridge, what's stored on a plane is drawn on the plane below it. A tile flagged with `8` doesn't move what's on it. The flag only lets the tile be seen from the planes below it, like a rooftop seen from the street. - - - ## MapObjects.Load ```pascal procedure TMapObjects.Load(var loader: TMapLoader); procedure TMapObjects.Load(); overload; ``` Reads the objects of every chunk `loader` has loaded that hasn't been read yet. Without a loader it reads {ref}`Map`'s. The getters below call this, so it rarely needs calling directly. An object belongs to the plane it's drawn on - see {ref}`MapObjects.DrawnPlane`. - - - ## MapObjects.Build ```pascal procedure TMapObjects.Build(idx: Integer); ``` Internal method that builds the models of `Data[idx]` with {ref}`TObjectModel` to fill in its `Height` and `Colors`. Only the colours that cover most of the object make it into `Colors`: the most common ones, until `COVERAGE` of its faces are accounted for. The rest are slivers and rarely lit corners that would only widen what a colour finder looks for. - - - ## MapObjects.GetByName ```pascal function TMapObjects.GetByName(name: String; amount: Integer = 0): TMapObjectDataArray; ``` Every object called `name`. Pass `amount` to stop after that many objects. Example: ```pascal WriteLn MapObjects.GetByName('Bank booth'); ``` - - - ## MapObjects.GetByID ```pascal function TMapObjects.GetByID(id: Integer): TMapObjectData; ``` The object with the id `id`. It has no `Coordinates` if there is no such object on the map. - - - ## MapObjects.GetByAction ```pascal function TMapObjects.GetByAction(action: String; amount: Integer = 0): TMapObjectDataArray; ``` Every object with `action` in its right-click menu. Pass `amount` to stop after that many objects. Example: ```pascal WriteLn MapObjects.GetByAction('Bank'); ``` - - - ## MapObjects.GetByAllActions ```pascal function TMapObjects.GetByAllActions(actions: TStringArray; amount: Integer = 0): TMapObjectDataArray; ``` Every object with all of `actions` in its right-click menu. Pass `amount` to stop after that many objects. - - - ## MapObjects.Clear ```pascal procedure TMapObjects.Clear(); ``` Forgets every object read so far, so the next getter reads the map again from scratch. - - - ## MapObjects variable Global {ref}`TMapObjects` variable, holding the objects of {ref}`Map`.