@timohausmann/quadtree-ts
    Preparing search index...

    Class Rectangle<CustomDataType>

    Class representing a Rectangle

    const rectangle = new Rectangle({
      x: 10,
      y: 20,
      width: 30,
      height: 40,
    });

    const rectangle = new Rectangle({
      x: 10,
      y: 20,
      width: 30,
      height: 40,
      data: {
        name: 'Jane',
        health: 100,
      },
    });

    interface ObjectData {
      name: string;
      health: number;
    }
    const entity: ObjectData = {
      name: 'Jane',
      health: 100,
    };

    // Typescript will infer the type of the data property
    const rectangle1 = new Rectangle({
      x: 10,
      y: 20,
      width: 30,
      height: 40,
      data: entity,
    });

    // You can also pass in a generic type for the data property
    const rectangle2 = new Rectangle<ObjectData>({
      x: 10,
      y: 20,
      width: 30,
      height: 40,
    });
    rectangle2.data = entity;

    // extending inherits the geometry's properties and the qtIndex method
    class Box extends Rectangle {

      constructor(content, x, y, width, height) {
        super({ x, y, width, height });
        this.content = content;
      }
    }

    const box = new Box('Gravity Boots', 10, 20, 30, 40);

    // no need to extend if you don't implement RectangleGeometry
    class Box {

      constructor(content) {
        this.content = content;
        this.position = [10, 20];
        this.size = [30, 40];
      }

      // add a qtIndex method to your class
      qtIndex(node) {
        // map your properties to RectangleGeometry
        return Rectangle.prototype.qtIndex.call({
          x: this.position[0],
          y: this.position[1],
          width: this.size[0],
          height: this.size[1],
        }, node);
      }
    }

    const box = new Box('Gravity Boots');

    const player = {
      health: 100,
      x: 10,
      y: 20,
      width: 30,
      height: 30,
      qtIndex: Rectangle.prototype.qtIndex,
    });

    // Note: this is not recommended but possible.
    // Using this technique, each object would have it's own qtIndex method.
    // Rather add qtIndex to your prototype, e.g. by using classes like shown above.
    const player = {
      name: 'Jane',
      health: 100,
      position: [10, 20],
      size: [30, 40],
      qtIndex: function(node) {
        return Rectangle.prototype.qtIndex.call({
          x: this.position[0],
          y: this.position[1],
          width: this.size[0],
          height: this.size[1],
        }, node);
      },
    });

    Type Parameters

    • CustomDataType = void

      Type of the custom data property (optional, inferred automatically).

    Implements

    Index

    Constructors

    constructor

    Properties

    data? height width x y

    Methods

    qtIndex

    Constructors

    Properties

    data?: CustomDataType

    Custom data.

    height: number

    Height of the rectangle.

    width: number

    Width of the rectangle.

    x: number

    X start of the rectangle (top left).

    y: number

    Y start of the rectangle (top left).

    Methods

    • Determine which quadrant this rectangle belongs to.

      Parameters

      Returns number[]

      Array containing indexes of intersecting subnodes (0-3 = top-right, top-left, bottom-left, bottom-right)

    Settings

    Member Visibility

    On This Page

    Constructors
    Properties
    Methods