https://github.com/evilkiwi/quadtree

A simple, efficient Quadtree system
https://github.com/evilkiwi/quadtree

game game-development game-server nodejs physics quadtree

Last synced: about 2 months ago
JSON representation

A simple, efficient Quadtree system

• Host: GitHub
• URL: https://github.com/evilkiwi/quadtree
• Owner: evilkiwi
• License: gpl-3.0
• Created: 2018-07-02T17:15:39.000Z (over 6 years ago)
• Default Branch: master
• Last Pushed: 2023-11-11T09:15:12.000Z (about 1 year ago)
• Last Synced: 2024-11-29T14:46:48.261Z (2 months ago)
• Topics: game, game-development, game-server, nodejs, physics, quadtree
• Language: TypeScript
• Homepage: https://evil.kiwi
• Size: 146 KB
• Stars: 5
• Watchers: 2
• Forks: 1
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • Changelog: CHANGELOG.md
  • Contributing: CONTRIBUTING.md
  • Funding: .github/FUNDING.yml
  • License: LICENSE
  • Code of conduct: CODE_OF_CONDUCT.md

Awesome Lists containing this project

README

        


  

    

  

  

    

  

  

  
Quadtree



A quadtree is a method of splitting a game world in to separate nodes in order to increase the performance of collision-based operations.

## Installation

This package is available via NPM:

```bash

yarn add @evilkiwi/quadtree

# or

npm install @evilkiwi/quadtree

```

## Usage

TODO:

## Explanation

A regular way of checking collisions in a game would be getting `ObjectA` and checking it's position against every other Object/Entity in my

game, and then doing the same for every other Object/Entity. This is minimal with a smaller amount of entities, but isn't scalable. And

whilst you _can_ optimise this somewhat, it fundamentally cannot scale. This method is called the `n^2` method, as if you have 100

Object/Entities, you'll need to do 100^2 checks to run the collision logic (10,000 checks).

The idea behind a Quadtree in Game Development is to get around this by having spacial awareness. For example, if I'm checking collisions

for `ObjectA`, I only need to check the other Entities/Objects that are around it - there's no point checking for collision against an

Entity that's on the other side of the game world. You could do something similar to this in the `n^2` method by looping over every single

Object/Entity, checking whether its position is close to `ObjectA` and only then running collision logic on it, but this is still

fundamentally unscalable as you are still doing _some_ level of logic on _every_ Object/Entity in the game world, hence the performance

bottlenecks of `n^2` still apply.

A Quadtree does this by taking Objects that you supply it (In Game Dev, these would be Entities), and then subdividing the game world in to

quads based on how many Objects are in a given area. For example, see this image:

![Example 1](https://i.imgur.com/AlY7vtN.png)

The blue lines show the quads that were generated by the quadtree after inserting the red objects (Entities).

For more information on Quadtrees and how they work, check out this video: [What are Quadtrees](https://www.youtube.com/watch?v=-OLQlDHCMgM)

## To-do

- Add a test suite