dem 0.2.3

GoldSrc demo parser and writer library
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
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275

use crate::types::{TeBeamPoints, TeBspDecal, TeTextMessage, TempEntity};

use super::*;

macro_rules! wrap_ent {
    ($te:ident, $parser:ident, $input:ident, $aux:ident) => {{
        let ($input, res) = $parser::parse($input, $aux)?;
        ($input, TempEntity::$te(res))
    }};
}

mod beam_points;
mod bsp_decal;
mod text_message;

impl Doer for SvcTempEntity {
    fn id(&self) -> u8 {
        23
    }

    fn parse(i: &[u8], aux: AuxRefCell) -> Result<Self> {
        let (i, entity_type) = le_u8(i)?;

        let (i, entity) = match entity_type {
            0 => wrap_ent!(TeBeamPoints, TeBeamPoints, i, aux),
            1 => map(take(20usize), |res: &[u8]| {
                TempEntity::TeBeamEntPoint(res.to_vec())
            })(i)?,
            2 => map(take(6usize), |res: &[u8]| {
                TempEntity::TeGunshot(res.to_vec())
            })(i)?,
            // The docs say 6 but its parser says 11.
            3 => map(take(11usize), |res: &[u8]| {
                TempEntity::TeExplosion(res.to_vec())
            })(i)?,
            4 => map(take(6usize), |res: &[u8]| {
                TempEntity::TeTarExplosion(res.to_vec())
            })(i)?,
            5 => map(take(10usize), |res: &[u8]| {
                TempEntity::TeSmoke(res.to_vec())
            })(i)?,
            6 => map(take(12usize), |res: &[u8]| {
                TempEntity::TeTracer(res.to_vec())
            })(i)?,
            7 => map(take(17usize), |res: &[u8]| {
                TempEntity::TeLightning(res.to_vec())
            })(i)?,
            8 => map(take(16usize), |res: &[u8]| {
                TempEntity::TeBeamEnts(res.to_vec())
            })(i)?,
            9 => map(take(6usize), |res: &[u8]| {
                TempEntity::TeSparks(res.to_vec())
            })(i)?,
            10 => map(take(6usize), |res: &[u8]| {
                TempEntity::TeLavaSplash(res.to_vec())
            })(i)?,
            11 => map(take(6usize), |res: &[u8]| {
                TempEntity::TeTeleport(res.to_vec())
            })(i)?,
            12 => map(take(8usize), |res: &[u8]| {
                TempEntity::TeExplosion2(res.to_vec())
            })(i)?,
            13 => wrap_ent!(TeBspDecal, TeBspDecal, i, aux),
            14 => map(take(9usize), |res: &[u8]| {
                TempEntity::TeImplosion(res.to_vec())
            })(i)?,
            15 => map(take(19usize), |res: &[u8]| {
                TempEntity::TeSpriteTrail(res.to_vec())
            })(i)?,
            17 => map(take(10usize), |res: &[u8]| {
                TempEntity::TeSprite(res.to_vec())
            })(i)?,
            18 => map(take(16usize), |res: &[u8]| {
                TempEntity::TeBeamSprite(res.to_vec())
            })(i)?,
            19 => map(take(24usize), |res: &[u8]| {
                TempEntity::TeBeamTorus(res.to_vec())
            })(i)?,
            20 => map(take(24usize), |res: &[u8]| {
                TempEntity::TeBeamDisk(res.to_vec())
            })(i)?,
            21 => map(take(24usize), |res: &[u8]| {
                TempEntity::TeBeamCylinder(res.to_vec())
            })(i)?,
            22 => map(take(10usize), |res: &[u8]| {
                TempEntity::TeBeamFollow(res.to_vec())
            })(i)?,
            23 => map(take(11usize), |res: &[u8]| {
                TempEntity::TeGlowSprite(res.to_vec())
            })(i)?,
            24 => map(take(16usize), |res: &[u8]| {
                TempEntity::TeBeamRing(res.to_vec())
            })(i)?,
            25 => map(take(19usize), |res: &[u8]| {
                TempEntity::TeStreakSplash(res.to_vec())
            })(i)?,
            27 => map(take(12usize), |res: &[u8]| {
                TempEntity::TeDLight(res.to_vec())
            })(i)?,
            28 => map(take(16usize), |res: &[u8]| {
                TempEntity::TeELight(res.to_vec())
            })(i)?,
            29 => wrap_ent!(TeTextMessage, TeTextMessage, i, aux),
            30 => map(take(17usize), |res: &[u8]| TempEntity::TeLine(res.to_vec()))(i)?,
            31 => map(take(17usize), |res: &[u8]| TempEntity::TeBox(res.to_vec()))(i)?,
            99 => map(take(2usize), |res: &[u8]| {
                TempEntity::TeKillBeam(res.to_vec())
            })(i)?,
            100 => map(take(10usize), |res: &[u8]| {
                TempEntity::TeLargeFunnel(res.to_vec())
            })(i)?,
            101 => map(take(14usize), |res: &[u8]| {
                TempEntity::TeBloodStream(res.to_vec())
            })(i)?,
            102 => map(take(12usize), |res: &[u8]| {
                TempEntity::TeShowLine(res.to_vec())
            })(i)?,
            103 => map(take(14usize), |res: &[u8]| {
                TempEntity::TeBlood(res.to_vec())
            })(i)?,
            104 => map(take(9usize), |res: &[u8]| TempEntity::TeDecal(res.to_vec()))(i)?,
            105 => map(take(5usize), |res: &[u8]| TempEntity::TeFizz(res.to_vec()))(i)?,
            106 => map(take(17usize), |res: &[u8]| {
                TempEntity::TeModel(res.to_vec())
            })(i)?,
            107 => map(take(13usize), |res: &[u8]| {
                TempEntity::TeExplodeModel(res.to_vec())
            })(i)?,
            // Docs say 13 but its parser says 24.
            108 => map(take(24usize), |res: &[u8]| {
                TempEntity::TeBreakModel(res.to_vec())
            })(i)?,
            109 => map(take(9usize), |res: &[u8]| {
                TempEntity::TeGunshotDecal(res.to_vec())
            })(i)?,
            110 => map(take(17usize), |res: &[u8]| {
                TempEntity::TeSpriteSpray(res.to_vec())
            })(i)?,
            111 => map(take(7usize), |res: &[u8]| {
                TempEntity::TeArmorRicochet(res.to_vec())
            })(i)?,
            112 => map(take(10usize), |res: &[u8]| {
                TempEntity::TePlayerDecal(res.to_vec())
            })(i)?,
            113 => map(take(10usize), |res: &[u8]| {
                TempEntity::TeBubbles(res.to_vec())
            })(i)?,
            114 => map(take(19usize), |res: &[u8]| {
                TempEntity::TeBubbleTrail(res.to_vec())
            })(i)?,
            115 => map(take(12usize), |res: &[u8]| {
                TempEntity::TeBloodSprite(res.to_vec())
            })(i)?,
            116 => map(take(7usize), |res: &[u8]| {
                TempEntity::TeWorldDecal(res.to_vec())
            })(i)?,
            117 => map(take(7usize), |res: &[u8]| {
                TempEntity::TeWorldDecalHigh(res.to_vec())
            })(i)?,
            118 => map(take(9usize), |res: &[u8]| {
                TempEntity::TeDecalHigh(res.to_vec())
            })(i)?,
            119 => map(take(16usize), |res: &[u8]| {
                TempEntity::TeProjectile(res.to_vec())
            })(i)?,
            120 => map(take(18usize), |res: &[u8]| {
                TempEntity::TeSpray(res.to_vec())
            })(i)?,
            121 => map(take(5usize), |res: &[u8]| {
                TempEntity::TePlayerSprites(res.to_vec())
            })(i)?,
            122 => map(take(10usize), |res: &[u8]| {
                TempEntity::TeParticleBurst(res.to_vec())
            })(i)?,
            123 => map(take(9usize), |res: &[u8]| {
                TempEntity::TeFireField(res.to_vec())
            })(i)?,
            124 => map(take(7usize), |res: &[u8]| {
                TempEntity::TePlayerAttachment(res.to_vec())
            })(i)?,
            125 => map(take(1usize), |res: &[u8]| {
                TempEntity::TeKillPlayerAttachment(res.to_vec())
            })(i)?,
            // Docs say 10 but its parser says 18.
            126 => map(take(18usize), |res: &[u8]| {
                TempEntity::TeMultigunShot(res.to_vec())
            })(i)?,
            127 => map(take(15usize), |res: &[u8]| {
                TempEntity::TeUserTracer(res.to_vec())
            })(i)?,
            _ => context("Bad temp entity number", fail)(i)?,
        };

        Ok((
            i,
            Self {
                entity_type,
                entity,
            },
        ))
    }

    fn write(&self, aux: AuxRefCell) -> ByteVec {
        let mut writer = ByteWriter::new();

        writer.append_u8(self.id());
        writer.append_u8(self.entity_type);

        let bytes = match &self.entity {
            TempEntity::TeBeamPoints(i) => &i.write(aux),
            TempEntity::TeBeamEntPoint(i) => i,
            TempEntity::TeGunshot(i) => i,
            TempEntity::TeExplosion(i) => i,
            TempEntity::TeTarExplosion(i) => i,
            TempEntity::TeSmoke(i) => i,
            TempEntity::TeTracer(i) => i,
            TempEntity::TeLightning(i) => i,
            TempEntity::TeBeamEnts(i) => i,
            TempEntity::TeSparks(i) => i,
            TempEntity::TeLavaSplash(i) => i,
            TempEntity::TeTeleport(i) => i,
            TempEntity::TeExplosion2(i) => i,
            TempEntity::TeBspDecal(i) => &i.write(aux),
            TempEntity::TeImplosion(i) => i,
            TempEntity::TeSpriteTrail(i) => i,
            TempEntity::TeSprite(i) => i,
            TempEntity::TeBeamSprite(i) => i,
            TempEntity::TeBeamTorus(i) => i,
            TempEntity::TeBeamDisk(i) => i,
            TempEntity::TeBeamCylinder(i) => i,
            TempEntity::TeBeamFollow(i) => i,
            TempEntity::TeGlowSprite(i) => i,
            TempEntity::TeBeamRing(i) => i,
            TempEntity::TeStreakSplash(i) => i,
            TempEntity::TeDLight(i) => i,
            TempEntity::TeELight(i) => i,
            TempEntity::TeTextMessage(i) => &i.write(aux),
            TempEntity::TeLine(i) => i,
            TempEntity::TeBox(i) => i,
            TempEntity::TeKillBeam(i) => i,
            TempEntity::TeLargeFunnel(i) => i,
            TempEntity::TeBloodStream(i) => i,
            TempEntity::TeShowLine(i) => i,
            TempEntity::TeBlood(i) => i,
            TempEntity::TeDecal(i) => i,
            TempEntity::TeFizz(i) => i,
            TempEntity::TeModel(i) => i,
            TempEntity::TeExplodeModel(i) => i,
            TempEntity::TeBreakModel(i) => i,
            TempEntity::TeGunshotDecal(i) => i,
            TempEntity::TeSpriteSpray(i) => i,
            TempEntity::TeArmorRicochet(i) => i,
            TempEntity::TePlayerDecal(i) => i,
            TempEntity::TeBubbles(i) => i,
            TempEntity::TeBubbleTrail(i) => i,
            TempEntity::TeBloodSprite(i) => i,
            TempEntity::TeWorldDecal(i) => i,
            TempEntity::TeWorldDecalHigh(i) => i,
            TempEntity::TeDecalHigh(i) => i,
            TempEntity::TeProjectile(i) => i,
            TempEntity::TeSpray(i) => i,
            TempEntity::TePlayerSprites(i) => i,
            TempEntity::TeParticleBurst(i) => i,
            TempEntity::TeFireField(i) => i,
            TempEntity::TePlayerAttachment(i) => i,
            TempEntity::TeKillPlayerAttachment(i) => i,
            TempEntity::TeMultigunShot(i) => i,
            TempEntity::TeUserTracer(i) => i,
        };

        writer.append_u8_slice(bytes);

        writer.data
    }
}