nengi - GitLite

KO | EN

gitlite — search

#react #go #golang #android #rust #deep-learning #docker #awesome #kubernetes #awesome-list #security #ios #openai #open-source

nengi

(★ 357)

a node.js + html5 network engine for real-time multiplayer games

파일 탐색기

최종 버전 다운로드 (.zip)

- - Binary.js
  - BinaryType.js
  - BitBuffer.js
  - BitStream.js
- - Bot.js
- - Chronus.js
  - Client.js
  - Interpolator.js
  - Outbound.js
  - Predictor.js
  - WorldState.js
- - consoleLogLogo.js
  - metaConfig.js
  - NoInterpsMessage.js
- - Alias.js
  - BasicSpace.js
  - Channel.js
  - Client.js
  - EntityCache.js
  - FauxCache.js
  - Historian.js
  - IdPool.js
  - Instance.js
  - LatencyRecord.js
  - NetworkReader.js
  - NetworkWriter.js
  - Sleep.js
  - SpatialChannel.js
- - CommandProtocol.js
  - compare.js
  - ComponentProtocol.js
  - copyProxy.js
  - createOptSchema.js
  - createPropSchema.js
  - deproxify.js
  - EntityProtocol.js
  - getValue.js
  - LocalEventProtocol.js
  - MessageProtocol.js
  - Protocol.js
  - ProtocolMap.js
  - proxify.js
  - selectUIntType.js
  - setValue.js
- - Chunk.js
- defaults.js
- EDictionary.js
- - jasmine.json
- bot-test.js
- channel-spec.js
- connectionMocker.js
- end-spec.js
- exp-scratch.js
- index-spec.js
- proxy-array-protocols-spec.js
- proxy-spec.js
.gitignore
.prettierignore
FUNDING.yml
index-es6.js
index.d.ts
index.js
indexBrowser.js
LICENSE.txt
package-lock.json
package.json
README.md

# 설치 가이드

1. 코드 내려받기

git clone https://github.com/timetocode/nengi

깃허브에서 프로젝트 코드 전체를 내 컴퓨터로 내려받습니다.

cd nengi

방금 내려받은 프로젝트 폴더 안으로 이동합니다.

2. Node.js

쉬움 추천

사전 준비물

Git GitHub에서 프로젝트 코드를 내려받으려면 필요합니다.
Node.js npm 명령어를 쓰려면 Node.js가 설치되어 있어야 합니다. LTS(장기지원) 버전을 추천합니다.

npm install

package.json에 명시된 라이브러리들을 내려받아 설치합니다.

npm start

개발/실행 서버를 켭니다.

✅ 명령어 실행 후 터미널에 나타나는 주소(보통 http://localhost:3000 형태)를 브라우저에서 열어보세요.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# nengi.js - multiplayer network engine <img src="https://timetocode.com/images/nengi-logo-32x32.png" />
Hello friend. Nengi.js is a networking library/engine for node.js and HTML5.

Nengi straddles two types of performance: volume and responsiveness.

With respect to volume, it is possible to make a nengi game that can support 100+ concurrent players or 50,000+ entities on a 20 tick server.
 
 Regarding responsiveness, the advanced api consists of tools that can eliminate input delay, setup lag compensated collisions, and smooth away lag. This boils down to a game with controls so responsive that it feels like single player.

Have your players saying:
>"HOW IS THIS A BROWSER GAME?!"

Join us on [nengi's Discord server](https://discord.gg/7kAa7NJ) or help support development on [timetocode's Patreon](https://www.patreon.com/timetocode)

## Currently compatible with node 14; will not work with node 15+
This is a stable branch of nengi, the very same that has a several millions of gameplays on it. It however relies on a websocket library that has no support past node 14 (cWS.js).

## Node 16 support (NEW, also may not work with node 17)
There is an experimental branch called 'sixteen' which uses uWS.js for its websocket layer. The previously used library (cWS.js) was itself a fork of an earlier version of uWS.js. The nengi api remains unchanged EXCEPT: bots don't work (yet) and the SSL syntax has changed (see uWS.js docs for new ssl syntax). There's no particular reason to think that this branch of nengi is less stable, but it is being kept separate until more users have tested it and bot support has been added (which will have to come through an addtional websocket library, likely the one simply named "ws"). If you are using this branch please share your experiences on the nengi discord server. It has been noted by the creator of uWS.js that they will only support major node versions (14, 16, 18, etc) so the same can be said for this branch of nengi.
## Features
* Authoritative Server Model (anti-cheat)
* Binary compression
* Optimized game state snapshots
* Networking culling
* An easy to use api consisting of
    * Entities - persistent objects that stay synced in real time
    * Messages - events and other instantaneous occurrences
    * Commands - input from game clients
    * Channels - compose the above into more advanced features
* Interpolation
* Compatible with PIXI.js, Babylon.js, Three.js, and much more
* Clientside prediction api
    * --> move instantly on the client
    * --> nengi will provide reconciliation data if needed
* Lag compensated shots / collisions
    * --> a player fires a shot
    * --> nengi can rewind the game state to the point in time that the shot occured given the player's latency

## Templates

Please note that these templates have not been updated recently, and while they should all work you may want to bump the nengi version to latest after checking them out.

There is a tutorial series for those learning nengi available at [https://timetocode.com/nengi/intro-1](https://timetocode.com/nengi/intro-1). The code contained in these tutorials is pretty nice -- if you're making a 2D game in nengi without csp then forking this code makes for a great template.

Other templates:

* [nice-proto](https://github.com/timetocode/nice-proto) - A prototype of a simpler API, this is nengi-2d-csp under the hood. The most mature version of this api is in the tutorial mentioned above.
* [nengi-barebone](https://github.com/timetocode/nengi-barebone) - A barebone nengi template
* [nengi-2d-basic](https://github.com/timetocode/nengi-2d-basic) - A simple 2d shooter
* [nengi-2d-csp](https://github.com/timetocode/nengi-2d-csp) - A simple 2d shooter with prediction/compensation
* [nengi-babylon-3d-shooter](https://github.com/timetocode/nengi-babylon-3d-shooter) - A template for 3D predicted games with Babylon.js
* [3d-top-down](https://github.com/timetocode/3d-top-down) - A top down game, in a 3d engine (Babylon.js)

## Usage
The [API documentation](https://timetocode.com/nengi) is the place to go for implementation details. But as an appetizer here is a tour of the the functionality associated with one of nengi's core features, the nengi.Entity

### the nengi.Entity stack
```js
// this is your own game object, it can have any properties or methods
class PlayerCharacter {
    constructor(x, y) {
        this.x = x
        this.y = y
        this.likesKittens = true
    }
    someLogic() {
        //etc
    }
}

// and this tells nengi what exactly to network about it
PlayerCharacter.protocol = {
    x: { type: nengi.Float32, interp: true },
    y: { type: nengi.Float32, interp: true }
}
```

The entity can then go on to be used in a nengi.Instance (the node.js game server)

```js
const entity = new PlayerCharacter(50, 50)
instance.addEntity(entity)
```

Any changes that occur to the entity's networked properties (in this case x & y) will automatically be detected and synchronized. The nengi.Client (the HTML5 game client) will receive the following data which encompasses any state change on any entity:

```js
const network = client.readNetwork()
network.entities.forEach(snapshot => {
    snapshot.createEntities.forEach(entity => {
        // entity { nid: 65534, ntype: 0, x: 50, y: 50, protocol: { name: 'PlayerCharacter', ... }} 
    })

snapshot.updateEntities.forEach(update => {
        // update { nid: 65534, prop: 'x', value: 63, path: ['x'] }
    })

snapshot.deleteEntities.forEach(nid => {
        // nid 65534
    })
})
```
This is everything the game client needs to keep any number of entities in sync: create, update, and delete. The data that traveled over the network was already optimized and highly compressed. The game state that comes out of client.readNetwork() is already smoothly interpolated and compatible with different frame rates (30, 60, 144, 250 etc).

This automatic synchornization of state on entities is the soul of nengi. It strikes a balance between configurability, performance, and ease of development. It also stays out of your game code. For things that are not easily represented as an entity, we have the nengi.Message, which can be used to manually network just about anything else.

The above is sufficient to network a vast variety of games where the game client sends commands to the game server and then waits on a reply from the server before the seeing the results of its commands. I refer to these as "non-predicted" games and every aspiring multiplayer programmer should make at least one before moving deeper with nengi.

That's the end of the basic path for a nengi entity, but the documentation covers the more advanced life of an entity. Summarized briefly, entities are culled, can be used for predictive movement on the game client, and have their state rewinded for advanced lag compensation.