cube-engine 0.1.0

cube-pump protocol implementation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

[ProtocolWrapper]
CubePump protocol runs via WebSocket.

There are two types of signals: LowLevelSignal (LL) and PackedSignal (PK).

[PackedSignal]
PKs mainly provide non-network-critical data related to the gameplay. They are sent in packages every 50ms.

[LowLevelSignal]
There are 5 classes of LL. Four of them are described in [HandShake], [LoginAccept], [Ping] and [Disconnect].

The fifth type of LL is the Package Signal, which sends a package of PKs in this format:
	length uint32
	deflated byte[length]
where deflated is the following data encoded in zlib deflation:
	for i from 1 to size
		0x80
		signalId[i] uint16
		signalPayload[i] dynamic
	0x00

Each LL has a 1-byte ID as presented in ll-id.txt

signalId[i] is the 2-byte ID of the i-th PK as presented in pk-id.txt

[Legend]
CS = Client -> Server only
SC = Server -> Client only
MT = Signal may be sent from both sides

nop = add some bits to pad the payload to a full byte

[DataTypes]
; [u]int(8|16|32|64): big-endian encoded

struct string
	length uint16
	buffer byte[length]
struct string32
	length uint32
	buffer byte[length]

struct event_time
	time uint64 ; number of microseconds since SPAWN happens

struct int_pos
	x int32
	y int32
	z int32
struct float_pos
	x float32
	y float32
	z float32

struct cube_pos
	batch int_pos
	local_x nibble
	local_y nibble
	local_z nibble
	nop
struct cube_precise_pos
	batch int_pos
	local_x nibble
	local_y nibble
	local_z nibble
	face nibble
	precise_x float32
	precise_y float32

struct cube_model
	TODO

struct flex_pos
	batch int_pos
	local float_pos
	yaw float32
	pitch float32

[FSM]
digraph FSM
	initial -> login_requested [HandShake]
	login_requested -> loading [LoginAccept]
	login_requested -> disconnected [Disconnect]
	loading -> loading [Load]
	loading -> loading [Ping]
	loading -> spawned [Spawn]
	loading -> disconnected [Disconnect]
	spawned -> spawned [Load]
	spawned -> spawned [GamePlay]
	spawned -> spawned [Ping]
	spawned -> disconnected [Disconnect]
	spawned -> loading [WorldSwitch]

[HandShake]
CS LOGIN_REQUEST
	majorProtocol uint32 ; client.major == server.major
	minorProtocol uint32 ; client.minor >= server.minor
	username string
	userId byte[20]
	language string
	sysInfo string

[LoginAccept]
SC LOGIN_ACCEPT
	minorProtocol uint32 ; to let client determine if server supports new features

[Disconnect]
SC DISCONNECT
	reason string
	rejoin bool
	nop

CS DISCONNECT

[Ping]
MT PING
	lastCycle uint64
MT PONG

[Load]
SC CUBE_DICT
	size uint32
	for i from 1 to size
		cubeDefId[i] uint32
		cubeDefName[i] string
		if cubeDefName[i] does not start with "CubePump."
			cubeDefModel[i] cube_model

SC CUBE_BATCH
	pos int_pos
	payload uint32[4096]

[Spawn]
SC SPAWN
	pos flex_pos
	; also resets eventTime to uint64(0)

[GamePlay]
SC CUBE_UPDATE
	pos cube_pos
	new uint16

CS CUBE_INTERACT
	pos cube_precise_pos
	method uint16

SC FLEX_MOTION
	eventTime event_time
	new flex_pos
	velocity float_pos

CS USER_MOTION
	yaw float32
	dash bool
	nop

CS USER_ROTATION
	yaw float32
	pitch float32

CS USER_FLAGS
	flyUp bool
	flyDown bool
	freeFly bool
	float bool
	crouch bool
	nop

SC FLEX_FLAGS
	crouch bool