1use serde::Deserialize;
2use vbsp::deserialize_bool;
3use vbsp::{Angles, Color, LightColor, Negated, Vector};
4#[derive(Debug, Clone, Deserialize)]
5#[non_exhaustive]
6#[serde(tag = "classname")]
7pub enum Entity<'a> {
8 #[serde(rename = "ambient_generic")]
9 #[serde(borrow)]
10 AmbientGeneric(AmbientGeneric<'a>),
11 #[serde(rename = "cycler")]
12 #[serde(borrow)]
13 Cycler(Cycler<'a>),
14 #[serde(rename = "env_beam")]
15 #[serde(borrow)]
16 EnvBeam(EnvBeam<'a>),
17 #[serde(rename = "env_bubbles")]
18 #[serde(borrow)]
19 EnvBubbles(EnvBubbles<'a>),
20 #[serde(rename = "env_detail_controller")]
21 EnvDetailController(EnvDetailController),
22 #[serde(rename = "env_embers")]
23 #[serde(borrow)]
24 EnvEmbers(EnvEmbers<'a>),
25 #[serde(rename = "env_entity_maker")]
26 #[serde(borrow)]
27 EnvEntityMaker(EnvEntityMaker<'a>),
28 #[serde(rename = "env_explosion")]
29 #[serde(borrow)]
30 EnvExplosion(EnvExplosion<'a>),
31 #[serde(rename = "env_fade")]
32 #[serde(borrow)]
33 EnvFade(EnvFade<'a>),
34 #[serde(rename = "env_fire")]
35 #[serde(borrow)]
36 EnvFire(EnvFire<'a>),
37 #[serde(rename = "env_fire_trail")]
38 #[serde(borrow)]
39 EnvFireTrail(EnvFireTrail<'a>),
40 #[serde(rename = "env_firesource")]
41 EnvFiresource(EnvFiresource),
42 #[serde(rename = "env_fog_controller")]
43 #[serde(borrow)]
44 EnvFogController(EnvFogController<'a>),
45 #[serde(rename = "env_hudhint")]
46 #[serde(borrow)]
47 EnvHudhint(EnvHudhint<'a>),
48 #[serde(rename = "env_laser")]
49 #[serde(borrow)]
50 EnvLaser(EnvLaser<'a>),
51 #[serde(rename = "env_lightglow")]
52 EnvLightglow(EnvLightglow),
53 #[serde(rename = "env_physexplosion")]
54 #[serde(borrow)]
55 EnvPhysexplosion(EnvPhysexplosion<'a>),
56 #[serde(rename = "env_projectedtexture")]
57 #[serde(borrow)]
58 EnvProjectedtexture(EnvProjectedtexture<'a>),
59 #[serde(rename = "env_screenoverlay")]
60 #[serde(borrow)]
61 EnvScreenoverlay(EnvScreenoverlay<'a>),
62 #[serde(rename = "env_shake")]
63 #[serde(borrow)]
64 EnvShake(EnvShake<'a>),
65 #[serde(rename = "env_shooter")]
66 #[serde(borrow)]
67 EnvShooter(EnvShooter<'a>),
68 #[serde(rename = "env_smokestack")]
69 #[serde(borrow)]
70 EnvSmokestack(EnvSmokestack<'a>),
71 #[serde(rename = "env_soundscape")]
72 #[serde(borrow)]
73 EnvSoundscape(EnvSoundscape<'a>),
74 #[serde(rename = "env_soundscape_proxy")]
75 #[serde(borrow)]
76 EnvSoundscapeProxy(EnvSoundscapeProxy<'a>),
77 #[serde(rename = "env_soundscape_triggerable")]
78 #[serde(borrow)]
79 EnvSoundscapeTriggerable(EnvSoundscapeTriggerable<'a>),
80 #[serde(rename = "env_spark")]
81 #[serde(borrow)]
82 EnvSpark(EnvSpark<'a>),
83 #[serde(rename = "env_sprite")]
84 #[serde(borrow)]
85 EnvSprite(EnvSprite<'a>),
86 #[serde(rename = "env_spritetrail")]
87 #[serde(borrow)]
88 EnvSpritetrail(EnvSpritetrail<'a>),
89 #[serde(rename = "env_steam")]
90 #[serde(borrow)]
91 EnvSteam(EnvSteam<'a>),
92 #[serde(rename = "env_sun")]
93 #[serde(borrow)]
94 EnvSun(EnvSun<'a>),
95 #[serde(rename = "env_tonemap_controller")]
96 #[serde(borrow)]
97 EnvTonemapController(EnvTonemapController<'a>),
98 #[serde(rename = "env_wind")]
99 EnvWind(EnvWind),
100 #[serde(rename = "filter_activator_class")]
101 #[serde(borrow)]
102 FilterActivatorClass(FilterActivatorClass<'a>),
103 #[serde(rename = "filter_activator_name")]
104 #[serde(borrow)]
105 FilterActivatorName(FilterActivatorName<'a>),
106 #[serde(rename = "filter_damage_type")]
107 #[serde(borrow)]
108 FilterDamageType(FilterDamageType<'a>),
109 #[serde(rename = "filter_multi")]
110 #[serde(borrow)]
111 FilterMulti(FilterMulti<'a>),
112 #[serde(rename = "func_areaportal")]
113 #[serde(borrow)]
114 FuncAreaportal(FuncAreaportal<'a>),
115 #[serde(rename = "func_areaportalwindow")]
116 #[serde(borrow)]
117 FuncAreaportalwindow(FuncAreaportalwindow<'a>),
118 #[serde(rename = "func_bomb_target")]
119 #[serde(borrow)]
120 FuncBombTarget(FuncBombTarget<'a>),
121 #[serde(rename = "func_breakable")]
122 #[serde(borrow)]
123 FuncBreakable(FuncBreakable<'a>),
124 #[serde(rename = "func_breakable_surf")]
125 #[serde(borrow)]
126 FuncBreakableSurf(FuncBreakableSurf<'a>),
127 #[serde(rename = "func_brush")]
128 #[serde(borrow)]
129 FuncBrush(FuncBrush<'a>),
130 #[serde(rename = "func_button")]
131 #[serde(borrow)]
132 FuncButton(FuncButton<'a>),
133 #[serde(rename = "func_buyzone")]
134 #[serde(borrow)]
135 FuncBuyzone(FuncBuyzone<'a>),
136 #[serde(rename = "func_clip_vphysics")]
137 #[serde(borrow)]
138 FuncClipVphysics(FuncClipVphysics<'a>),
139 #[serde(rename = "func_conveyor")]
140 #[serde(borrow)]
141 FuncConveyor(FuncConveyor<'a>),
142 #[serde(rename = "func_door")]
143 #[serde(borrow)]
144 FuncDoor(FuncDoor<'a>),
145 #[serde(rename = "func_door_rotating")]
146 #[serde(borrow)]
147 FuncDoorRotating(FuncDoorRotating<'a>),
148 #[serde(rename = "func_dustcloud")]
149 #[serde(borrow)]
150 FuncDustcloud(FuncDustcloud<'a>),
151 #[serde(rename = "func_dustmotes")]
152 #[serde(borrow)]
153 FuncDustmotes(FuncDustmotes<'a>),
154 #[serde(rename = "func_fish_pool")]
155 #[serde(borrow)]
156 FuncFishPool(FuncFishPool<'a>),
157 #[serde(rename = "func_footstep_control")]
158 #[serde(borrow)]
159 FuncFootstepControl(FuncFootstepControl<'a>),
160 #[serde(rename = "func_hostage_rescue")]
161 #[serde(borrow)]
162 FuncHostageRescue(FuncHostageRescue<'a>),
163 #[serde(rename = "func_illusionary")]
164 #[serde(borrow)]
165 FuncIllusionary(FuncIllusionary<'a>),
166 #[serde(rename = "func_lod")]
167 #[serde(borrow)]
168 FuncLod(FuncLod<'a>),
169 #[serde(rename = "func_monitor")]
170 #[serde(borrow)]
171 FuncMonitor(FuncMonitor<'a>),
172 #[serde(rename = "func_movelinear")]
173 #[serde(borrow)]
174 FuncMovelinear(FuncMovelinear<'a>),
175 #[serde(rename = "func_occluder")]
176 #[serde(borrow)]
177 FuncOccluder(FuncOccluder<'a>),
178 #[serde(rename = "func_physbox")]
179 #[serde(borrow)]
180 FuncPhysbox(FuncPhysbox<'a>),
181 #[serde(rename = "func_physbox_multiplayer")]
182 #[serde(borrow)]
183 FuncPhysboxMultiplayer(FuncPhysboxMultiplayer<'a>),
184 #[serde(rename = "func_precipitation")]
185 #[serde(borrow)]
186 FuncPrecipitation(FuncPrecipitation<'a>),
187 #[serde(rename = "func_rot_button")]
188 #[serde(borrow)]
189 FuncRotButton(FuncRotButton<'a>),
190 #[serde(rename = "func_rotating")]
191 #[serde(borrow)]
192 FuncRotating(FuncRotating<'a>),
193 #[serde(rename = "func_smokevolume")]
194 #[serde(borrow)]
195 FuncSmokevolume(FuncSmokevolume<'a>),
196 #[serde(rename = "func_tracktrain")]
197 #[serde(borrow)]
198 FuncTracktrain(FuncTracktrain<'a>),
199 #[serde(rename = "func_train")]
200 #[serde(borrow)]
201 FuncTrain(FuncTrain<'a>),
202 #[serde(rename = "func_wall")]
203 #[serde(borrow)]
204 FuncWall(FuncWall<'a>),
205 #[serde(rename = "func_wall_toggle")]
206 #[serde(borrow)]
207 FuncWallToggle(FuncWallToggle<'a>),
208 #[serde(rename = "func_water_analog")]
209 #[serde(borrow)]
210 FuncWaterAnalog(FuncWaterAnalog<'a>),
211 #[serde(rename = "game_player_equip")]
212 #[serde(borrow)]
213 GamePlayerEquip(GamePlayerEquip<'a>),
214 #[serde(rename = "game_text")]
215 #[serde(borrow)]
216 GameText(GameText<'a>),
217 #[serde(rename = "game_ui")]
218 #[serde(borrow)]
219 GameUi(GameUi<'a>),
220 #[serde(rename = "game_weapon_manager")]
221 #[serde(borrow)]
222 GameWeaponManager(GameWeaponManager<'a>),
223 #[serde(rename = "hostage_entity")]
224 #[serde(borrow)]
225 HostageEntity(HostageEntity<'a>),
226 #[serde(rename = "info_camera_link")]
227 #[serde(borrow)]
228 InfoCameraLink(InfoCameraLink<'a>),
229 #[serde(rename = "info_ladder")]
230 InfoLadder(InfoLadder),
231 #[serde(rename = "info_lighting_relative")]
232 #[serde(borrow)]
233 InfoLightingRelative(InfoLightingRelative<'a>),
234 #[serde(rename = "info_map_parameters")]
235 InfoMapParameters(InfoMapParameters),
236 #[serde(rename = "info_node")]
237 InfoNode(InfoNode),
238 #[serde(rename = "info_node_hint")]
239 InfoNodeHint(InfoNodeHint),
240 #[serde(rename = "info_particle_system")]
241 #[serde(borrow)]
242 InfoParticleSystem(InfoParticleSystem<'a>),
243 #[serde(rename = "info_player_counterterrorist")]
244 InfoPlayerCounterterrorist(InfoPlayerCounterterrorist),
245 #[serde(rename = "info_player_logo")]
246 InfoPlayerLogo(InfoPlayerLogo),
247 #[serde(rename = "info_player_start")]
248 InfoPlayerStart(InfoPlayerStart),
249 #[serde(rename = "info_player_terrorist")]
250 InfoPlayerTerrorist(InfoPlayerTerrorist),
251 #[serde(rename = "info_target")]
252 #[serde(borrow)]
253 InfoTarget(InfoTarget<'a>),
254 #[serde(rename = "info_teleport_destination")]
255 #[serde(borrow)]
256 InfoTeleportDestination(InfoTeleportDestination<'a>),
257 #[serde(rename = "infodecal")]
258 #[serde(borrow)]
259 Infodecal(Infodecal<'a>),
260 #[serde(rename = "keyframe_rope")]
261 #[serde(borrow)]
262 KeyframeRope(KeyframeRope<'a>),
263 #[serde(rename = "light")]
264 #[serde(borrow)]
265 Light(Light<'a>),
266 #[serde(rename = "light_environment")]
267 #[serde(borrow)]
268 LightEnvironment(LightEnvironment<'a>),
269 #[serde(rename = "light_spot")]
270 #[serde(borrow)]
271 LightSpot(LightSpot<'a>),
272 #[serde(rename = "logic_auto")]
273 #[serde(borrow)]
274 LogicAuto(LogicAuto<'a>),
275 #[serde(rename = "logic_branch")]
276 #[serde(borrow)]
277 LogicBranch(LogicBranch<'a>),
278 #[serde(rename = "logic_case")]
279 #[serde(borrow)]
280 LogicCase(LogicCase<'a>),
281 #[serde(rename = "logic_compare")]
282 #[serde(borrow)]
283 LogicCompare(LogicCompare<'a>),
284 #[serde(rename = "logic_measure_movement")]
285 #[serde(borrow)]
286 LogicMeasureMovement(LogicMeasureMovement<'a>),
287 #[serde(rename = "logic_relay")]
288 #[serde(borrow)]
289 LogicRelay(LogicRelay<'a>),
290 #[serde(rename = "logic_timer")]
291 #[serde(borrow)]
292 LogicTimer(LogicTimer<'a>),
293 #[serde(rename = "math_counter")]
294 #[serde(borrow)]
295 MathCounter(MathCounter<'a>),
296 #[serde(rename = "move_rope")]
297 #[serde(borrow)]
298 MoveRope(MoveRope<'a>),
299 #[serde(rename = "path_track")]
300 #[serde(borrow)]
301 PathTrack(PathTrack<'a>),
302 #[serde(rename = "phys_ballsocket")]
303 #[serde(borrow)]
304 PhysBallsocket(PhysBallsocket<'a>),
305 #[serde(rename = "phys_constraint")]
306 #[serde(borrow)]
307 PhysConstraint(PhysConstraint<'a>),
308 #[serde(rename = "phys_constraintsystem")]
309 #[serde(borrow)]
310 PhysConstraintsystem(PhysConstraintsystem<'a>),
311 #[serde(rename = "phys_hinge")]
312 #[serde(borrow)]
313 PhysHinge(PhysHinge<'a>),
314 #[serde(rename = "phys_keepupright")]
315 #[serde(borrow)]
316 PhysKeepupright(PhysKeepupright<'a>),
317 #[serde(rename = "phys_lengthconstraint")]
318 #[serde(borrow)]
319 PhysLengthconstraint(PhysLengthconstraint<'a>),
320 #[serde(rename = "phys_pulleyconstraint")]
321 #[serde(borrow)]
322 PhysPulleyconstraint(PhysPulleyconstraint<'a>),
323 #[serde(rename = "phys_ragdollconstraint")]
324 #[serde(borrow)]
325 PhysRagdollconstraint(PhysRagdollconstraint<'a>),
326 #[serde(rename = "phys_ragdollmagnet")]
327 PhysRagdollmagnet(PhysRagdollmagnet),
328 #[serde(rename = "phys_thruster")]
329 #[serde(borrow)]
330 PhysThruster(PhysThruster<'a>),
331 #[serde(rename = "phys_torque")]
332 #[serde(borrow)]
333 PhysTorque(PhysTorque<'a>),
334 #[serde(rename = "player_speedmod")]
335 #[serde(borrow)]
336 PlayerSpeedmod(PlayerSpeedmod<'a>),
337 #[serde(rename = "player_weaponstrip")]
338 #[serde(borrow)]
339 PlayerWeaponstrip(PlayerWeaponstrip<'a>),
340 #[serde(rename = "point_camera")]
341 #[serde(borrow)]
342 PointCamera(PointCamera<'a>),
343 #[serde(rename = "point_clientcommand")]
344 #[serde(borrow)]
345 PointClientcommand(PointClientcommand<'a>),
346 #[serde(rename = "point_devshot_camera")]
347 #[serde(borrow)]
348 PointDevshotCamera(PointDevshotCamera<'a>),
349 #[serde(rename = "point_servercommand")]
350 #[serde(borrow)]
351 PointServercommand(PointServercommand<'a>),
352 #[serde(rename = "point_spotlight")]
353 #[serde(borrow)]
354 PointSpotlight(PointSpotlight<'a>),
355 #[serde(rename = "point_surroundtest")]
356 #[serde(borrow)]
357 PointSurroundtest(PointSurroundtest<'a>),
358 #[serde(rename = "point_template")]
359 #[serde(borrow)]
360 PointTemplate(PointTemplate<'a>),
361 #[serde(rename = "point_tesla")]
362 #[serde(borrow)]
363 PointTesla(PointTesla<'a>),
364 #[serde(rename = "point_viewcontrol")]
365 #[serde(borrow)]
366 PointViewcontrol(PointViewcontrol<'a>),
367 #[serde(rename = "prop_door_rotating")]
368 #[serde(borrow)]
369 PropDoorRotating(PropDoorRotating<'a>),
370 #[serde(rename = "prop_dynamic")]
371 #[serde(borrow)]
372 PropDynamic(PropDynamic<'a>),
373 #[serde(rename = "prop_dynamic_override")]
374 #[serde(borrow)]
375 PropDynamicOverride(PropDynamicOverride<'a>),
376 #[serde(rename = "prop_physics")]
377 #[serde(borrow)]
378 PropPhysics(PropPhysics<'a>),
379 #[serde(rename = "prop_physics_multiplayer")]
380 #[serde(borrow)]
381 PropPhysicsMultiplayer(PropPhysicsMultiplayer<'a>),
382 #[serde(rename = "prop_physics_override")]
383 #[serde(borrow)]
384 PropPhysicsOverride(PropPhysicsOverride<'a>),
385 #[serde(rename = "prop_ragdoll")]
386 #[serde(borrow)]
387 PropRagdoll(PropRagdoll<'a>),
388 #[serde(rename = "shadow_control")]
389 ShadowControl(ShadowControl),
390 #[serde(rename = "sky_camera")]
391 SkyCamera(SkyCamera),
392 #[serde(rename = "trigger_gravity")]
393 #[serde(borrow)]
394 TriggerGravity(TriggerGravity<'a>),
395 #[serde(rename = "trigger_hurt")]
396 #[serde(borrow)]
397 TriggerHurt(TriggerHurt<'a>),
398 #[serde(rename = "trigger_look")]
399 #[serde(borrow)]
400 TriggerLook(TriggerLook<'a>),
401 #[serde(rename = "trigger_multiple")]
402 #[serde(borrow)]
403 TriggerMultiple(TriggerMultiple<'a>),
404 #[serde(rename = "trigger_once")]
405 #[serde(borrow)]
406 TriggerOnce(TriggerOnce<'a>),
407 #[serde(rename = "trigger_proximity")]
408 #[serde(borrow)]
409 TriggerProximity(TriggerProximity<'a>),
410 #[serde(rename = "trigger_push")]
411 #[serde(borrow)]
412 TriggerPush(TriggerPush<'a>),
413 #[serde(rename = "trigger_soundscape")]
414 #[serde(borrow)]
415 TriggerSoundscape(TriggerSoundscape<'a>),
416 #[serde(rename = "trigger_teleport")]
417 #[serde(borrow)]
418 TriggerTeleport(TriggerTeleport<'a>),
419 #[serde(rename = "trigger_vphysics_motion")]
420 #[serde(borrow)]
421 TriggerVphysicsMotion(TriggerVphysicsMotion<'a>),
422 #[serde(rename = "trigger_wind")]
423 #[serde(borrow)]
424 TriggerWind(TriggerWind<'a>),
425 #[serde(rename = "water_lod_control")]
426 #[serde(borrow)]
427 WaterLodControl(WaterLodControl<'a>),
428 #[serde(rename = "weapon_ak47")]
429 #[serde(borrow)]
430 WeaponAk47(WeaponAk47<'a>),
431 #[serde(rename = "weapon_awp")]
432 #[serde(borrow)]
433 WeaponAwp(WeaponAwp<'a>),
434 #[serde(rename = "weapon_deagle")]
435 #[serde(borrow)]
436 WeaponDeagle(WeaponDeagle<'a>),
437 #[serde(rename = "weapon_elite")]
438 #[serde(borrow)]
439 WeaponElite(WeaponElite<'a>),
440 #[serde(rename = "weapon_famas")]
441 WeaponFamas(WeaponFamas),
442 #[serde(rename = "weapon_fiveseven")]
443 #[serde(borrow)]
444 WeaponFiveseven(WeaponFiveseven<'a>),
445 #[serde(rename = "weapon_flashbang")]
446 #[serde(borrow)]
447 WeaponFlashbang(WeaponFlashbang<'a>),
448 #[serde(rename = "weapon_g3sg1")]
449 WeaponG3sg1(WeaponG3sg1),
450 #[serde(rename = "weapon_glock")]
451 #[serde(borrow)]
452 WeaponGlock(WeaponGlock<'a>),
453 #[serde(rename = "weapon_hegrenade")]
454 #[serde(borrow)]
455 WeaponHegrenade(WeaponHegrenade<'a>),
456 #[serde(rename = "weapon_knife")]
457 #[serde(borrow)]
458 WeaponKnife(WeaponKnife<'a>),
459 #[serde(rename = "weapon_m249")]
460 #[serde(borrow)]
461 WeaponM249(WeaponM249<'a>),
462 #[serde(rename = "weapon_m3")]
463 #[serde(borrow)]
464 WeaponM3(WeaponM3<'a>),
465 #[serde(rename = "weapon_m4a1")]
466 #[serde(borrow)]
467 WeaponM4a1(WeaponM4a1<'a>),
468 #[serde(rename = "weapon_mac10")]
469 WeaponMac10(WeaponMac10),
470 #[serde(rename = "weapon_p228")]
471 #[serde(borrow)]
472 WeaponP228(WeaponP228<'a>),
473 #[serde(rename = "weapon_p90")]
474 #[serde(borrow)]
475 WeaponP90(WeaponP90<'a>),
476 #[serde(rename = "weapon_scout")]
477 #[serde(borrow)]
478 WeaponScout(WeaponScout<'a>),
479 #[serde(rename = "weapon_sg550")]
480 WeaponSg550(WeaponSg550),
481 #[serde(rename = "weapon_smokegrenade")]
482 #[serde(borrow)]
483 WeaponSmokegrenade(WeaponSmokegrenade<'a>),
484 #[serde(rename = "weapon_tmp")]
485 WeaponTmp(WeaponTmp),
486 #[serde(rename = "weapon_ump45")]
487 #[serde(borrow)]
488 WeaponUmp45(WeaponUmp45<'a>),
489 #[serde(rename = "weapon_usp")]
490 #[serde(borrow)]
491 WeaponUsp(WeaponUsp<'a>),
492 #[serde(rename = "weapon_xm1014")]
493 #[serde(borrow)]
494 WeaponXm1014(WeaponXm1014<'a>),
495 #[serde(rename = "worldspawn")]
496 #[serde(borrow)]
497 Worldspawn(Worldspawn<'a>),
498}
499#[derive(Debug, Clone, Deserialize)]
500pub struct AmbientGeneric<'a> {
501 #[serde(deserialize_with = "deserialize_bool")]
502 #[serde(default)]
503 pub cspinup: bool,
504 #[serde(deserialize_with = "deserialize_bool")]
505 #[serde(default)]
506 pub fadein: bool,
507 #[serde(deserialize_with = "deserialize_bool")]
508 #[serde(default)]
509 pub fadeinsecs: bool,
510 #[serde(deserialize_with = "deserialize_bool")]
511 #[serde(default)]
512 pub fadeout: bool,
513 #[serde(deserialize_with = "deserialize_bool")]
514 #[serde(default)]
515 pub fadeoutsecs: bool,
516 pub health: u8,
517 #[serde(deserialize_with = "deserialize_bool")]
518 #[serde(default)]
519 pub lfomodpitch: bool,
520 #[serde(deserialize_with = "deserialize_bool")]
521 #[serde(default)]
522 pub lfomodvol: bool,
523 #[serde(deserialize_with = "deserialize_bool")]
524 #[serde(default)]
525 pub lforate: bool,
526 #[serde(deserialize_with = "deserialize_bool")]
527 #[serde(default)]
528 pub lfotype: bool,
529 pub message: &'a str,
530 #[serde(deserialize_with = "deserialize_bool")]
531 #[serde(default)]
532 pub no_decomp: bool,
533 pub origin: Vector,
534 pub pitch: u8,
535 pub pitchstart: u8,
536 #[serde(deserialize_with = "deserialize_bool")]
537 #[serde(default)]
538 pub preset: bool,
539 pub radius: f32,
540 #[serde(default)]
541 pub sourceentityname: Option<&'a str>,
542 pub spawnflags: u32,
543 #[serde(deserialize_with = "deserialize_bool")]
544 #[serde(default)]
545 pub spindown: bool,
546 #[serde(deserialize_with = "deserialize_bool")]
547 #[serde(default)]
548 pub spinup: bool,
549 #[serde(default)]
550 pub targetname: Option<&'a str>,
551 #[serde(default)]
552 pub volstart: Option<u8>,
553}
554#[derive(Debug, Clone, Deserialize)]
555pub struct Cycler<'a> {
556 pub angles: Angles,
557 #[serde(deserialize_with = "deserialize_bool")]
558 #[serde(default)]
559 pub disablereceiveshadows: bool,
560 #[serde(deserialize_with = "deserialize_bool")]
561 #[serde(default)]
562 pub disableshadows: bool,
563 pub model: &'a str,
564 pub origin: Vector,
565 pub renderamt: u8,
566 pub rendercolor: Color,
567 #[serde(deserialize_with = "deserialize_bool")]
568 #[serde(default)]
569 pub sequence: bool,
570 #[serde(deserialize_with = "deserialize_bool")]
571 #[serde(default)]
572 pub skin: bool,
573 pub spawnflags: u32,
574 #[serde(default)]
575 pub targetname: Option<&'a str>,
576}
577#[derive(Debug, Clone, Deserialize)]
578pub struct EnvBeam<'a> {
579 pub boltwidth: f32,
580 #[serde(default)]
581 pub damage: Option<f32>,
582 #[serde(default)]
583 pub decalname: Option<&'a str>,
584 #[serde(default)]
585 pub framerate: Option<u8>,
586 #[serde(deserialize_with = "deserialize_bool")]
587 #[serde(default)]
588 pub framestart: bool,
589 #[serde(default)]
590 pub hdrcolorscale: Option<f32>,
591 pub life: f32,
592 pub lightningend: &'a str,
593 pub lightningstart: &'a str,
594 #[serde(default)]
595 pub noiseamplitude: Option<&'a str>,
596 pub origin: Vector,
597 #[serde(default)]
598 pub parentname: Option<&'a str>,
599 pub radius: f32,
600 pub renderamt: u8,
601 pub rendercolor: Color,
602 #[serde(deserialize_with = "deserialize_bool")]
603 #[serde(default)]
604 pub renderfx: bool,
605 pub spawnflags: u32,
606 pub striketime: f32,
607 #[serde(default)]
608 pub targetname: Option<&'a str>,
609 pub texture: &'a str,
610 pub texturescroll: u8,
611 #[serde(deserialize_with = "deserialize_bool")]
612 #[serde(default)]
613 pub touchtype: bool,
614}
615#[derive(Debug, Clone, Deserialize)]
616pub struct EnvBubbles<'a> {
617 #[serde(deserialize_with = "deserialize_bool")]
618 pub current: bool,
619 pub density: u8,
620 pub frequency: u8,
621 pub model: &'a str,
622 pub spawnflags: u32,
623}
624#[derive(Debug, Clone, Deserialize)]
625pub struct EnvDetailController {
626 pub angles: Angles,
627 pub fademaxdist: u16,
628 pub fademindist: u16,
629 pub origin: Vector,
630}
631#[derive(Debug, Clone, Deserialize)]
632pub struct EnvEmbers<'a> {
633 pub angles: Angles,
634 pub density: u16,
635 pub lifetime: u8,
636 pub model: &'a str,
637 #[serde(deserialize_with = "deserialize_bool")]
638 #[serde(default)]
639 pub particletype: bool,
640 pub rendercolor: Color,
641 #[serde(default)]
642 pub spawnflags: Option<u32>,
643 pub speed: f32,
644 #[serde(default)]
645 pub targetname: Option<&'a str>,
646}
647#[derive(Debug, Clone, Deserialize)]
648pub struct EnvEntityMaker<'a> {
649 pub angles: Angles,
650 pub entitytemplate: &'a str,
651 pub onentityspawned: &'a str,
652 pub origin: Vector,
653 pub postspawndirection: Vector,
654 pub postspawndirectionvariance: f32,
655 #[serde(deserialize_with = "deserialize_bool")]
656 #[serde(default)]
657 pub postspawninheritangles: bool,
658 #[serde(deserialize_with = "deserialize_bool")]
659 #[serde(default)]
660 pub postspawnspeed: bool,
661 pub spawnflags: u32,
662 pub targetname: &'a str,
663}
664#[derive(Debug, Clone, Deserialize)]
665pub struct EnvExplosion<'a> {
666 pub fireballsprite: &'a str,
667 pub imagnitude: u16,
668 #[serde(default)]
669 pub iradiusoverride: Option<u16>,
670 pub origin: Vector,
671 #[serde(default)]
672 pub parentname: Option<&'a str>,
673 pub rendermode: u8,
674 #[serde(default)]
675 pub spawnflags: Option<u32>,
676 pub targetname: &'a str,
677}
678#[derive(Debug, Clone, Deserialize)]
679pub struct EnvFade<'a> {
680 pub duration: f32,
681 pub holdtime: f32,
682 pub origin: Vector,
683 pub renderamt: u8,
684 pub rendercolor: Color,
685 pub spawnflags: u32,
686 pub targetname: &'a str,
687}
688#[derive(Debug, Clone, Deserialize)]
689pub struct EnvFire<'a> {
690 pub damagescale: f32,
691 pub fireattack: u8,
692 #[serde(default)]
693 pub firedecay: Option<u8>,
694 pub firesize: u16,
695 #[serde(deserialize_with = "deserialize_bool")]
696 #[serde(default)]
697 pub firetype: bool,
698 pub health: u16,
699 pub ignitionpoint: u8,
700 pub origin: Vector,
701 pub spawnflags: u32,
702 #[serde(deserialize_with = "deserialize_bool")]
703 #[serde(default)]
704 pub startdisabled: bool,
705 #[serde(default)]
706 pub targetname: Option<&'a str>,
707}
708#[derive(Debug, Clone, Deserialize)]
709pub struct EnvFireTrail<'a> {
710 pub origin: Vector,
711 pub parentname: &'a str,
712 pub targetname: &'a str,
713}
714#[derive(Debug, Clone, Deserialize)]
715pub struct EnvFiresource {
716 pub firedamage: u8,
717 pub fireradius: u8,
718 pub origin: Vector,
719 pub spawnflags: u32,
720}
721#[derive(Debug, Clone, Deserialize)]
722pub struct EnvFogController<'a> {
723 pub angles: Angles,
724 pub farz: f32,
725 #[serde(deserialize_with = "deserialize_bool")]
726 #[serde(default)]
727 pub fogblend: bool,
728 pub fogcolor: Color,
729 pub fogcolor2: Color,
730 pub fogdir: Vector,
731 #[serde(deserialize_with = "deserialize_bool")]
732 pub fogenable: bool,
733 pub fogend: f32,
734 #[serde(default)]
735 pub foglerptime: Option<f32>,
736 #[serde(default)]
737 pub fogmaxdensity: Option<f32>,
738 pub fogstart: f32,
739 #[serde(deserialize_with = "deserialize_bool")]
740 #[serde(default)]
741 pub maxdxlevel: bool,
742 #[serde(deserialize_with = "deserialize_bool")]
743 #[serde(default)]
744 pub mindxlevel: bool,
745 pub origin: Vector,
746 #[serde(default)]
747 pub spawnflags: Option<u32>,
748 #[serde(default)]
749 pub targetname: Option<&'a str>,
750 #[serde(deserialize_with = "deserialize_bool")]
751 #[serde(default)]
752 pub use_angles: bool,
753}
754#[derive(Debug, Clone, Deserialize)]
755pub struct EnvHudhint<'a> {
756 pub message: &'a str,
757 pub origin: Vector,
758 #[serde(default)]
759 pub spawnflags: Option<u32>,
760 pub targetname: &'a str,
761}
762#[derive(Debug, Clone, Deserialize)]
763pub struct EnvLaser<'a> {
764 #[serde(default)]
765 pub angles: Option<Angles>,
766 #[serde(deserialize_with = "deserialize_bool")]
767 #[serde(default)]
768 pub current: bool,
769 pub damage: f32,
770 #[serde(default)]
771 pub density: Option<u8>,
772 pub dissolvetype: &'a str,
773 #[serde(default)]
774 pub frequency: Option<u8>,
775 #[serde(default)]
776 pub hdrcolorscale: Option<f32>,
777 #[serde(default)]
778 pub lasertarget: Option<&'a str>,
779 #[serde(default)]
780 pub noiseamplitude: Option<f32>,
781 pub origin: Vector,
782 #[serde(default)]
783 pub parentname: Option<&'a str>,
784 pub renderamt: u8,
785 pub rendercolor: Color,
786 #[serde(default)]
787 pub spawnflags: Option<u32>,
788 #[serde(default)]
789 pub targetname: Option<&'a str>,
790 pub texture: &'a str,
791 pub texturescroll: u8,
792 pub width: f32,
793}
794#[derive(Debug, Clone, Deserialize)]
795pub struct EnvLightglow {
796 pub angles: Angles,
797 pub glowproxysize: f32,
798 #[serde(default)]
799 pub hdrcolorscale: Option<f32>,
800 pub horizontalglowsize: u16,
801 pub maxdist: u16,
802 pub mindist: u16,
803 pub origin: Vector,
804 #[serde(default)]
805 pub outermaxdist: Option<u16>,
806 pub rendercolor: Color,
807 #[serde(default)]
808 pub spawnflags: Option<u32>,
809 pub verticalglowsize: u16,
810}
811#[derive(Debug, Clone, Deserialize)]
812pub struct EnvPhysexplosion<'a> {
813 pub magnitude: u16,
814 pub origin: Vector,
815 pub radius: u16,
816 pub spawnflags: u32,
817 pub targetentityname: &'a str,
818 pub targetname: &'a str,
819}
820#[derive(Debug, Clone, Deserialize)]
821pub struct EnvProjectedtexture<'a> {
822 pub angles: Angles,
823 #[serde(deserialize_with = "deserialize_bool")]
824 pub cameraspace: bool,
825 #[serde(deserialize_with = "deserialize_bool")]
826 pub enableshadows: bool,
827 pub farz: u16,
828 pub lightcolor: LightColor,
829 pub lightfov: f32,
830 #[serde(deserialize_with = "deserialize_bool")]
831 pub lightonlytarget: bool,
832 #[serde(deserialize_with = "deserialize_bool")]
833 pub lightworld: bool,
834 pub nearz: f32,
835 pub origin: Vector,
836 #[serde(default)]
837 pub parentname: Option<&'a str>,
838 #[serde(deserialize_with = "deserialize_bool")]
839 pub shadowquality: bool,
840 pub spawnflags: u32,
841 pub targetname: &'a str,
842}
843#[derive(Debug, Clone, Deserialize)]
844pub struct EnvScreenoverlay<'a> {
845 pub origin: Vector,
846 pub overlayname1: &'a str,
847 pub overlaytime1: f32,
848 pub overlaytime10: f32,
849 pub overlaytime2: f32,
850 pub overlaytime3: f32,
851 pub overlaytime4: f32,
852 pub overlaytime5: f32,
853 pub overlaytime6: f32,
854 pub overlaytime7: f32,
855 pub overlaytime8: f32,
856 pub overlaytime9: f32,
857 pub targetname: &'a str,
858}
859#[derive(Debug, Clone, Deserialize)]
860pub struct EnvShake<'a> {
861 pub amplitude: u8,
862 pub duration: f32,
863 pub frequency: f32,
864 pub origin: Vector,
865 pub radius: u16,
866 pub spawnflags: u32,
867 pub targetname: &'a str,
868}
869#[derive(Debug, Clone, Deserialize)]
870pub struct EnvShooter<'a> {
871 pub angles: Angles,
872 pub delay: f32,
873 #[serde(deserialize_with = "deserialize_bool")]
874 pub disablereceiveshadows: bool,
875 #[serde(deserialize_with = "deserialize_bool")]
876 #[serde(default)]
877 pub disableshadows: bool,
878 pub gibangles: Angles,
879 #[serde(deserialize_with = "deserialize_bool")]
880 #[serde(default)]
881 pub gibanglevelocity: bool,
882 #[serde(deserialize_with = "deserialize_bool")]
883 pub gibgravityscale: bool,
884 pub m_flgiblife: f32,
885 pub m_flvariance: f32,
886 pub m_flvelocity: u16,
887 pub m_igibs: u32,
888 #[serde(default)]
889 pub massoverride: Option<f32>,
890 #[serde(deserialize_with = "deserialize_bool")]
891 #[serde(default)]
892 pub nogibshadows: bool,
893 pub origin: Vector,
894 #[serde(default)]
895 pub parentname: Option<&'a str>,
896 pub renderamt: u8,
897 pub rendercolor: Color,
898 #[serde(deserialize_with = "deserialize_bool")]
899 pub renderfx: bool,
900 #[serde(deserialize_with = "deserialize_bool")]
901 pub rendermode: bool,
902 #[serde(default)]
903 pub shootmodel: Option<&'a str>,
904 pub shootsounds: i32,
905 #[serde(deserialize_with = "deserialize_bool")]
906 pub simulation: bool,
907 #[serde(deserialize_with = "deserialize_bool")]
908 pub skin: bool,
909 pub spawnflags: u32,
910 pub targetname: &'a str,
911}
912#[derive(Debug, Clone, Deserialize)]
913pub struct EnvSmokestack<'a> {
914 pub angles: Angles,
915 pub basespread: u8,
916 pub endsize: u8,
917 #[serde(deserialize_with = "deserialize_bool")]
918 #[serde(default)]
919 pub initialstate: bool,
920 pub jetlength: u8,
921 pub origin: Vector,
922 #[serde(default)]
923 pub parentname: Option<&'a str>,
924 pub rate: u8,
925 pub renderamt: u8,
926 pub rendercolor: Color,
927 #[serde(default)]
928 pub roll: Option<f32>,
929 pub smokematerial: &'a str,
930 pub speed: u8,
931 pub spreadspeed: u8,
932 pub startsize: u8,
933 #[serde(default)]
934 pub targetname: Option<&'a str>,
935 #[serde(default)]
936 pub twist: Option<u8>,
937 #[serde(default)]
938 pub windangle: Option<u8>,
939 #[serde(default)]
940 pub windspeed: Option<u8>,
941}
942#[derive(Debug, Clone, Deserialize)]
943pub struct EnvSoundscape<'a> {
944 pub origin: Vector,
945 #[serde(default)]
946 pub position0: Option<&'a str>,
947 #[serde(default)]
948 pub position1: Option<&'a str>,
949 #[serde(default)]
950 pub position2: Option<&'a str>,
951 #[serde(default)]
952 pub position3: Option<&'a str>,
953 #[serde(default)]
954 pub position4: Option<&'a str>,
955 #[serde(default)]
956 pub position5: Option<&'a str>,
957 #[serde(default)]
958 pub position6: Option<&'a str>,
959 #[serde(default)]
960 pub position7: Option<&'a str>,
961 pub radius: f32,
962 pub soundscape: &'a str,
963 #[serde(deserialize_with = "deserialize_bool")]
964 #[serde(default)]
965 pub startdisabled: bool,
966 #[serde(default)]
967 pub targetname: Option<&'a str>,
968}
969#[derive(Debug, Clone, Deserialize)]
970pub struct EnvSoundscapeProxy<'a> {
971 pub mainsoundscapename: &'a str,
972 pub origin: Vector,
973 pub radius: i32,
974}
975#[derive(Debug, Clone, Deserialize)]
976pub struct EnvSoundscapeTriggerable<'a> {
977 pub origin: Vector,
978 #[serde(default)]
979 pub position0: Option<&'a str>,
980 #[serde(default)]
981 pub position1: Option<&'a str>,
982 #[serde(default)]
983 pub position2: Option<&'a str>,
984 #[serde(default)]
985 pub position3: Option<&'a str>,
986 #[serde(default)]
987 pub position4: Option<&'a str>,
988 #[serde(default)]
989 pub position5: Option<&'a str>,
990 #[serde(default)]
991 pub position6: Option<&'a str>,
992 #[serde(default)]
993 pub position7: Option<&'a str>,
994 pub radius: u16,
995 pub soundscape: &'a str,
996 #[serde(deserialize_with = "deserialize_bool")]
997 #[serde(default)]
998 pub startdisabled: bool,
999 pub targetname: &'a str,
1000}
1001#[derive(Debug, Clone, Deserialize)]
1002pub struct EnvSpark<'a> {
1003 pub angles: Angles,
1004 pub magnitude: u8,
1005 #[serde(default)]
1006 pub maxdelay: Option<f32>,
1007 pub origin: Vector,
1008 #[serde(default)]
1009 pub parentname: Option<&'a str>,
1010 pub spawnflags: u32,
1011 #[serde(default)]
1012 pub targetname: Option<&'a str>,
1013 pub traillength: u8,
1014}
1015#[derive(Debug, Clone, Deserialize)]
1016pub struct EnvSprite<'a> {
1017 #[serde(default)]
1018 pub _minlight: Option<f32>,
1019 #[serde(default)]
1020 pub angles: Option<Angles>,
1021 #[serde(deserialize_with = "deserialize_bool")]
1022 #[serde(default)]
1023 pub disablereceiveshadows: bool,
1024 #[serde(deserialize_with = "deserialize_bool")]
1025 #[serde(default)]
1026 pub disableshadows: bool,
1027 pub framerate: f32,
1028 pub glowproxysize: f32,
1029 #[serde(default)]
1030 pub hdrcolorscale: Option<f32>,
1031 #[serde(deserialize_with = "deserialize_bool")]
1032 #[serde(default)]
1033 pub maxdxlevel: bool,
1034 #[serde(default)]
1035 pub mindxlevel: Option<u8>,
1036 pub model: &'a str,
1037 pub origin: Vector,
1038 #[serde(default)]
1039 pub parentname: Option<&'a str>,
1040 pub renderamt: u8,
1041 pub rendercolor: Color,
1042 #[serde(default)]
1043 pub renderfx: Option<u8>,
1044 #[serde(default)]
1045 pub rendermode: Option<u8>,
1046 #[serde(default)]
1047 pub scale: Option<f32>,
1048 #[serde(default)]
1049 pub spawnflags: Option<u32>,
1050 #[serde(default)]
1051 pub targetname: Option<&'a str>,
1052}
1053#[derive(Debug, Clone, Deserialize)]
1054pub struct EnvSpritetrail<'a> {
1055 #[serde(deserialize_with = "deserialize_bool")]
1056 #[serde(default)]
1057 pub disablereceiveshadows: bool,
1058 #[serde(deserialize_with = "deserialize_bool")]
1059 #[serde(default)]
1060 pub disableshadows: bool,
1061 pub endwidth: f32,
1062 pub lifetime: f32,
1063 #[serde(deserialize_with = "deserialize_bool")]
1064 #[serde(default)]
1065 pub maxdxlevel: bool,
1066 #[serde(deserialize_with = "deserialize_bool")]
1067 #[serde(default)]
1068 pub mindxlevel: bool,
1069 pub origin: Vector,
1070 #[serde(default)]
1071 pub parentname: Option<&'a str>,
1072 pub renderamt: u8,
1073 pub rendercolor: Color,
1074 pub rendermode: u8,
1075 pub spritename: &'a str,
1076 pub startwidth: f32,
1077 #[serde(default)]
1078 pub targetname: Option<&'a str>,
1079}
1080#[derive(Debug, Clone, Deserialize)]
1081pub struct EnvSteam<'a> {
1082 pub angles: Angles,
1083 pub endsize: u8,
1084 #[serde(deserialize_with = "deserialize_bool")]
1085 #[serde(default)]
1086 pub initialstate: bool,
1087 pub jetlength: u16,
1088 pub origin: Vector,
1089 #[serde(default)]
1090 pub parentname: Option<&'a str>,
1091 #[serde(deserialize_with = "deserialize_bool")]
1092 #[serde(default)]
1093 pub r#type: bool,
1094 pub rate: u8,
1095 pub renderamt: u8,
1096 pub rendercolor: Color,
1097 #[serde(default)]
1098 pub rollspeed: Option<u8>,
1099 #[serde(default)]
1100 pub spawnflags: Option<u32>,
1101 pub speed: u8,
1102 pub spreadspeed: u8,
1103 pub startsize: u8,
1104 #[serde(default)]
1105 pub targetname: Option<&'a str>,
1106}
1107#[derive(Debug, Clone, Deserialize)]
1108pub struct EnvSun<'a> {
1109 pub angles: &'a str,
1110 #[serde(default)]
1111 pub hdrcolorscale: Option<f32>,
1112 #[serde(default)]
1113 pub horzsize0: Option<u8>,
1114 #[serde(default)]
1115 pub horzsize1: Option<u8>,
1116 #[serde(default)]
1117 pub horzsize2: Option<u8>,
1118 #[serde(default)]
1119 pub horzsize3: Option<u8>,
1120 #[serde(default)]
1121 pub material: Option<&'a str>,
1122 #[serde(default)]
1123 pub material0: Option<&'a str>,
1124 #[serde(default)]
1125 pub material1: Option<&'a str>,
1126 #[serde(default)]
1127 pub material2: Option<&'a str>,
1128 #[serde(default)]
1129 pub material3: Option<&'a str>,
1130 #[serde(default)]
1131 pub numlayers: Option<u8>,
1132 pub origin: Vector,
1133 #[serde(default)]
1134 pub overlaycolor: Option<&'a str>,
1135 #[serde(default)]
1136 pub overlaymaterial: Option<&'a str>,
1137 #[serde(default)]
1138 pub overlaysize: Option<i32>,
1139 #[serde(default)]
1140 pub pitch: Option<i32>,
1141 pub rendercolor: &'a str,
1142 pub size: u8,
1143 #[serde(default)]
1144 pub target: Option<&'a str>,
1145 #[serde(deserialize_with = "deserialize_bool")]
1146 #[serde(default)]
1147 pub use_angles: bool,
1148 #[serde(default)]
1149 pub vertsize0: Option<u8>,
1150 #[serde(default)]
1151 pub vertsize1: Option<u8>,
1152 #[serde(default)]
1153 pub vertsize2: Option<u8>,
1154 #[serde(default)]
1155 pub vertsize3: Option<u8>,
1156}
1157#[derive(Debug, Clone, Deserialize)]
1158pub struct EnvTonemapController<'a> {
1159 pub origin: Vector,
1160 #[serde(default)]
1161 pub targetname: Option<&'a str>,
1162}
1163#[derive(Debug, Clone, Deserialize)]
1164pub struct EnvWind {
1165 #[serde(default)]
1166 pub angles: Option<Angles>,
1167 pub gustdirchange: u8,
1168 #[serde(default)]
1169 pub gustduration: Option<u8>,
1170 pub maxgust: u8,
1171 pub maxgustdelay: u8,
1172 pub maxwind: u8,
1173 pub mingust: u8,
1174 pub mingustdelay: u8,
1175 pub minwind: u8,
1176 pub origin: Vector,
1177}
1178#[derive(Debug, Clone, Deserialize)]
1179pub struct FilterActivatorClass<'a> {
1180 pub filterclass: &'a str,
1181 pub negated: Negated,
1182 pub origin: Vector,
1183 pub targetname: &'a str,
1184}
1185#[derive(Debug, Clone, Deserialize)]
1186pub struct FilterActivatorName<'a> {
1187 #[serde(default)]
1188 pub filtername: Option<&'a str>,
1189 pub negated: Negated,
1190 #[serde(default)]
1191 pub onfail: Option<&'a str>,
1192 #[serde(default)]
1193 pub onpass: Option<&'a str>,
1194 pub origin: Vector,
1195 pub targetname: &'a str,
1196}
1197#[derive(Debug, Clone, Deserialize)]
1198pub struct FilterDamageType<'a> {
1199 pub damagetype: u8,
1200 pub negated: Negated,
1201 pub origin: Vector,
1202 #[serde(default)]
1203 pub targetname: Option<&'a str>,
1204}
1205#[derive(Debug, Clone, Deserialize)]
1206pub struct FilterMulti<'a> {
1207 pub filter01: &'a str,
1208 #[serde(default)]
1209 pub filter02: Option<&'a str>,
1210 #[serde(default)]
1211 pub filter03: Option<&'a str>,
1212 #[serde(default)]
1213 pub filter04: Option<&'a str>,
1214 #[serde(default)]
1215 pub filter05: Option<&'a str>,
1216 #[serde(deserialize_with = "deserialize_bool")]
1217 pub filtertype: bool,
1218 #[serde(deserialize_with = "deserialize_bool")]
1219 pub negated: bool,
1220 pub origin: Vector,
1221 pub targetname: &'a str,
1222}
1223#[derive(Debug, Clone, Deserialize)]
1224pub struct FuncAreaportal<'a> {
1225 pub portalnumber: u8,
1226 #[serde(deserialize_with = "deserialize_bool")]
1227 #[serde(default)]
1228 pub portalversion: bool,
1229 #[serde(deserialize_with = "deserialize_bool")]
1230 pub startopen: bool,
1231 #[serde(default)]
1232 pub target: Option<&'a str>,
1233 #[serde(default)]
1234 pub targetname: Option<&'a str>,
1235}
1236#[derive(Debug, Clone, Deserialize)]
1237pub struct FuncAreaportalwindow<'a> {
1238 pub fadedist: u16,
1239 pub fadestartdist: u16,
1240 pub portalnumber: u8,
1241 #[serde(deserialize_with = "deserialize_bool")]
1242 #[serde(default)]
1243 pub portalversion: bool,
1244 #[serde(default)]
1245 pub target: Option<&'a str>,
1246 pub translucencylimit: f32,
1247}
1248#[derive(Debug, Clone, Deserialize)]
1249pub struct FuncBombTarget<'a> {
1250 pub bombexplode: &'a str,
1251 pub model: &'a str,
1252 #[serde(default)]
1253 pub spawnflags: Option<u32>,
1254 #[serde(default)]
1255 pub target: Option<&'a str>,
1256 #[serde(default)]
1257 pub targetname: Option<&'a str>,
1258}
1259#[derive(Debug, Clone, Deserialize)]
1260pub struct FuncBreakable<'a> {
1261 #[serde(default)]
1262 pub _minlight: Option<f32>,
1263 #[serde(default)]
1264 pub angles: Option<Angles>,
1265 #[serde(deserialize_with = "deserialize_bool")]
1266 #[serde(default)]
1267 pub delay: bool,
1268 #[serde(deserialize_with = "deserialize_bool")]
1269 #[serde(default)]
1270 pub disablereceiveshadows: bool,
1271 #[serde(deserialize_with = "deserialize_bool")]
1272 #[serde(default)]
1273 pub disableshadows: bool,
1274 #[serde(deserialize_with = "deserialize_bool")]
1275 #[serde(default)]
1276 pub explodedamage: bool,
1277 #[serde(default)]
1278 pub explodemagnitude: Option<u16>,
1279 #[serde(default)]
1280 pub exploderadius: Option<u16>,
1281 #[serde(deserialize_with = "deserialize_bool")]
1282 #[serde(default)]
1283 pub explosion: bool,
1284 pub gibdir: Vector,
1285 pub health: u32,
1286 #[serde(default)]
1287 pub material: Option<u8>,
1288 #[serde(default)]
1289 pub minhealthdmg: Option<u8>,
1290 pub model: &'a str,
1291 #[serde(deserialize_with = "deserialize_bool")]
1292 #[serde(default)]
1293 pub nodamageforces: bool,
1294 #[serde(default)]
1295 pub onbreak: Option<&'a str>,
1296 pub origin: Vector,
1297 #[serde(default)]
1298 pub parentname: Option<&'a str>,
1299 #[serde(deserialize_with = "deserialize_bool")]
1300 #[serde(default)]
1301 pub performancemode: bool,
1302 pub physdamagescale: f32,
1303 #[serde(deserialize_with = "deserialize_bool")]
1304 #[serde(default)]
1305 pub pressuredelay: bool,
1306 #[serde(default)]
1307 pub propdata: Option<u8>,
1308 pub renderamt: u8,
1309 pub rendercolor: Color,
1310 #[serde(deserialize_with = "deserialize_bool")]
1311 #[serde(default)]
1312 pub renderfx: bool,
1313 #[serde(default)]
1314 pub rendermode: Option<u8>,
1315 #[serde(default)]
1316 pub spawnflags: Option<u32>,
1317 #[serde(deserialize_with = "deserialize_bool")]
1318 #[serde(default)]
1319 pub spawnobject: bool,
1320 #[serde(default)]
1321 pub targetname: Option<&'a str>,
1322}
1323#[derive(Debug, Clone, Deserialize)]
1324pub struct FuncBreakableSurf<'a> {
1325 #[serde(deserialize_with = "deserialize_bool")]
1326 pub disablereceiveshadows: bool,
1327 #[serde(deserialize_with = "deserialize_bool")]
1328 pub disableshadows: bool,
1329 #[serde(deserialize_with = "deserialize_bool")]
1330 pub error: bool,
1331 #[serde(deserialize_with = "deserialize_bool")]
1332 pub explodedamage: bool,
1333 #[serde(deserialize_with = "deserialize_bool")]
1334 pub explodemagnitude: bool,
1335 #[serde(deserialize_with = "deserialize_bool")]
1336 pub exploderadius: bool,
1337 #[serde(deserialize_with = "deserialize_bool")]
1338 pub explosion: bool,
1339 pub fragility: u8,
1340 pub gibdir: Vector,
1341 pub health: u8,
1342 pub lowerleft: Vector,
1343 pub lowerright: Vector,
1344 #[serde(deserialize_with = "deserialize_bool")]
1345 pub material: bool,
1346 pub model: &'a str,
1347 #[serde(deserialize_with = "deserialize_bool")]
1348 #[serde(default)]
1349 pub nodamageforces: bool,
1350 #[serde(deserialize_with = "deserialize_bool")]
1351 #[serde(default)]
1352 pub performancemode: bool,
1353 #[serde(deserialize_with = "deserialize_bool")]
1354 pub pressuredelay: bool,
1355 #[serde(default)]
1356 pub propdata: Option<u8>,
1357 pub renderamt: u8,
1358 pub rendercolor: Color,
1359 #[serde(deserialize_with = "deserialize_bool")]
1360 pub renderfx: bool,
1361 #[serde(deserialize_with = "deserialize_bool")]
1362 pub rendermode: bool,
1363 #[serde(default)]
1364 pub spawnflags: Option<u32>,
1365 #[serde(deserialize_with = "deserialize_bool")]
1366 pub spawnobject: bool,
1367 #[serde(deserialize_with = "deserialize_bool")]
1368 pub surfacetype: bool,
1369 #[serde(default)]
1370 pub targetname: Option<&'a str>,
1371 pub upperleft: Vector,
1372 pub upperright: Vector,
1373}
1374#[derive(Debug, Clone, Deserialize)]
1375pub struct FuncBrush<'a> {
1376 #[serde(default)]
1377 pub _minlight: Option<f32>,
1378 #[serde(deserialize_with = "deserialize_bool")]
1379 #[serde(default)]
1380 pub disablereceiveshadows: bool,
1381 #[serde(deserialize_with = "deserialize_bool")]
1382 #[serde(default)]
1383 pub disableshadows: bool,
1384 #[serde(default)]
1385 pub inputfilter: Option<u8>,
1386 #[serde(deserialize_with = "deserialize_bool")]
1387 #[serde(default)]
1388 pub invert_exclusion: bool,
1389 pub model: &'a str,
1390 pub origin: Vector,
1391 pub renderamt: u8,
1392 pub rendercolor: Color,
1393 #[serde(default)]
1394 pub renderfx: Option<u8>,
1395 #[serde(default)]
1396 pub rendermode: Option<u8>,
1397 #[serde(deserialize_with = "deserialize_bool")]
1398 #[serde(default)]
1399 pub solidbsp: bool,
1400 pub solidity: u8,
1401 #[serde(default)]
1402 pub spawnflags: Option<u32>,
1403 #[serde(default)]
1404 pub speed: Option<u8>,
1405 #[serde(deserialize_with = "deserialize_bool")]
1406 #[serde(default)]
1407 pub startdisabled: bool,
1408 #[serde(default)]
1409 pub targetname: Option<&'a str>,
1410 #[serde(deserialize_with = "deserialize_bool")]
1411 #[serde(default)]
1412 pub vrad_brush_cast_shadows: bool,
1413 #[serde(default)]
1414 pub wait: Option<u8>,
1415}
1416#[derive(Debug, Clone, Deserialize)]
1417pub struct FuncButton<'a> {
1418 #[serde(default)]
1419 pub _minlight: Option<f32>,
1420 #[serde(default)]
1421 pub angles: Option<Angles>,
1422 #[serde(deserialize_with = "deserialize_bool")]
1423 pub disablereceiveshadows: bool,
1424 #[serde(deserialize_with = "deserialize_bool")]
1425 #[serde(default)]
1426 pub disableshadows: bool,
1427 #[serde(deserialize_with = "deserialize_bool")]
1428 #[serde(default)]
1429 pub health: bool,
1430 pub lip: f32,
1431 #[serde(deserialize_with = "deserialize_bool")]
1432 #[serde(default)]
1433 pub locked_sentence: bool,
1434 #[serde(default)]
1435 pub locked_sound: Option<u8>,
1436 pub model: &'a str,
1437 pub movedir: Vector,
1438 #[serde(default)]
1439 pub ondamaged: Option<&'a str>,
1440 #[serde(default)]
1441 pub onin: Option<&'a str>,
1442 #[serde(default)]
1443 pub onout: Option<&'a str>,
1444 pub onpressed: &'a str,
1445 #[serde(default)]
1446 pub onuselocked: Option<&'a str>,
1447 pub origin: Vector,
1448 #[serde(default)]
1449 pub parentname: Option<&'a str>,
1450 pub renderamt: u8,
1451 pub rendercolor: Color,
1452 pub renderfx: u8,
1453 pub rendermode: u8,
1454 pub sounds: u8,
1455 pub spawnflags: u32,
1456 pub speed: f32,
1457 #[serde(default)]
1458 pub targetname: Option<&'a str>,
1459 #[serde(deserialize_with = "deserialize_bool")]
1460 #[serde(default)]
1461 pub unlocked_sentence: bool,
1462 #[serde(deserialize_with = "deserialize_bool")]
1463 #[serde(default)]
1464 pub unlocked_sound: bool,
1465 pub wait: f32,
1466}
1467#[derive(Debug, Clone, Deserialize)]
1468pub struct FuncBuyzone<'a> {
1469 pub model: &'a str,
1470 #[serde(default)]
1471 pub team: Option<u8>,
1472 #[serde(default)]
1473 pub teamnum: Option<u8>,
1474}
1475#[derive(Debug, Clone, Deserialize)]
1476pub struct FuncClipVphysics<'a> {
1477 pub model: &'a str,
1478 #[serde(default)]
1479 pub spawnflags: Option<u32>,
1480 #[serde(default)]
1481 pub targetname: Option<&'a str>,
1482}
1483#[derive(Debug, Clone, Deserialize)]
1484pub struct FuncConveyor<'a> {
1485 #[serde(default)]
1486 pub _minlight: Option<f32>,
1487 #[serde(default)]
1488 pub angles: Option<Angles>,
1489 #[serde(deserialize_with = "deserialize_bool")]
1490 pub disablereceiveshadows: bool,
1491 #[serde(deserialize_with = "deserialize_bool")]
1492 pub disableshadows: bool,
1493 pub model: &'a str,
1494 pub movedir: Vector,
1495 pub renderamt: u8,
1496 pub rendercolor: Color,
1497 #[serde(deserialize_with = "deserialize_bool")]
1498 pub renderfx: bool,
1499 #[serde(deserialize_with = "deserialize_bool")]
1500 pub rendermode: bool,
1501 pub spawnflags: u32,
1502 pub speed: u16,
1503}
1504#[derive(Debug, Clone, Deserialize)]
1505pub struct FuncDoor<'a> {
1506 #[serde(default)]
1507 pub _minlight: Option<f32>,
1508 #[serde(deserialize_with = "deserialize_bool")]
1509 pub disablereceiveshadows: bool,
1510 #[serde(deserialize_with = "deserialize_bool")]
1511 #[serde(default)]
1512 pub disableshadows: bool,
1513 #[serde(default)]
1514 pub dmg: Option<u32>,
1515 #[serde(deserialize_with = "deserialize_bool")]
1516 #[serde(default)]
1517 pub forceclosed: bool,
1518 #[serde(deserialize_with = "deserialize_bool")]
1519 pub health: bool,
1520 #[serde(deserialize_with = "deserialize_bool")]
1521 #[serde(default)]
1522 pub ignoredebris: bool,
1523 #[serde(default)]
1524 pub lip: Option<f32>,
1525 #[serde(deserialize_with = "deserialize_bool")]
1526 pub locked_sentence: bool,
1527 #[serde(deserialize_with = "deserialize_bool")]
1528 #[serde(default)]
1529 pub locked_sound: bool,
1530 #[serde(deserialize_with = "deserialize_bool")]
1531 #[serde(default)]
1532 pub loopmovesound: bool,
1533 pub model: &'a str,
1534 pub movedir: Vector,
1535 #[serde(deserialize_with = "deserialize_bool")]
1536 #[serde(default)]
1537 pub no_decomp: bool,
1538 #[serde(default)]
1539 pub noise1: Option<&'a str>,
1540 #[serde(default)]
1541 pub noise2: Option<&'a str>,
1542 #[serde(default)]
1543 pub onclose: Option<&'a str>,
1544 #[serde(default)]
1545 pub onfullyclosed: Option<&'a str>,
1546 #[serde(default)]
1547 pub onfullyopen: Option<&'a str>,
1548 #[serde(default)]
1549 pub onopen: Option<&'a str>,
1550 pub origin: Vector,
1551 #[serde(default)]
1552 pub parentname: Option<&'a str>,
1553 pub renderamt: u8,
1554 pub rendercolor: Color,
1555 #[serde(default)]
1556 pub renderfx: Option<u8>,
1557 pub rendermode: u8,
1558 #[serde(deserialize_with = "deserialize_bool")]
1559 #[serde(default)]
1560 pub sounds: bool,
1561 pub spawnflags: u32,
1562 #[serde(deserialize_with = "deserialize_bool")]
1563 #[serde(default)]
1564 pub spawnpos: bool,
1565 pub speed: u16,
1566 #[serde(default)]
1567 pub targetname: Option<&'a str>,
1568 #[serde(deserialize_with = "deserialize_bool")]
1569 pub unlocked_sentence: bool,
1570 #[serde(deserialize_with = "deserialize_bool")]
1571 #[serde(default)]
1572 pub unlocked_sound: bool,
1573 pub wait: f32,
1574}
1575#[derive(Debug, Clone, Deserialize)]
1576pub struct FuncDoorRotating<'a> {
1577 #[serde(deserialize_with = "deserialize_bool")]
1578 #[serde(default)]
1579 pub _minlight: bool,
1580 pub angles: Angles,
1581 #[serde(default)]
1582 pub chainstodoor: Option<&'a str>,
1583 #[serde(deserialize_with = "deserialize_bool")]
1584 pub disablereceiveshadows: bool,
1585 #[serde(deserialize_with = "deserialize_bool")]
1586 pub disableshadows: bool,
1587 pub distance: u8,
1588 pub dmg: u32,
1589 #[serde(deserialize_with = "deserialize_bool")]
1590 #[serde(default)]
1591 pub forceclosed: bool,
1592 #[serde(deserialize_with = "deserialize_bool")]
1593 pub health: bool,
1594 #[serde(deserialize_with = "deserialize_bool")]
1595 #[serde(default)]
1596 pub ignoredebris: bool,
1597 pub lip: u8,
1598 #[serde(deserialize_with = "deserialize_bool")]
1599 pub locked_sentence: bool,
1600 #[serde(deserialize_with = "deserialize_bool")]
1601 #[serde(default)]
1602 pub loopmovesound: bool,
1603 pub model: &'a str,
1604 #[serde(default)]
1605 pub noise1: Option<&'a str>,
1606 #[serde(default)]
1607 pub noise2: Option<&'a str>,
1608 #[serde(default)]
1609 pub onfullyclosed: Option<&'a str>,
1610 #[serde(default)]
1611 pub onfullyopen: Option<&'a str>,
1612 pub origin: Vector,
1613 #[serde(default)]
1614 pub parentname: Option<&'a str>,
1615 pub renderamt: u8,
1616 pub rendercolor: Color,
1617 #[serde(deserialize_with = "deserialize_bool")]
1618 pub renderfx: bool,
1619 #[serde(deserialize_with = "deserialize_bool")]
1620 pub rendermode: bool,
1621 #[serde(deserialize_with = "deserialize_bool")]
1622 #[serde(default)]
1623 pub solidbsp: bool,
1624 pub spawnflags: u32,
1625 #[serde(deserialize_with = "deserialize_bool")]
1626 #[serde(default)]
1627 pub spawnpos: bool,
1628 pub speed: u16,
1629 #[serde(default)]
1630 pub targetname: Option<&'a str>,
1631 #[serde(deserialize_with = "deserialize_bool")]
1632 pub unlocked_sentence: bool,
1633 pub wait: i32,
1634}
1635#[derive(Debug, Clone, Deserialize)]
1636pub struct FuncDustcloud<'a> {
1637 pub alpha: u8,
1638 pub color: Color,
1639 pub distmax: u16,
1640 #[serde(deserialize_with = "deserialize_bool")]
1641 pub frozen: bool,
1642 pub lifetimemax: u8,
1643 pub lifetimemin: u8,
1644 pub model: &'a str,
1645 pub sizemax: u8,
1646 pub sizemin: u8,
1647 pub spawnrate: u16,
1648 pub speedmax: u8,
1649 #[serde(deserialize_with = "deserialize_bool")]
1650 pub startdisabled: bool,
1651 #[serde(default)]
1652 pub targetname: Option<&'a str>,
1653}
1654#[derive(Debug, Clone, Deserialize)]
1655pub struct FuncDustmotes<'a> {
1656 pub alpha: u8,
1657 pub color: Color,
1658 pub distmax: u16,
1659 #[serde(deserialize_with = "deserialize_bool")]
1660 #[serde(default)]
1661 pub fallspeed: bool,
1662 #[serde(deserialize_with = "deserialize_bool")]
1663 pub frozen: bool,
1664 pub lifetimemax: u8,
1665 pub lifetimemin: u8,
1666 pub model: &'a str,
1667 pub sizemax: u8,
1668 pub sizemin: u8,
1669 pub spawnrate: u32,
1670 pub speedmax: u8,
1671 #[serde(deserialize_with = "deserialize_bool")]
1672 pub startdisabled: bool,
1673 #[serde(default)]
1674 pub targetname: Option<&'a str>,
1675}
1676#[derive(Debug, Clone, Deserialize)]
1677pub struct FuncFishPool<'a> {
1678 pub fish_count: u8,
1679 pub max_range: u16,
1680 pub model: &'a str,
1681 pub origin: Vector,
1682 #[serde(deserialize_with = "deserialize_bool")]
1683 #[serde(default)]
1684 pub skin: bool,
1685}
1686#[derive(Debug, Clone, Deserialize)]
1687pub struct FuncFootstepControl<'a> {
1688 pub destination: &'a str,
1689 pub model: &'a str,
1690 pub source: &'a str,
1691}
1692#[derive(Debug, Clone, Deserialize)]
1693pub struct FuncHostageRescue<'a> {
1694 pub model: &'a str,
1695}
1696#[derive(Debug, Clone, Deserialize)]
1697pub struct FuncIllusionary<'a> {
1698 #[serde(default)]
1699 pub _minlight: Option<f32>,
1700 #[serde(deserialize_with = "deserialize_bool")]
1701 #[serde(default)]
1702 pub disablereceiveshadows: bool,
1703 #[serde(deserialize_with = "deserialize_bool")]
1704 #[serde(default)]
1705 pub disableshadows: bool,
1706 pub model: &'a str,
1707 pub origin: Vector,
1708 pub renderamt: u8,
1709 pub rendercolor: Color,
1710 #[serde(default)]
1711 pub renderfx: Option<u8>,
1712 #[serde(default)]
1713 pub rendermode: Option<u8>,
1714 #[serde(default)]
1715 pub skin: Option<i32>,
1716 #[serde(default)]
1717 pub spawnflags: Option<u32>,
1718 #[serde(default)]
1719 pub speed: Option<u8>,
1720 #[serde(default)]
1721 pub targetname: Option<&'a str>,
1722 #[serde(default)]
1723 pub wait: Option<u8>,
1724 #[serde(default)]
1725 pub zhlt_lightflags: Option<u8>,
1726}
1727#[derive(Debug, Clone, Deserialize)]
1728pub struct FuncLod<'a> {
1729 pub disappeardist: u16,
1730 pub model: &'a str,
1731 #[serde(deserialize_with = "deserialize_bool")]
1732 pub solid: bool,
1733}
1734#[derive(Debug, Clone, Deserialize)]
1735pub struct FuncMonitor<'a> {
1736 #[serde(default)]
1737 pub _minlight: Option<f32>,
1738 #[serde(deserialize_with = "deserialize_bool")]
1739 #[serde(default)]
1740 pub disablereceiveshadows: bool,
1741 #[serde(deserialize_with = "deserialize_bool")]
1742 #[serde(default)]
1743 pub disableshadows: bool,
1744 #[serde(deserialize_with = "deserialize_bool")]
1745 #[serde(default)]
1746 pub inputfilter: bool,
1747 #[serde(deserialize_with = "deserialize_bool")]
1748 #[serde(default)]
1749 pub invert_exclusion: bool,
1750 pub model: &'a str,
1751 pub origin: Vector,
1752 #[serde(default)]
1753 pub parentname: Option<&'a str>,
1754 pub renderamt: u8,
1755 pub rendercolor: Color,
1756 #[serde(deserialize_with = "deserialize_bool")]
1757 #[serde(default)]
1758 pub renderfx: bool,
1759 #[serde(default)]
1760 pub rendermode: Option<u8>,
1761 #[serde(deserialize_with = "deserialize_bool")]
1762 #[serde(default)]
1763 pub solidbsp: bool,
1764 #[serde(deserialize_with = "deserialize_bool")]
1765 #[serde(default)]
1766 pub solidity: bool,
1767 #[serde(default)]
1768 pub spawnflags: Option<u32>,
1769 #[serde(deserialize_with = "deserialize_bool")]
1770 #[serde(default)]
1771 pub startdisabled: bool,
1772 pub target: &'a str,
1773 #[serde(default)]
1774 pub targetname: Option<&'a str>,
1775 #[serde(deserialize_with = "deserialize_bool")]
1776 #[serde(default)]
1777 pub vrad_brush_cast_shadows: bool,
1778}
1779#[derive(Debug, Clone, Deserialize)]
1780pub struct FuncMovelinear<'a> {
1781 #[serde(default)]
1782 pub _minlight: Option<f32>,
1783 #[serde(default)]
1784 pub blockdamage: Option<f32>,
1785 #[serde(deserialize_with = "deserialize_bool")]
1786 pub disablereceiveshadows: bool,
1787 #[serde(deserialize_with = "deserialize_bool")]
1788 #[serde(default)]
1789 pub disableshadows: bool,
1790 pub model: &'a str,
1791 pub movedir: Vector,
1792 pub movedistance: u16,
1793 #[serde(default)]
1794 pub onfullyclosed: Option<&'a str>,
1795 #[serde(default)]
1796 pub onfullyopen: Option<&'a str>,
1797 pub origin: Vector,
1798 #[serde(default)]
1799 pub parentname: Option<&'a str>,
1800 pub renderamt: u8,
1801 pub rendercolor: Color,
1802 #[serde(deserialize_with = "deserialize_bool")]
1803 pub renderfx: bool,
1804 pub rendermode: u8,
1805 pub spawnflags: u32,
1806 pub speed: u8,
1807 pub startposition: f32,
1808 #[serde(default)]
1809 pub startsound: Option<&'a str>,
1810 #[serde(default)]
1811 pub stopsound: Option<&'a str>,
1812 #[serde(default)]
1813 pub targetname: Option<&'a str>,
1814}
1815#[derive(Debug, Clone, Deserialize)]
1816pub struct FuncOccluder<'a> {
1817 pub model: &'a str,
1818 pub occludernumber: u8,
1819 #[serde(deserialize_with = "deserialize_bool")]
1820 pub startactive: bool,
1821 #[serde(default)]
1822 pub targetname: Option<&'a str>,
1823}
1824#[derive(Debug, Clone, Deserialize)]
1825pub struct FuncPhysbox<'a> {
1826 #[serde(default)]
1827 pub _minlight: Option<f32>,
1828 #[serde(deserialize_with = "deserialize_bool")]
1829 #[serde(default)]
1830 pub damagetoenablemotion: bool,
1831 #[serde(deserialize_with = "deserialize_bool")]
1832 pub damagetype: bool,
1833 #[serde(deserialize_with = "deserialize_bool")]
1834 pub disablereceiveshadows: bool,
1835 #[serde(deserialize_with = "deserialize_bool")]
1836 pub disableshadows: bool,
1837 #[serde(deserialize_with = "deserialize_bool")]
1838 #[serde(default)]
1839 pub explodedamage: bool,
1840 #[serde(deserialize_with = "deserialize_bool")]
1841 #[serde(default)]
1842 pub explodemagnitude: bool,
1843 #[serde(deserialize_with = "deserialize_bool")]
1844 #[serde(default)]
1845 pub exploderadius: bool,
1846 #[serde(deserialize_with = "deserialize_bool")]
1847 #[serde(default)]
1848 pub explosion: bool,
1849 #[serde(deserialize_with = "deserialize_bool")]
1850 #[serde(default)]
1851 pub forcetoenablemotion: bool,
1852 pub gibdir: Vector,
1853 #[serde(default)]
1854 pub health: Option<u16>,
1855 #[serde(default)]
1856 pub massscale: Option<f32>,
1857 #[serde(default)]
1858 pub material: Option<u8>,
1859 pub model: &'a str,
1860 #[serde(deserialize_with = "deserialize_bool")]
1861 #[serde(default)]
1862 pub nodamageforces: bool,
1863 #[serde(deserialize_with = "deserialize_bool")]
1864 #[serde(default)]
1865 pub notsolid: bool,
1866 pub origin: Vector,
1867 #[serde(default)]
1868 pub parentname: Option<&'a str>,
1869 #[serde(deserialize_with = "deserialize_bool")]
1870 #[serde(default)]
1871 pub performancemode: bool,
1872 pub preferredcarryangles: Angles,
1873 #[serde(deserialize_with = "deserialize_bool")]
1874 #[serde(default)]
1875 pub pressuredelay: bool,
1876 #[serde(default)]
1877 pub propdata: Option<u8>,
1878 pub renderamt: u8,
1879 pub rendercolor: Color,
1880 #[serde(deserialize_with = "deserialize_bool")]
1881 pub renderfx: bool,
1882 #[serde(deserialize_with = "deserialize_bool")]
1883 pub rendermode: bool,
1884 pub spawnflags: u32,
1885 #[serde(deserialize_with = "deserialize_bool")]
1886 #[serde(default)]
1887 pub spawnobject: bool,
1888 #[serde(default)]
1889 pub targetname: Option<&'a str>,
1890}
1891#[derive(Debug, Clone, Deserialize)]
1892pub struct FuncPhysboxMultiplayer<'a> {
1893 #[serde(default)]
1894 pub _minlight: Option<u8>,
1895 #[serde(deserialize_with = "deserialize_bool")]
1896 pub damagetoenablemotion: bool,
1897 #[serde(deserialize_with = "deserialize_bool")]
1898 pub damagetype: bool,
1899 #[serde(deserialize_with = "deserialize_bool")]
1900 pub disablereceiveshadows: bool,
1901 #[serde(deserialize_with = "deserialize_bool")]
1902 pub disableshadows: bool,
1903 #[serde(deserialize_with = "deserialize_bool")]
1904 pub explodedamage: bool,
1905 #[serde(deserialize_with = "deserialize_bool")]
1906 pub explodemagnitude: bool,
1907 #[serde(deserialize_with = "deserialize_bool")]
1908 pub exploderadius: bool,
1909 #[serde(deserialize_with = "deserialize_bool")]
1910 pub explosion: bool,
1911 #[serde(deserialize_with = "deserialize_bool")]
1912 pub forcetoenablemotion: bool,
1913 pub gibdir: Vector,
1914 pub health: u8,
1915 pub massscale: f32,
1916 pub material: u8,
1917 pub model: &'a str,
1918 #[serde(deserialize_with = "deserialize_bool")]
1919 pub nodamageforces: bool,
1920 #[serde(deserialize_with = "deserialize_bool")]
1921 pub notsolid: bool,
1922 #[serde(default)]
1923 pub onawakened: Option<&'a str>,
1924 pub origin: Vector,
1925 #[serde(default)]
1926 pub parentname: Option<&'a str>,
1927 #[serde(deserialize_with = "deserialize_bool")]
1928 pub performancemode: bool,
1929 pub preferredcarryangles: Angles,
1930 #[serde(deserialize_with = "deserialize_bool")]
1931 pub pressuredelay: bool,
1932 #[serde(deserialize_with = "deserialize_bool")]
1933 pub propdata: bool,
1934 pub renderamt: u8,
1935 pub rendercolor: Color,
1936 pub renderfx: u8,
1937 pub rendermode: u8,
1938 pub spawnflags: u32,
1939 #[serde(deserialize_with = "deserialize_bool")]
1940 #[serde(default)]
1941 pub spawnobject: bool,
1942 #[serde(default)]
1943 pub targetname: Option<&'a str>,
1944}
1945#[derive(Debug, Clone, Deserialize)]
1946pub struct FuncPrecipitation<'a> {
1947 pub model: &'a str,
1948 #[serde(default)]
1949 pub preciptype: Option<u8>,
1950 pub renderamt: u16,
1951 pub rendercolor: Color,
1952 #[serde(default)]
1953 pub renderfx: Option<u8>,
1954 #[serde(default)]
1955 pub targetname: Option<&'a str>,
1956}
1957#[derive(Debug, Clone, Deserialize)]
1958pub struct FuncRotButton<'a> {
1959 pub angles: Angles,
1960 pub distance: i32,
1961 #[serde(deserialize_with = "deserialize_bool")]
1962 pub health: bool,
1963 pub model: &'a str,
1964 pub onpressed: &'a str,
1965 pub origin: Vector,
1966 pub sounds: u8,
1967 pub spawnflags: u32,
1968 pub speed: u8,
1969 #[serde(deserialize_with = "deserialize_bool")]
1970 #[serde(default)]
1971 pub startdisabled: bool,
1972 #[serde(default)]
1973 pub targetname: Option<&'a str>,
1974 pub wait: i32,
1975}
1976#[derive(Debug, Clone, Deserialize)]
1977pub struct FuncRotating<'a> {
1978 #[serde(default)]
1979 pub _minlight: Option<f32>,
1980 pub angles: Angles,
1981 #[serde(deserialize_with = "deserialize_bool")]
1982 pub disablereceiveshadows: bool,
1983 #[serde(deserialize_with = "deserialize_bool")]
1984 #[serde(default)]
1985 pub disableshadows: bool,
1986 pub dmg: f32,
1987 pub fanfriction: f32,
1988 pub maxspeed: f32,
1989 #[serde(default)]
1990 pub message: Option<&'a str>,
1991 pub model: &'a str,
1992 #[serde(deserialize_with = "deserialize_bool")]
1993 #[serde(default)]
1994 pub no_decomp: bool,
1995 pub origin: Vector,
1996 #[serde(default)]
1997 pub parentname: Option<&'a str>,
1998 pub renderamt: u8,
1999 pub rendercolor: Color,
2000 #[serde(deserialize_with = "deserialize_bool")]
2001 pub renderfx: bool,
2002 pub rendermode: u8,
2003 #[serde(deserialize_with = "deserialize_bool")]
2004 #[serde(default)]
2005 pub solidbsp: bool,
2006 pub spawnflags: u32,
2007 #[serde(default)]
2008 pub targetname: Option<&'a str>,
2009 pub volume: f32,
2010}
2011#[derive(Debug, Clone, Deserialize)]
2012pub struct FuncSmokevolume<'a> {
2013 pub color1: Color,
2014 pub color2: Color,
2015 pub density: f32,
2016 #[serde(deserialize_with = "deserialize_bool")]
2017 pub densityrampspeed: bool,
2018 pub material: &'a str,
2019 pub model: &'a str,
2020 pub movementspeed: u8,
2021 pub particledrawwidth: u8,
2022 pub particlespacingdistance: u8,
2023 pub rotationspeed: u8,
2024 pub spawnflags: u32,
2025}
2026#[derive(Debug, Clone, Deserialize)]
2027pub struct FuncTracktrain<'a> {
2028 #[serde(deserialize_with = "deserialize_bool")]
2029 #[serde(default)]
2030 pub _minlight: bool,
2031 #[serde(deserialize_with = "deserialize_bool")]
2032 pub bank: bool,
2033 #[serde(deserialize_with = "deserialize_bool")]
2034 pub disablereceiveshadows: bool,
2035 #[serde(deserialize_with = "deserialize_bool")]
2036 pub disableshadows: bool,
2037 #[serde(deserialize_with = "deserialize_bool")]
2038 pub dmg: bool,
2039 pub height: u8,
2040 #[serde(deserialize_with = "deserialize_bool")]
2041 #[serde(default)]
2042 pub manualaccelspeed: bool,
2043 #[serde(deserialize_with = "deserialize_bool")]
2044 #[serde(default)]
2045 pub manualdecelspeed: bool,
2046 #[serde(deserialize_with = "deserialize_bool")]
2047 #[serde(default)]
2048 pub manualspeedchanges: bool,
2049 pub model: &'a str,
2050 #[serde(default)]
2051 pub movesound: Option<&'a str>,
2052 pub movesoundmaxpitch: u8,
2053 #[serde(deserialize_with = "deserialize_bool")]
2054 pub movesoundmaxtime: bool,
2055 pub movesoundminpitch: u8,
2056 #[serde(deserialize_with = "deserialize_bool")]
2057 pub movesoundmintime: bool,
2058 pub orientationtype: u8,
2059 pub origin: Vector,
2060 pub renderamt: u8,
2061 pub rendercolor: Color,
2062 #[serde(deserialize_with = "deserialize_bool")]
2063 pub renderfx: bool,
2064 #[serde(deserialize_with = "deserialize_bool")]
2065 pub rendermode: bool,
2066 pub spawnflags: u32,
2067 pub speed: u16,
2068 #[serde(default)]
2069 pub startsound: Option<&'a str>,
2070 pub startspeed: u16,
2071 #[serde(default)]
2072 pub stopsound: Option<&'a str>,
2073 pub target: &'a str,
2074 pub targetname: &'a str,
2075 pub velocitytype: u8,
2076 pub volume: f32,
2077 pub wheels: u8,
2078}
2079#[derive(Debug, Clone, Deserialize)]
2080pub struct FuncTrain<'a> {
2081 pub _minlight: f32,
2082 #[serde(deserialize_with = "deserialize_bool")]
2083 pub disablereceiveshadows: bool,
2084 #[serde(deserialize_with = "deserialize_bool")]
2085 pub disableshadows: bool,
2086 #[serde(deserialize_with = "deserialize_bool")]
2087 pub dmg: bool,
2088 pub model: &'a str,
2089 pub origin: Vector,
2090 pub renderamt: u8,
2091 pub rendercolor: Color,
2092 #[serde(deserialize_with = "deserialize_bool")]
2093 pub renderfx: bool,
2094 #[serde(deserialize_with = "deserialize_bool")]
2095 pub rendermode: bool,
2096 pub spawnflags: u32,
2097 pub speed: u16,
2098 pub target: &'a str,
2099 pub targetname: &'a str,
2100 #[serde(deserialize_with = "deserialize_bool")]
2101 pub texframeindex: bool,
2102 pub volume: f32,
2103}
2104#[derive(Debug, Clone, Deserialize)]
2105pub struct FuncWall<'a> {
2106 #[serde(default)]
2107 pub _minlight: Option<f32>,
2108 #[serde(deserialize_with = "deserialize_bool")]
2109 #[serde(default)]
2110 pub disablereceiveshadows: bool,
2111 #[serde(deserialize_with = "deserialize_bool")]
2112 #[serde(default)]
2113 pub disableshadows: bool,
2114 pub model: &'a str,
2115 #[serde(default)]
2116 pub origin: Option<Vector>,
2117 pub renderamt: u8,
2118 pub rendercolor: Color,
2119 #[serde(default)]
2120 pub renderfx: Option<u8>,
2121 #[serde(default)]
2122 pub rendermode: Option<u8>,
2123 #[serde(default)]
2124 pub spawnflags: Option<u32>,
2125 #[serde(default)]
2126 pub targetname: Option<&'a str>,
2127 #[serde(deserialize_with = "deserialize_bool")]
2128 #[serde(default)]
2129 pub zhlt_lightflags: bool,
2130}
2131#[derive(Debug, Clone, Deserialize)]
2132pub struct FuncWallToggle<'a> {
2133 #[serde(default)]
2134 pub _minlight: Option<f32>,
2135 #[serde(deserialize_with = "deserialize_bool")]
2136 pub disablereceiveshadows: bool,
2137 #[serde(deserialize_with = "deserialize_bool")]
2138 pub disableshadows: bool,
2139 pub model: &'a str,
2140 #[serde(default)]
2141 pub origin: Option<Vector>,
2142 pub renderamt: u8,
2143 pub rendercolor: Color,
2144 pub renderfx: u8,
2145 pub rendermode: u8,
2146 pub spawnflags: u32,
2147 pub targetname: &'a str,
2148}
2149#[derive(Debug, Clone, Deserialize)]
2150pub struct FuncWaterAnalog<'a> {
2151 #[serde(default)]
2152 pub _minlight: Option<f32>,
2153 #[serde(deserialize_with = "deserialize_bool")]
2154 #[serde(default)]
2155 pub disablereceiveshadows: bool,
2156 #[serde(deserialize_with = "deserialize_bool")]
2157 #[serde(default)]
2158 pub disableshadows: bool,
2159 pub model: &'a str,
2160 #[serde(default)]
2161 pub movedir: Option<Vector>,
2162 #[serde(default)]
2163 pub movedistance: Option<u8>,
2164 pub origin: Vector,
2165 #[serde(default)]
2166 pub parentname: Option<&'a str>,
2167 #[serde(default)]
2168 pub renderamt: Option<u8>,
2169 #[serde(default)]
2170 pub rendercolor: Option<Color>,
2171 #[serde(deserialize_with = "deserialize_bool")]
2172 #[serde(default)]
2173 pub renderfx: bool,
2174 #[serde(default)]
2175 pub rendermode: Option<u8>,
2176 #[serde(default)]
2177 pub speed: Option<u8>,
2178 #[serde(deserialize_with = "deserialize_bool")]
2179 #[serde(default)]
2180 pub startposition: bool,
2181 #[serde(default)]
2182 pub targetname: Option<&'a str>,
2183 pub waveheight: f32,
2184}
2185#[derive(Debug, Clone, Deserialize)]
2186pub struct GamePlayerEquip<'a> {
2187 #[serde(deserialize_with = "deserialize_bool")]
2188 #[serde(default)]
2189 pub ammo_338mag: bool,
2190 #[serde(default)]
2191 pub ammo_45acp: Option<u8>,
2192 #[serde(default)]
2193 pub ammo_50ae: Option<u8>,
2194 #[serde(default)]
2195 pub ammo_762mm: Option<u8>,
2196 #[serde(default)]
2197 pub ammo_9mm: Option<u8>,
2198 #[serde(default)]
2199 pub ammo_buckshot: Option<u8>,
2200 #[serde(default)]
2201 pub item_assaultsuit: Option<u8>,
2202 pub origin: Vector,
2203 #[serde(default)]
2204 pub spawnflags: Option<u32>,
2205 #[serde(default)]
2206 pub targetname: Option<&'a str>,
2207 #[serde(deserialize_with = "deserialize_bool")]
2208 #[serde(default)]
2209 pub weapon_awp: bool,
2210 #[serde(deserialize_with = "deserialize_bool")]
2211 #[serde(default)]
2212 pub weapon_deagle: bool,
2213 #[serde(deserialize_with = "deserialize_bool")]
2214 #[serde(default)]
2215 pub weapon_glock: bool,
2216 #[serde(deserialize_with = "deserialize_bool")]
2217 #[serde(default)]
2218 pub weapon_hegrenade: bool,
2219 #[serde(deserialize_with = "deserialize_bool")]
2220 #[serde(default)]
2221 pub weapon_knife: bool,
2222 #[serde(deserialize_with = "deserialize_bool")]
2223 #[serde(default)]
2224 pub weapon_m3: bool,
2225 #[serde(deserialize_with = "deserialize_bool")]
2226 #[serde(default)]
2227 pub weapon_p90: bool,
2228 #[serde(deserialize_with = "deserialize_bool")]
2229 #[serde(default)]
2230 pub weapon_scout: bool,
2231 #[serde(deserialize_with = "deserialize_bool")]
2232 #[serde(default)]
2233 pub weapon_usp: bool,
2234}
2235#[derive(Debug, Clone, Deserialize)]
2236pub struct GameText<'a> {
2237 pub channel: u8,
2238 pub color: Color,
2239 pub color2: Color,
2240 pub effect: u8,
2241 pub fadein: f32,
2242 pub fadeout: f32,
2243 pub fxtime: f32,
2244 pub holdtime: u8,
2245 pub message: &'a str,
2246 pub origin: Vector,
2247 pub spawnflags: u32,
2248 pub targetname: &'a str,
2249 pub x: i32,
2250 pub y: f32,
2251}
2252#[derive(Debug, Clone, Deserialize)]
2253pub struct GameUi<'a> {
2254 pub fieldofview: f32,
2255 pub origin: Vector,
2256 pub playeroff: &'a str,
2257 pub pressedback: &'a str,
2258 pub pressedforward: &'a str,
2259 pub pressedmoveleft: &'a str,
2260 pub pressedmoveright: &'a str,
2261 pub spawnflags: u32,
2262 pub targetname: &'a str,
2263 pub unpressedback: &'a str,
2264 pub unpressedforward: &'a str,
2265 pub unpressedmoveleft: &'a str,
2266 pub unpressedmoveright: &'a str,
2267}
2268#[derive(Debug, Clone, Deserialize)]
2269pub struct GameWeaponManager<'a> {
2270 #[serde(deserialize_with = "deserialize_bool")]
2271 pub ammomod: bool,
2272 #[serde(deserialize_with = "deserialize_bool")]
2273 pub maxpieces: bool,
2274 pub origin: Vector,
2275 pub weaponname: &'a str,
2276}
2277#[derive(Debug, Clone, Deserialize)]
2278pub struct HostageEntity<'a> {
2279 pub angles: Angles,
2280 #[serde(deserialize_with = "deserialize_bool")]
2281 #[serde(default)]
2282 pub hostagetype: bool,
2283 #[serde(default)]
2284 pub model: Option<&'a str>,
2285 pub origin: Vector,
2286 #[serde(deserialize_with = "deserialize_bool")]
2287 #[serde(default)]
2288 pub skin: bool,
2289 #[serde(default)]
2290 pub spawnflags: Option<u32>,
2291}
2292#[derive(Debug, Clone, Deserialize)]
2293pub struct InfoCameraLink<'a> {
2294 pub origin: Vector,
2295 #[serde(default)]
2296 pub pointcamera: Option<&'a str>,
2297 #[serde(default)]
2298 pub target: Option<&'a str>,
2299 #[serde(default)]
2300 pub targetname: Option<&'a str>,
2301}
2302#[derive(Debug, Clone, Deserialize)]
2303pub struct InfoLadder {
2304 #[serde(rename = "maxs.x")]
2305 pub maxs_x: f32,
2306 #[serde(rename = "maxs.y")]
2307 pub maxs_y: f32,
2308 #[serde(rename = "maxs.z")]
2309 pub maxs_z: f32,
2310 #[serde(rename = "mins.x")]
2311 pub mins_x: f32,
2312 #[serde(rename = "mins.y")]
2313 pub mins_y: f32,
2314 #[serde(rename = "mins.z")]
2315 pub mins_z: f32,
2316}
2317#[derive(Debug, Clone, Deserialize)]
2318pub struct InfoLightingRelative<'a> {
2319 pub lightinglandmark: &'a str,
2320 pub origin: Vector,
2321 pub targetname: &'a str,
2322}
2323#[derive(Debug, Clone, Deserialize)]
2324pub struct InfoMapParameters {
2325 #[serde(default)]
2326 pub angles: Option<Angles>,
2327 pub bombradius: u16,
2328 #[serde(deserialize_with = "deserialize_bool")]
2329 #[serde(default)]
2330 pub buying: bool,
2331 pub origin: Vector,
2332 #[serde(default)]
2333 pub spawnflags: Option<u32>,
2334}
2335#[derive(Debug, Clone, Deserialize)]
2336pub struct InfoNode {
2337 pub nodeid: u16,
2338 pub origin: Vector,
2339}
2340#[derive(Debug, Clone, Deserialize)]
2341pub struct InfoNodeHint {
2342 pub angles: Angles,
2343 pub hinttype: u16,
2344 pub ignorefacing: u8,
2345 pub maximumstate: u8,
2346 #[serde(deserialize_with = "deserialize_bool")]
2347 pub minimumstate: bool,
2348 pub nodefov: u8,
2349 pub nodeid: u8,
2350 pub origin: Vector,
2351 #[serde(deserialize_with = "deserialize_bool")]
2352 pub starthintdisabled: bool,
2353 pub targetnode: i32,
2354}
2355#[derive(Debug, Clone, Deserialize)]
2356pub struct InfoParticleSystem<'a> {
2357 pub angles: Angles,
2358 #[serde(deserialize_with = "deserialize_bool")]
2359 pub cpoint1_parent: bool,
2360 #[serde(deserialize_with = "deserialize_bool")]
2361 pub cpoint2_parent: bool,
2362 #[serde(deserialize_with = "deserialize_bool")]
2363 pub cpoint3_parent: bool,
2364 #[serde(deserialize_with = "deserialize_bool")]
2365 pub cpoint4_parent: bool,
2366 #[serde(deserialize_with = "deserialize_bool")]
2367 pub cpoint5_parent: bool,
2368 #[serde(deserialize_with = "deserialize_bool")]
2369 pub cpoint6_parent: bool,
2370 #[serde(deserialize_with = "deserialize_bool")]
2371 pub cpoint7_parent: bool,
2372 pub effect_name: &'a str,
2373 #[serde(deserialize_with = "deserialize_bool")]
2374 pub flag_as_weather: bool,
2375 pub origin: Vector,
2376 #[serde(default)]
2377 pub parentname: Option<&'a str>,
2378 #[serde(default)]
2379 pub spawnflags: Option<u32>,
2380 #[serde(deserialize_with = "deserialize_bool")]
2381 pub start_active: bool,
2382 #[serde(default)]
2383 pub targetname: Option<&'a str>,
2384}
2385#[derive(Debug, Clone, Deserialize)]
2386pub struct InfoPlayerCounterterrorist {
2387 pub angles: Angles,
2388 pub origin: Vector,
2389}
2390#[derive(Debug, Clone, Deserialize)]
2391pub struct InfoPlayerLogo {
2392 pub angles: Angles,
2393 pub origin: Vector,
2394}
2395#[derive(Debug, Clone, Deserialize)]
2396pub struct InfoPlayerStart {
2397 pub angles: Angles,
2398 pub origin: Vector,
2399 #[serde(default)]
2400 pub spawnflags: Option<u32>,
2401}
2402#[derive(Debug, Clone, Deserialize)]
2403pub struct InfoPlayerTerrorist {
2404 pub angles: Angles,
2405 #[serde(deserialize_with = "deserialize_bool")]
2406 #[serde(default)]
2407 pub no_decomp: bool,
2408 pub origin: Vector,
2409}
2410#[derive(Debug, Clone, Deserialize)]
2411pub struct InfoTarget<'a> {
2412 pub angles: Angles,
2413 pub origin: Vector,
2414 #[serde(default)]
2415 pub parentname: Option<&'a str>,
2416 #[serde(default)]
2417 pub spawnflags: Option<u32>,
2418 #[serde(default)]
2419 pub targetname: Option<&'a str>,
2420}
2421#[derive(Debug, Clone, Deserialize)]
2422pub struct InfoTeleportDestination<'a> {
2423 pub angles: Angles,
2424 pub origin: Vector,
2425 #[serde(default)]
2426 pub parentname: Option<&'a str>,
2427 #[serde(default)]
2428 pub targetname: Option<&'a str>,
2429}
2430#[derive(Debug, Clone, Deserialize)]
2431pub struct Infodecal<'a> {
2432 #[serde(default)]
2433 pub angles: Option<Angles>,
2434 #[serde(deserialize_with = "deserialize_bool")]
2435 #[serde(default)]
2436 pub lowpriority: bool,
2437 pub origin: Vector,
2438 #[serde(default)]
2439 pub spawnflags: Option<u32>,
2440 pub texture: &'a str,
2441}
2442#[derive(Debug, Clone, Deserialize)]
2443pub struct KeyframeRope<'a> {
2444 #[serde(default)]
2445 pub angles: Option<Angles>,
2446 #[serde(deserialize_with = "deserialize_bool")]
2447 #[serde(default)]
2448 pub barbed: bool,
2449 #[serde(deserialize_with = "deserialize_bool")]
2450 #[serde(default)]
2451 pub breakable: bool,
2452 #[serde(deserialize_with = "deserialize_bool")]
2453 #[serde(default)]
2454 pub collide: bool,
2455 #[serde(deserialize_with = "deserialize_bool")]
2456 #[serde(default)]
2457 pub dangling: bool,
2458 #[serde(deserialize_with = "deserialize_bool")]
2459 #[serde(default)]
2460 pub maxdxlevel: bool,
2461 #[serde(deserialize_with = "deserialize_bool")]
2462 #[serde(default)]
2463 pub mindxlevel: bool,
2464 pub movespeed: u8,
2465 #[serde(default)]
2466 pub nextkey: Option<&'a str>,
2467 #[serde(deserialize_with = "deserialize_bool")]
2468 #[serde(default)]
2469 pub nowind: bool,
2470 pub origin: Vector,
2471 #[serde(default)]
2472 pub parentname: Option<&'a str>,
2473 #[serde(deserialize_with = "deserialize_bool")]
2474 #[serde(default)]
2475 pub r#type: bool,
2476 pub ropematerial: &'a str,
2477 pub slack: f32,
2478 #[serde(default)]
2479 pub spawnflags: Option<u32>,
2480 pub subdiv: u8,
2481 pub targetname: &'a str,
2482 pub texturescale: u8,
2483 pub width: f32,
2484}
2485#[derive(Debug, Clone, Deserialize)]
2486pub struct Light<'a> {
2487 #[serde(default)]
2488 pub _constant_attn: Option<f32>,
2489 #[serde(default)]
2490 pub _distance: Option<u16>,
2491 #[serde(default)]
2492 pub _fifty_percent_distance: Option<f32>,
2493 #[serde(default)]
2494 pub _hardfalloff: Option<u16>,
2495 pub _light: LightColor,
2496 #[serde(default)]
2497 pub _lighthdr: Option<&'a str>,
2498 #[serde(deserialize_with = "deserialize_bool")]
2499 #[serde(default)]
2500 pub _lightscalehdr: bool,
2501 #[serde(default)]
2502 pub _linear_attn: Option<f32>,
2503 pub _quadratic_attn: f32,
2504 #[serde(default)]
2505 pub _zero_percent_distance: Option<f32>,
2506 #[serde(default)]
2507 pub angles: Option<Angles>,
2508 #[serde(default)]
2509 pub defaultstyle: Option<u8>,
2510 #[serde(default)]
2511 pub ontimer: Option<&'a str>,
2512 pub origin: Vector,
2513 #[serde(default)]
2514 pub spawnflags: Option<u32>,
2515 #[serde(default)]
2516 pub style: Option<u8>,
2517 #[serde(default)]
2518 pub targetname: Option<&'a str>,
2519}
2520#[derive(Debug, Clone, Deserialize)]
2521pub struct LightEnvironment<'a> {
2522 pub _ambient: LightColor,
2523 #[serde(default)]
2524 pub _ambienthdr: Option<&'a str>,
2525 #[serde(deserialize_with = "deserialize_bool")]
2526 #[serde(default)]
2527 pub _ambientscalehdr: bool,
2528 #[serde(default)]
2529 pub _diffuse_light: Option<LightColor>,
2530 #[serde(default)]
2531 pub _diffuse_lighting: Option<LightColor>,
2532 pub _light: LightColor,
2533 #[serde(default)]
2534 pub _lighthdr: Option<&'a str>,
2535 #[serde(deserialize_with = "deserialize_bool")]
2536 #[serde(default)]
2537 pub _lightscalehdr: bool,
2538 pub angles: Vector,
2539 pub origin: Vector,
2540 #[serde(default)]
2541 pub pitch: Option<i32>,
2542 #[serde(default)]
2543 pub spawnflags: Option<u32>,
2544 #[serde(deserialize_with = "deserialize_bool")]
2545 #[serde(default)]
2546 pub style: bool,
2547 #[serde(default)]
2548 pub sunspreadangle: Option<u8>,
2549}
2550#[derive(Debug, Clone, Deserialize)]
2551pub struct LightSpot<'a> {
2552 pub _cone: u8,
2553 #[serde(default)]
2554 pub _cone2: Option<u8>,
2555 #[serde(default)]
2556 pub _constant_attn: Option<f32>,
2557 #[serde(default)]
2558 pub _distance: Option<u32>,
2559 pub _exponent: f32,
2560 #[serde(default)]
2561 pub _fifty_percent_distance: Option<f32>,
2562 #[serde(deserialize_with = "deserialize_bool")]
2563 #[serde(default)]
2564 pub _hardfalloff: bool,
2565 pub _inner_cone: u8,
2566 pub _light: LightColor,
2567 #[serde(default)]
2568 pub _lighthdr: Option<&'a str>,
2569 #[serde(deserialize_with = "deserialize_bool")]
2570 #[serde(default)]
2571 pub _lightscalehdr: bool,
2572 #[serde(default)]
2573 pub _linear_attn: Option<f32>,
2574 #[serde(deserialize_with = "deserialize_bool")]
2575 pub _quadratic_attn: bool,
2576 #[serde(default)]
2577 pub _zero_percent_distance: Option<f32>,
2578 pub angles: Angles,
2579 #[serde(default)]
2580 pub defaultstyle: Option<u8>,
2581 pub origin: Vector,
2582 pub pitch: f32,
2583 #[serde(default)]
2584 pub renderamt: Option<u8>,
2585 #[serde(default)]
2586 pub spawnflags: Option<u32>,
2587 #[serde(default)]
2588 pub style: Option<u8>,
2589 #[serde(default)]
2590 pub targetname: Option<&'a str>,
2591}
2592#[derive(Debug, Clone, Deserialize)]
2593pub struct LogicAuto<'a> {
2594 #[serde(default)]
2595 pub onloadgame: Option<&'a str>,
2596 pub onmapspawn: &'a str,
2597 #[serde(default)]
2598 pub onnewgame: Option<&'a str>,
2599 pub origin: Vector,
2600 pub spawnflags: u32,
2601}
2602#[derive(Debug, Clone, Deserialize)]
2603pub struct LogicBranch<'a> {
2604 #[serde(deserialize_with = "deserialize_bool")]
2605 pub initialvalue: bool,
2606 #[serde(default)]
2607 pub onfalse: Option<&'a str>,
2608 pub ontrue: &'a str,
2609 pub origin: Vector,
2610 pub targetname: &'a str,
2611}
2612#[derive(Debug, Clone, Deserialize)]
2613pub struct LogicCase<'a> {
2614 #[serde(default)]
2615 pub case01: Option<u8>,
2616 #[serde(default)]
2617 pub case02: Option<u8>,
2618 #[serde(default)]
2619 pub case03: Option<u8>,
2620 #[serde(default)]
2621 pub case04: Option<u8>,
2622 #[serde(default)]
2623 pub case05: Option<u8>,
2624 #[serde(default)]
2625 pub case06: Option<u8>,
2626 #[serde(default)]
2627 pub case07: Option<u8>,
2628 #[serde(default)]
2629 pub case08: Option<u8>,
2630 #[serde(default)]
2631 pub case09: Option<u8>,
2632 #[serde(default)]
2633 pub case10: Option<u8>,
2634 #[serde(default)]
2635 pub case11: Option<u8>,
2636 #[serde(default)]
2637 pub case12: Option<u8>,
2638 #[serde(default)]
2639 pub case13: Option<u8>,
2640 #[serde(default)]
2641 pub case14: Option<u8>,
2642 #[serde(default)]
2643 pub case15: Option<u8>,
2644 #[serde(default)]
2645 pub case16: Option<u8>,
2646 pub oncase01: &'a str,
2647 pub oncase02: &'a str,
2648 pub oncase03: &'a str,
2649 pub oncase04: &'a str,
2650 #[serde(default)]
2651 pub oncase05: Option<&'a str>,
2652 #[serde(default)]
2653 pub oncase06: Option<&'a str>,
2654 #[serde(default)]
2655 pub oncase07: Option<&'a str>,
2656 #[serde(default)]
2657 pub oncase08: Option<&'a str>,
2658 #[serde(default)]
2659 pub oncase09: Option<&'a str>,
2660 #[serde(default)]
2661 pub oncase10: Option<&'a str>,
2662 #[serde(default)]
2663 pub oncase11: Option<&'a str>,
2664 #[serde(default)]
2665 pub oncase12: Option<&'a str>,
2666 #[serde(default)]
2667 pub oncase13: Option<&'a str>,
2668 #[serde(default)]
2669 pub oncase14: Option<&'a str>,
2670 #[serde(default)]
2671 pub oncase15: Option<&'a str>,
2672 #[serde(default)]
2673 pub oncase16: Option<&'a str>,
2674 pub origin: Vector,
2675 pub targetname: &'a str,
2676}
2677#[derive(Debug, Clone, Deserialize)]
2678pub struct LogicCompare<'a> {
2679 #[serde(deserialize_with = "deserialize_bool")]
2680 pub comparevalue: bool,
2681 pub ongreaterthan: &'a str,
2682 pub origin: Vector,
2683 pub targetname: &'a str,
2684}
2685#[derive(Debug, Clone, Deserialize)]
2686pub struct LogicMeasureMovement<'a> {
2687 pub measurereference: &'a str,
2688 pub measuretarget: &'a str,
2689 #[serde(deserialize_with = "deserialize_bool")]
2690 pub measuretype: bool,
2691 pub origin: Vector,
2692 pub target: &'a str,
2693 pub targetname: &'a str,
2694 pub targetreference: &'a str,
2695 #[serde(deserialize_with = "deserialize_bool")]
2696 pub targetscale: bool,
2697}
2698#[derive(Debug, Clone, Deserialize)]
2699pub struct LogicRelay<'a> {
2700 pub ontrigger: &'a str,
2701 pub origin: Vector,
2702 #[serde(default)]
2703 pub spawnflags: Option<u32>,
2704 #[serde(deserialize_with = "deserialize_bool")]
2705 #[serde(default)]
2706 pub startdisabled: bool,
2707 pub targetname: &'a str,
2708}
2709#[derive(Debug, Clone, Deserialize)]
2710pub struct LogicTimer<'a> {
2711 #[serde(default)]
2712 pub lowerrandombound: Option<u8>,
2713 pub ontimer: &'a str,
2714 #[serde(default)]
2715 pub ontimerhigh: Option<&'a str>,
2716 #[serde(default)]
2717 pub ontimerlow: Option<&'a str>,
2718 pub origin: Vector,
2719 #[serde(default)]
2720 pub refiretime: Option<f32>,
2721 #[serde(default)]
2722 pub spawnflags: Option<u32>,
2723 #[serde(deserialize_with = "deserialize_bool")]
2724 #[serde(default)]
2725 pub startdisabled: bool,
2726 #[serde(default)]
2727 pub targetname: Option<&'a str>,
2728 #[serde(default)]
2729 pub upperrandombound: Option<u8>,
2730 #[serde(deserialize_with = "deserialize_bool")]
2731 #[serde(default)]
2732 pub userandomtime: bool,
2733}
2734#[derive(Debug, Clone, Deserialize)]
2735pub struct MathCounter<'a> {
2736 pub max: u16,
2737 #[serde(deserialize_with = "deserialize_bool")]
2738 #[serde(default)]
2739 pub min: bool,
2740 pub onhitmax: &'a str,
2741 pub origin: Vector,
2742 #[serde(default)]
2743 pub outvalue: Option<&'a str>,
2744 #[serde(deserialize_with = "deserialize_bool")]
2745 #[serde(default)]
2746 pub startdisabled: bool,
2747 #[serde(deserialize_with = "deserialize_bool")]
2748 #[serde(default)]
2749 pub startvalue: bool,
2750 pub targetname: &'a str,
2751}
2752#[derive(Debug, Clone, Deserialize)]
2753pub struct MoveRope<'a> {
2754 #[serde(default)]
2755 pub angles: Option<Angles>,
2756 #[serde(deserialize_with = "deserialize_bool")]
2757 #[serde(default)]
2758 pub barbed: bool,
2759 #[serde(deserialize_with = "deserialize_bool")]
2760 #[serde(default)]
2761 pub breakable: bool,
2762 #[serde(deserialize_with = "deserialize_bool")]
2763 #[serde(default)]
2764 pub collide: bool,
2765 #[serde(deserialize_with = "deserialize_bool")]
2766 #[serde(default)]
2767 pub dangling: bool,
2768 #[serde(deserialize_with = "deserialize_bool")]
2769 #[serde(default)]
2770 pub maxdxlevel: bool,
2771 #[serde(deserialize_with = "deserialize_bool")]
2772 #[serde(default)]
2773 pub mindxlevel: bool,
2774 pub movespeed: u8,
2775 #[serde(default)]
2776 pub nextkey: Option<&'a str>,
2777 #[serde(deserialize_with = "deserialize_bool")]
2778 #[serde(default)]
2779 pub nowind: bool,
2780 pub origin: Vector,
2781 #[serde(default)]
2782 pub parentname: Option<&'a str>,
2783 pub positioninterpolator: u8,
2784 #[serde(default)]
2785 pub r#type: Option<u8>,
2786 pub ropematerial: &'a str,
2787 pub slack: u8,
2788 #[serde(default)]
2789 pub spawnflags: Option<u32>,
2790 pub subdiv: u8,
2791 #[serde(default)]
2792 pub targetname: Option<&'a str>,
2793 pub texturescale: u8,
2794 pub width: f32,
2795}
2796#[derive(Debug, Clone, Deserialize)]
2797pub struct PathTrack<'a> {
2798 pub angles: Angles,
2799 #[serde(default)]
2800 pub onpass: Option<&'a str>,
2801 #[serde(default)]
2802 pub onuser1: Option<&'a str>,
2803 pub orientationtype: u8,
2804 pub origin: Vector,
2805 #[serde(deserialize_with = "deserialize_bool")]
2806 #[serde(default)]
2807 pub radius: bool,
2808 #[serde(default)]
2809 pub spawnflags: Option<u32>,
2810 #[serde(default)]
2811 pub speed: Option<u16>,
2812 #[serde(default)]
2813 pub target: Option<&'a str>,
2814 pub targetname: &'a str,
2815}
2816#[derive(Debug, Clone, Deserialize)]
2817pub struct PhysBallsocket<'a> {
2818 pub attach1: &'a str,
2819 #[serde(deserialize_with = "deserialize_bool")]
2820 #[serde(default)]
2821 pub forcelimit: bool,
2822 pub origin: Vector,
2823 #[serde(default)]
2824 pub spawnflags: Option<u32>,
2825 #[serde(default)]
2826 pub targetname: Option<&'a str>,
2827 #[serde(deserialize_with = "deserialize_bool")]
2828 #[serde(default)]
2829 pub torquelimit: bool,
2830}
2831#[derive(Debug, Clone, Deserialize)]
2832pub struct PhysConstraint<'a> {
2833 pub angles: Angles,
2834 pub constraintsystem: &'a str,
2835 #[serde(deserialize_with = "deserialize_bool")]
2836 pub forcelimit: bool,
2837 pub origin: Vector,
2838 pub spawnflags: u32,
2839 #[serde(deserialize_with = "deserialize_bool")]
2840 pub torquelimit: bool,
2841}
2842#[derive(Debug, Clone, Deserialize)]
2843pub struct PhysConstraintsystem<'a> {
2844 #[serde(deserialize_with = "deserialize_bool")]
2845 pub additionaliterations: bool,
2846 pub origin: Vector,
2847 pub targetname: &'a str,
2848}
2849#[derive(Debug, Clone, Deserialize)]
2850pub struct PhysHinge<'a> {
2851 pub attach1: &'a str,
2852 #[serde(default)]
2853 pub breaksound: Option<&'a str>,
2854 #[serde(default)]
2855 pub constraintsystem: Option<&'a str>,
2856 #[serde(deserialize_with = "deserialize_bool")]
2857 pub forcelimit: bool,
2858 pub hingeaxis: Vector,
2859 pub hingefriction: u16,
2860 pub origin: Vector,
2861 pub spawnflags: u32,
2862 #[serde(deserialize_with = "deserialize_bool")]
2863 pub systemloadscale: bool,
2864 #[serde(default)]
2865 pub targetname: Option<&'a str>,
2866 #[serde(deserialize_with = "deserialize_bool")]
2867 pub torquelimit: bool,
2868}
2869#[derive(Debug, Clone, Deserialize)]
2870pub struct PhysKeepupright<'a> {
2871 pub angles: Angles,
2872 pub angularlimit: u8,
2873 pub attach1: &'a str,
2874 pub origin: Vector,
2875 pub spawnflags: u32,
2876 #[serde(default)]
2877 pub targetname: Option<&'a str>,
2878}
2879#[derive(Debug, Clone, Deserialize)]
2880pub struct PhysLengthconstraint<'a> {
2881 #[serde(deserialize_with = "deserialize_bool")]
2882 pub addlength: bool,
2883 pub angles: Angles,
2884 pub attach1: &'a str,
2885 pub attachpoint: Vector,
2886 pub constraintsystem: &'a str,
2887 #[serde(deserialize_with = "deserialize_bool")]
2888 pub forcelimit: bool,
2889 #[serde(deserialize_with = "deserialize_bool")]
2890 pub minlength: bool,
2891 pub origin: Vector,
2892 pub spawnflags: u32,
2893 #[serde(default)]
2894 pub targetname: Option<&'a str>,
2895 #[serde(deserialize_with = "deserialize_bool")]
2896 pub torquelimit: bool,
2897}
2898#[derive(Debug, Clone, Deserialize)]
2899pub struct PhysPulleyconstraint<'a> {
2900 #[serde(deserialize_with = "deserialize_bool")]
2901 pub addlength: bool,
2902 pub angles: Angles,
2903 #[serde(default)]
2904 pub attach1: Option<&'a str>,
2905 #[serde(default)]
2906 pub attach2: Option<&'a str>,
2907 #[serde(default)]
2908 pub constraintsystem: Option<&'a str>,
2909 #[serde(deserialize_with = "deserialize_bool")]
2910 pub forcelimit: bool,
2911 #[serde(deserialize_with = "deserialize_bool")]
2912 pub gearratio: bool,
2913 pub origin: Vector,
2914 pub position2: Vector,
2915 pub spawnflags: u32,
2916 #[serde(deserialize_with = "deserialize_bool")]
2917 pub torquelimit: bool,
2918}
2919#[derive(Debug, Clone, Deserialize)]
2920pub struct PhysRagdollconstraint<'a> {
2921 #[serde(default)]
2922 pub angles: Option<Angles>,
2923 pub attach1: &'a str,
2924 #[serde(deserialize_with = "deserialize_bool")]
2925 pub forcelimit: bool,
2926 pub origin: Vector,
2927 pub spawnflags: u32,
2928 #[serde(deserialize_with = "deserialize_bool")]
2929 #[serde(default)]
2930 pub teleportfollowdistance: bool,
2931 #[serde(deserialize_with = "deserialize_bool")]
2932 pub torquelimit: bool,
2933 #[serde(deserialize_with = "deserialize_bool")]
2934 pub xfriction: bool,
2935 pub xmax: u8,
2936 pub xmin: i32,
2937 #[serde(deserialize_with = "deserialize_bool")]
2938 pub yfriction: bool,
2939 pub ymax: u8,
2940 pub ymin: i32,
2941 #[serde(deserialize_with = "deserialize_bool")]
2942 pub zfriction: bool,
2943 #[serde(deserialize_with = "deserialize_bool")]
2944 pub zmax: bool,
2945 #[serde(deserialize_with = "deserialize_bool")]
2946 pub zmin: bool,
2947}
2948#[derive(Debug, Clone, Deserialize)]
2949pub struct PhysRagdollmagnet {
2950 pub angles: Angles,
2951 pub axis: Vector,
2952 pub force: u16,
2953 pub origin: Vector,
2954 pub radius: u16,
2955 pub spawnflags: u32,
2956 #[serde(deserialize_with = "deserialize_bool")]
2957 pub startdisabled: bool,
2958}
2959#[derive(Debug, Clone, Deserialize)]
2960pub struct PhysThruster<'a> {
2961 pub angles: Angles,
2962 pub attach1: &'a str,
2963 pub force: u16,
2964 #[serde(deserialize_with = "deserialize_bool")]
2965 pub forcetime: bool,
2966 pub origin: Vector,
2967 #[serde(default)]
2968 pub parentname: Option<&'a str>,
2969 pub spawnflags: u32,
2970 pub targetname: &'a str,
2971}
2972#[derive(Debug, Clone, Deserialize)]
2973pub struct PhysTorque<'a> {
2974 pub attach1: &'a str,
2975 pub axis: Vector,
2976 pub force: u16,
2977 #[serde(deserialize_with = "deserialize_bool")]
2978 pub forcetime: bool,
2979 pub origin: Vector,
2980 pub spawnflags: u32,
2981 pub targetname: &'a str,
2982}
2983#[derive(Debug, Clone, Deserialize)]
2984pub struct PlayerSpeedmod<'a> {
2985 pub origin: Vector,
2986 #[serde(default)]
2987 pub spawnflags: Option<u32>,
2988 pub targetname: &'a str,
2989}
2990#[derive(Debug, Clone, Deserialize)]
2991pub struct PlayerWeaponstrip<'a> {
2992 pub origin: Vector,
2993 pub targetname: &'a str,
2994}
2995#[derive(Debug, Clone, Deserialize)]
2996pub struct PointCamera<'a> {
2997 pub angles: Angles,
2998 pub fogcolor: Color,
2999 #[serde(deserialize_with = "deserialize_bool")]
3000 #[serde(default)]
3001 pub fogenable: bool,
3002 pub fogend: u16,
3003 #[serde(deserialize_with = "deserialize_bool")]
3004 #[serde(default)]
3005 pub fogmaxdensity: bool,
3006 pub fogstart: u16,
3007 pub fov: u8,
3008 pub origin: Vector,
3009 #[serde(default)]
3010 pub resolution: Option<u16>,
3011 #[serde(default)]
3012 pub spawnflags: Option<u32>,
3013 pub targetname: &'a str,
3014 #[serde(deserialize_with = "deserialize_bool")]
3015 #[serde(default)]
3016 pub usescreenaspectratio: bool,
3017}
3018#[derive(Debug, Clone, Deserialize)]
3019pub struct PointClientcommand<'a> {
3020 pub origin: Vector,
3021 pub targetname: &'a str,
3022}
3023#[derive(Debug, Clone, Deserialize)]
3024pub struct PointDevshotCamera<'a> {
3025 pub angles: Angles,
3026 #[serde(default)]
3027 pub cameraname: Option<&'a str>,
3028 pub fov: u8,
3029 pub origin: Vector,
3030}
3031#[derive(Debug, Clone, Deserialize)]
3032pub struct PointServercommand<'a> {
3033 pub origin: Vector,
3034 pub targetname: &'a str,
3035}
3036#[derive(Debug, Clone, Deserialize)]
3037pub struct PointSpotlight<'a> {
3038 pub angles: Angles,
3039 #[serde(deserialize_with = "deserialize_bool")]
3040 #[serde(default)]
3041 pub disablereceiveshadows: bool,
3042 #[serde(default)]
3043 pub hdrcolorscale: Option<f32>,
3044 #[serde(deserialize_with = "deserialize_bool")]
3045 #[serde(default)]
3046 pub maxdxlevel: bool,
3047 #[serde(deserialize_with = "deserialize_bool")]
3048 #[serde(default)]
3049 pub mindxlevel: bool,
3050 pub origin: Vector,
3051 #[serde(default)]
3052 pub parentname: Option<&'a str>,
3053 #[serde(default)]
3054 pub renderamt: Option<u8>,
3055 pub rendercolor: Color,
3056 #[serde(default)]
3057 pub renderfx: Option<u8>,
3058 #[serde(default)]
3059 pub rendermode: Option<u8>,
3060 pub spawnflags: u32,
3061 pub spotlightlength: f32,
3062 pub spotlightwidth: f32,
3063 #[serde(default)]
3064 pub targetname: Option<&'a str>,
3065}
3066#[derive(Debug, Clone, Deserialize)]
3067pub struct PointSurroundtest<'a> {
3068 pub on2speakers: &'a str,
3069 pub on4speakers: &'a str,
3070 pub on51speakers: &'a str,
3071 pub origin: Vector,
3072 pub targetname: &'a str,
3073}
3074#[derive(Debug, Clone, Deserialize)]
3075pub struct PointTemplate<'a> {
3076 #[serde(default)]
3077 pub boltwidth: Option<u8>,
3078 #[serde(deserialize_with = "deserialize_bool")]
3079 #[serde(default)]
3080 pub damage: bool,
3081 #[serde(default)]
3082 pub decalname: Option<&'a str>,
3083 #[serde(deserialize_with = "deserialize_bool")]
3084 #[serde(default)]
3085 pub framerate: bool,
3086 #[serde(deserialize_with = "deserialize_bool")]
3087 #[serde(default)]
3088 pub framestart: bool,
3089 #[serde(default)]
3090 pub hdrcolorscale: Option<f32>,
3091 #[serde(deserialize_with = "deserialize_bool")]
3092 #[serde(default)]
3093 pub life: bool,
3094 #[serde(deserialize_with = "deserialize_bool")]
3095 #[serde(default)]
3096 pub noiseamplitude: bool,
3097 #[serde(default)]
3098 pub onentityspawned: Option<&'a str>,
3099 pub origin: Vector,
3100 #[serde(default)]
3101 pub radius: Option<u16>,
3102 #[serde(default)]
3103 pub renderamt: Option<u8>,
3104 #[serde(default)]
3105 pub rendercolor: Option<Color>,
3106 #[serde(deserialize_with = "deserialize_bool")]
3107 #[serde(default)]
3108 pub renderfx: bool,
3109 pub spawnflags: u32,
3110 #[serde(deserialize_with = "deserialize_bool")]
3111 #[serde(default)]
3112 pub striketime: bool,
3113 pub targetname: &'a str,
3114 pub template01: &'a str,
3115 #[serde(default)]
3116 pub template02: Option<&'a str>,
3117 #[serde(default)]
3118 pub template03: Option<&'a str>,
3119 #[serde(default)]
3120 pub template04: Option<&'a str>,
3121 #[serde(default)]
3122 pub template05: Option<&'a str>,
3123 #[serde(default)]
3124 pub texture: Option<&'a str>,
3125 #[serde(default)]
3126 pub texturescroll: Option<u8>,
3127 #[serde(deserialize_with = "deserialize_bool")]
3128 #[serde(default)]
3129 pub touchtype: bool,
3130}
3131#[derive(Debug, Clone, Deserialize)]
3132pub struct PointTesla<'a> {
3133 pub beamcount_max: u8,
3134 pub beamcount_min: u8,
3135 pub interval_max: u8,
3136 pub interval_min: f32,
3137 pub lifetime_max: f32,
3138 pub lifetime_min: f32,
3139 pub m_color: Color,
3140 pub m_flradius: u8,
3141 pub m_soundname: &'a str,
3142 pub origin: Vector,
3143 pub targetname: &'a str,
3144 pub texture: &'a str,
3145 pub thick_max: u8,
3146 pub thick_min: u8,
3147}
3148#[derive(Debug, Clone, Deserialize)]
3149pub struct PointViewcontrol<'a> {
3150 pub acceleration: u16,
3151 pub angles: Angles,
3152 pub deceleration: u16,
3153 #[serde(deserialize_with = "deserialize_bool")]
3154 #[serde(default)]
3155 pub interpolatepositiontoplayer: bool,
3156 pub origin: Vector,
3157 #[serde(default)]
3158 pub parentname: Option<&'a str>,
3159 pub spawnflags: u32,
3160 #[serde(deserialize_with = "deserialize_bool")]
3161 #[serde(default)]
3162 pub speed: bool,
3163 #[serde(default)]
3164 pub target: Option<&'a str>,
3165 #[serde(default)]
3166 pub targetname: Option<&'a str>,
3167 pub wait: f32,
3168}
3169#[derive(Debug, Clone, Deserialize)]
3170pub struct PropDoorRotating<'a> {
3171 pub ajarangles: Angles,
3172 pub angles: Angles,
3173 pub axis: &'a str,
3174 #[serde(deserialize_with = "deserialize_bool")]
3175 pub disableshadows: bool,
3176 pub distance: u8,
3177 #[serde(deserialize_with = "deserialize_bool")]
3178 #[serde(default)]
3179 pub dmg: bool,
3180 #[serde(deserialize_with = "deserialize_bool")]
3181 #[serde(default)]
3182 pub forceclosed: bool,
3183 #[serde(deserialize_with = "deserialize_bool")]
3184 pub hardware: bool,
3185 #[serde(deserialize_with = "deserialize_bool")]
3186 #[serde(default)]
3187 pub health: bool,
3188 pub model: &'a str,
3189 #[serde(default)]
3190 pub onclose: Option<&'a str>,
3191 #[serde(default)]
3192 pub onopen: Option<&'a str>,
3193 #[serde(deserialize_with = "deserialize_bool")]
3194 #[serde(default)]
3195 pub opendir: bool,
3196 pub origin: Vector,
3197 pub returndelay: i32,
3198 pub skin: u8,
3199 #[serde(default)]
3200 pub soundcloseoverride: Option<&'a str>,
3201 #[serde(default)]
3202 pub soundmoveoverride: Option<&'a str>,
3203 #[serde(default)]
3204 pub soundopenoverride: Option<&'a str>,
3205 pub spawnflags: u32,
3206 #[serde(deserialize_with = "deserialize_bool")]
3207 #[serde(default)]
3208 pub spawnpos: bool,
3209 pub speed: u8,
3210 #[serde(default)]
3211 pub targetname: Option<&'a str>,
3212}
3213#[derive(Debug, Clone, Deserialize)]
3214pub struct PropDynamic<'a> {
3215 #[serde(default)]
3216 pub _minlight: Option<f32>,
3217 pub angles: Angles,
3218 #[serde(deserialize_with = "deserialize_bool")]
3219 #[serde(default)]
3220 pub body: bool,
3221 #[serde(default)]
3222 pub defaultanim: Option<&'a str>,
3223 #[serde(deserialize_with = "deserialize_bool")]
3224 #[serde(default)]
3225 pub disablebonefollowers: bool,
3226 #[serde(deserialize_with = "deserialize_bool")]
3227 #[serde(default)]
3228 pub disablereceiveshadows: bool,
3229 #[serde(deserialize_with = "deserialize_bool")]
3230 #[serde(default)]
3231 pub disableshadows: bool,
3232 #[serde(deserialize_with = "deserialize_bool")]
3233 #[serde(default)]
3234 pub explodedamage: bool,
3235 #[serde(deserialize_with = "deserialize_bool")]
3236 #[serde(default)]
3237 pub exploderadius: bool,
3238 #[serde(default)]
3239 pub fademaxdist: Option<f32>,
3240 pub fademindist: f32,
3241 #[serde(deserialize_with = "deserialize_bool")]
3242 #[serde(default)]
3243 pub fadescale: bool,
3244 #[serde(default)]
3245 pub globalname: Option<&'a str>,
3246 #[serde(deserialize_with = "deserialize_bool")]
3247 #[serde(default)]
3248 pub health: bool,
3249 #[serde(default)]
3250 pub lightingoriginhack: Option<&'a str>,
3251 pub maxanimtime: u8,
3252 #[serde(deserialize_with = "deserialize_bool")]
3253 #[serde(default)]
3254 pub maxdxlevel: bool,
3255 pub minanimtime: u8,
3256 #[serde(deserialize_with = "deserialize_bool")]
3257 #[serde(default)]
3258 pub mindxlevel: bool,
3259 pub model: &'a str,
3260 #[serde(default)]
3261 pub modelscale: Option<f32>,
3262 #[serde(default)]
3263 pub ontakedamage: Option<&'a str>,
3264 pub origin: Vector,
3265 #[serde(default)]
3266 pub parentname: Option<&'a str>,
3267 #[serde(deserialize_with = "deserialize_bool")]
3268 #[serde(default)]
3269 pub performancemode: bool,
3270 #[serde(deserialize_with = "deserialize_bool")]
3271 #[serde(default)]
3272 pub pressuredelay: bool,
3273 #[serde(deserialize_with = "deserialize_bool")]
3274 #[serde(default)]
3275 pub randomanimation: bool,
3276 #[serde(default)]
3277 pub renderamt: Option<u8>,
3278 #[serde(default)]
3279 pub rendercolor: Option<Color>,
3280 #[serde(default)]
3281 pub renderfx: Option<u8>,
3282 #[serde(deserialize_with = "deserialize_bool")]
3283 #[serde(default)]
3284 pub rendermode: bool,
3285 #[serde(default)]
3286 pub setbodygroup: Option<u8>,
3287 #[serde(deserialize_with = "deserialize_bool")]
3288 #[serde(default)]
3289 pub skin: bool,
3290 pub solid: u8,
3291 #[serde(default)]
3292 pub spawnflags: Option<u32>,
3293 #[serde(deserialize_with = "deserialize_bool")]
3294 #[serde(default)]
3295 pub startdisabled: bool,
3296 #[serde(default)]
3297 pub targetname: Option<&'a str>,
3298}
3299#[derive(Debug, Clone, Deserialize)]
3300pub struct PropDynamicOverride<'a> {
3301 #[serde(default)]
3302 pub _minlight: Option<f32>,
3303 pub angles: Angles,
3304 #[serde(default)]
3305 pub defaultanim: Option<&'a str>,
3306 #[serde(deserialize_with = "deserialize_bool")]
3307 #[serde(default)]
3308 pub disablebonefollowers: bool,
3309 #[serde(deserialize_with = "deserialize_bool")]
3310 #[serde(default)]
3311 pub disablereceiveshadows: bool,
3312 #[serde(deserialize_with = "deserialize_bool")]
3313 #[serde(default)]
3314 pub disableshadows: bool,
3315 #[serde(deserialize_with = "deserialize_bool")]
3316 #[serde(default)]
3317 pub explodedamage: bool,
3318 #[serde(deserialize_with = "deserialize_bool")]
3319 #[serde(default)]
3320 pub exploderadius: bool,
3321 #[serde(default)]
3322 pub fademaxdist: Option<u16>,
3323 pub fademindist: i32,
3324 #[serde(deserialize_with = "deserialize_bool")]
3325 pub fadescale: bool,
3326 #[serde(deserialize_with = "deserialize_bool")]
3327 #[serde(default)]
3328 pub health: bool,
3329 pub maxanimtime: f32,
3330 #[serde(deserialize_with = "deserialize_bool")]
3331 #[serde(default)]
3332 pub maxdxlevel: bool,
3333 pub minanimtime: f32,
3334 #[serde(deserialize_with = "deserialize_bool")]
3335 #[serde(default)]
3336 pub mindxlevel: bool,
3337 pub model: &'a str,
3338 #[serde(default)]
3339 pub modelscale: Option<f32>,
3340 pub origin: Vector,
3341 #[serde(default)]
3342 pub parentname: Option<&'a str>,
3343 #[serde(deserialize_with = "deserialize_bool")]
3344 #[serde(default)]
3345 pub performancemode: bool,
3346 #[serde(deserialize_with = "deserialize_bool")]
3347 #[serde(default)]
3348 pub pressuredelay: bool,
3349 #[serde(deserialize_with = "deserialize_bool")]
3350 #[serde(default)]
3351 pub randomanimation: bool,
3352 #[serde(default)]
3353 pub renderamt: Option<u8>,
3354 #[serde(default)]
3355 pub rendercolor: Option<Color>,
3356 #[serde(deserialize_with = "deserialize_bool")]
3357 #[serde(default)]
3358 pub renderfx: bool,
3359 #[serde(deserialize_with = "deserialize_bool")]
3360 #[serde(default)]
3361 pub rendermode: bool,
3362 #[serde(deserialize_with = "deserialize_bool")]
3363 #[serde(default)]
3364 pub setbodygroup: bool,
3365 #[serde(deserialize_with = "deserialize_bool")]
3366 #[serde(default)]
3367 pub skin: bool,
3368 pub solid: u8,
3369 #[serde(default)]
3370 pub spawnflags: Option<u32>,
3371 #[serde(deserialize_with = "deserialize_bool")]
3372 #[serde(default)]
3373 pub startdisabled: bool,
3374 #[serde(default)]
3375 pub targetname: Option<&'a str>,
3376}
3377#[derive(Debug, Clone, Deserialize)]
3378pub struct PropPhysics<'a> {
3379 #[serde(default)]
3380 pub _minlight: Option<f32>,
3381 pub angles: Angles,
3382 #[serde(deserialize_with = "deserialize_bool")]
3383 #[serde(default)]
3384 pub damagetoenablemotion: bool,
3385 #[serde(deserialize_with = "deserialize_bool")]
3386 #[serde(default)]
3387 pub damagetype: bool,
3388 #[serde(deserialize_with = "deserialize_bool")]
3389 #[serde(default)]
3390 pub disablereceiveshadows: bool,
3391 #[serde(deserialize_with = "deserialize_bool")]
3392 #[serde(default)]
3393 pub disableshadows: bool,
3394 #[serde(deserialize_with = "deserialize_bool")]
3395 #[serde(default)]
3396 pub explodedamage: bool,
3397 #[serde(deserialize_with = "deserialize_bool")]
3398 #[serde(default)]
3399 pub exploderadius: bool,
3400 #[serde(default)]
3401 pub fademaxdist: Option<u16>,
3402 pub fademindist: i32,
3403 #[serde(deserialize_with = "deserialize_bool")]
3404 #[serde(default)]
3405 pub fadescale: bool,
3406 #[serde(deserialize_with = "deserialize_bool")]
3407 #[serde(default)]
3408 pub forcetoenablemotion: bool,
3409 pub inertiascale: f32,
3410 #[serde(deserialize_with = "deserialize_bool")]
3411 #[serde(default)]
3412 pub massscale: bool,
3413 #[serde(deserialize_with = "deserialize_bool")]
3414 #[serde(default)]
3415 pub maxdxlevel: bool,
3416 #[serde(deserialize_with = "deserialize_bool")]
3417 #[serde(default)]
3418 pub mindxlevel: bool,
3419 #[serde(default)]
3420 pub minhealthdmg: Option<u8>,
3421 pub model: &'a str,
3422 #[serde(deserialize_with = "deserialize_bool")]
3423 #[serde(default)]
3424 pub nodamageforces: bool,
3425 pub origin: Vector,
3426 #[serde(deserialize_with = "deserialize_bool")]
3427 #[serde(default)]
3428 pub performancemode: bool,
3429 pub physdamagescale: f32,
3430 #[serde(deserialize_with = "deserialize_bool")]
3431 #[serde(default)]
3432 pub pressuredelay: bool,
3433 #[serde(default)]
3434 pub renderamt: Option<u8>,
3435 #[serde(default)]
3436 pub rendercolor: Option<Color>,
3437 #[serde(deserialize_with = "deserialize_bool")]
3438 #[serde(default)]
3439 pub renderfx: bool,
3440 #[serde(deserialize_with = "deserialize_bool")]
3441 #[serde(default)]
3442 pub rendermode: bool,
3443 #[serde(default)]
3444 pub shadowcastdist: Option<u8>,
3445 #[serde(default)]
3446 pub skin: Option<u8>,
3447 pub spawnflags: u32,
3448 #[serde(default)]
3449 pub targetname: Option<&'a str>,
3450}
3451#[derive(Debug, Clone, Deserialize)]
3452pub struct PropPhysicsMultiplayer<'a> {
3453 #[serde(default)]
3454 pub _minlight: Option<f32>,
3455 pub angles: Angles,
3456 #[serde(deserialize_with = "deserialize_bool")]
3457 #[serde(default)]
3458 pub body: bool,
3459 #[serde(deserialize_with = "deserialize_bool")]
3460 #[serde(default)]
3461 pub damagetoenablemotion: bool,
3462 #[serde(deserialize_with = "deserialize_bool")]
3463 #[serde(default)]
3464 pub damagetype: bool,
3465 #[serde(deserialize_with = "deserialize_bool")]
3466 #[serde(default)]
3467 pub disablereceiveshadows: bool,
3468 #[serde(deserialize_with = "deserialize_bool")]
3469 #[serde(default)]
3470 pub disableshadows: bool,
3471 #[serde(deserialize_with = "deserialize_bool")]
3472 #[serde(default)]
3473 pub explodedamage: bool,
3474 #[serde(deserialize_with = "deserialize_bool")]
3475 #[serde(default)]
3476 pub exploderadius: bool,
3477 #[serde(default)]
3478 pub fademaxdist: Option<u16>,
3479 pub fademindist: i32,
3480 #[serde(default)]
3481 pub fadescale: Option<f32>,
3482 #[serde(default)]
3483 pub forcetoenablemotion: Option<u16>,
3484 #[serde(deserialize_with = "deserialize_bool")]
3485 #[serde(default)]
3486 pub health: bool,
3487 pub inertiascale: f32,
3488 #[serde(default)]
3489 pub massscale: Option<f32>,
3490 #[serde(deserialize_with = "deserialize_bool")]
3491 #[serde(default)]
3492 pub maxdxlevel: bool,
3493 #[serde(deserialize_with = "deserialize_bool")]
3494 #[serde(default)]
3495 pub mindxlevel: bool,
3496 #[serde(default)]
3497 pub minhealthdmg: Option<u8>,
3498 pub model: &'a str,
3499 #[serde(deserialize_with = "deserialize_bool")]
3500 #[serde(default)]
3501 pub multiplayer_physics_mode: bool,
3502 #[serde(deserialize_with = "deserialize_bool")]
3503 #[serde(default)]
3504 pub nodamageforces: bool,
3505 #[serde(default)]
3506 pub onawakened: Option<&'a str>,
3507 #[serde(default)]
3508 pub onbreak: Option<&'a str>,
3509 #[serde(default)]
3510 pub onhealthchanged: Option<&'a str>,
3511 #[serde(default)]
3512 pub onmotionenabled: Option<&'a str>,
3513 pub origin: Vector,
3514 #[serde(deserialize_with = "deserialize_bool")]
3515 #[serde(default)]
3516 pub performancemode: bool,
3517 pub physdamagescale: f32,
3518 #[serde(default)]
3519 pub physicsmode: Option<u8>,
3520 #[serde(deserialize_with = "deserialize_bool")]
3521 #[serde(default)]
3522 pub pressuredelay: bool,
3523 #[serde(default)]
3524 pub renderamt: Option<u8>,
3525 #[serde(default)]
3526 pub rendercolor: Option<Color>,
3527 #[serde(deserialize_with = "deserialize_bool")]
3528 #[serde(default)]
3529 pub renderfx: bool,
3530 #[serde(deserialize_with = "deserialize_bool")]
3531 #[serde(default)]
3532 pub rendermode: bool,
3533 #[serde(deserialize_with = "deserialize_bool")]
3534 #[serde(default)]
3535 pub shadowcastdist: bool,
3536 #[serde(default)]
3537 pub skin: Option<u8>,
3538 #[serde(default)]
3539 pub solid: Option<u8>,
3540 pub spawnflags: u32,
3541 #[serde(default)]
3542 pub targetname: Option<&'a str>,
3543}
3544#[derive(Debug, Clone, Deserialize)]
3545pub struct PropPhysicsOverride<'a> {
3546 #[serde(default)]
3547 pub _minlight: Option<f32>,
3548 pub angles: Angles,
3549 #[serde(deserialize_with = "deserialize_bool")]
3550 #[serde(default)]
3551 pub body: bool,
3552 #[serde(deserialize_with = "deserialize_bool")]
3553 pub damagetoenablemotion: bool,
3554 #[serde(deserialize_with = "deserialize_bool")]
3555 pub damagetype: bool,
3556 #[serde(deserialize_with = "deserialize_bool")]
3557 #[serde(default)]
3558 pub disablereceiveshadows: bool,
3559 #[serde(deserialize_with = "deserialize_bool")]
3560 pub disableshadows: bool,
3561 #[serde(deserialize_with = "deserialize_bool")]
3562 pub explodedamage: bool,
3563 #[serde(deserialize_with = "deserialize_bool")]
3564 pub exploderadius: bool,
3565 #[serde(default)]
3566 pub fademaxdist: Option<u16>,
3567 pub fademindist: i32,
3568 #[serde(deserialize_with = "deserialize_bool")]
3569 pub fadescale: bool,
3570 #[serde(deserialize_with = "deserialize_bool")]
3571 pub forcetoenablemotion: bool,
3572 #[serde(deserialize_with = "deserialize_bool")]
3573 pub health: bool,
3574 pub inertiascale: f32,
3575 pub massscale: f32,
3576 #[serde(deserialize_with = "deserialize_bool")]
3577 #[serde(default)]
3578 pub maxdxlevel: bool,
3579 #[serde(deserialize_with = "deserialize_bool")]
3580 #[serde(default)]
3581 pub mindxlevel: bool,
3582 #[serde(deserialize_with = "deserialize_bool")]
3583 pub minhealthdmg: bool,
3584 pub model: &'a str,
3585 #[serde(default)]
3586 pub modelscale: Option<f32>,
3587 #[serde(deserialize_with = "deserialize_bool")]
3588 pub nodamageforces: bool,
3589 pub origin: Vector,
3590 #[serde(default)]
3591 pub parentname: Option<&'a str>,
3592 #[serde(deserialize_with = "deserialize_bool")]
3593 pub performancemode: bool,
3594 pub physdamagescale: f32,
3595 #[serde(deserialize_with = "deserialize_bool")]
3596 pub pressuredelay: bool,
3597 #[serde(default)]
3598 pub renderamt: Option<u8>,
3599 #[serde(default)]
3600 pub rendercolor: Option<Color>,
3601 #[serde(deserialize_with = "deserialize_bool")]
3602 #[serde(default)]
3603 pub renderfx: bool,
3604 #[serde(deserialize_with = "deserialize_bool")]
3605 #[serde(default)]
3606 pub rendermode: bool,
3607 #[serde(deserialize_with = "deserialize_bool")]
3608 pub shadowcastdist: bool,
3609 #[serde(deserialize_with = "deserialize_bool")]
3610 #[serde(default)]
3611 pub skin: bool,
3612 pub spawnflags: u32,
3613 #[serde(default)]
3614 pub targetname: Option<&'a str>,
3615}
3616#[derive(Debug, Clone, Deserialize)]
3617pub struct PropRagdoll<'a> {
3618 #[serde(default)]
3619 pub _minlight: Option<f32>,
3620 pub angles: Angles,
3621 #[serde(deserialize_with = "deserialize_bool")]
3622 #[serde(default)]
3623 pub disableshadows: bool,
3624 #[serde(default)]
3625 pub fademaxdist: Option<f32>,
3626 #[serde(default)]
3627 pub fademindist: Option<f32>,
3628 #[serde(deserialize_with = "deserialize_bool")]
3629 #[serde(default)]
3630 pub fadescale: bool,
3631 #[serde(deserialize_with = "deserialize_bool")]
3632 #[serde(default)]
3633 pub maxdxlevel: bool,
3634 #[serde(deserialize_with = "deserialize_bool")]
3635 #[serde(default)]
3636 pub mindxlevel: bool,
3637 pub model: &'a str,
3638 #[serde(default)]
3639 pub modelscale: Option<f32>,
3640 pub origin: Vector,
3641 #[serde(deserialize_with = "deserialize_bool")]
3642 #[serde(default)]
3643 pub renderamt: bool,
3644 #[serde(default)]
3645 pub rendercolor: Option<Color>,
3646 #[serde(deserialize_with = "deserialize_bool")]
3647 #[serde(default)]
3648 pub sequence: bool,
3649 #[serde(deserialize_with = "deserialize_bool")]
3650 #[serde(default)]
3651 pub skin: bool,
3652 #[serde(default)]
3653 pub solid: Option<u8>,
3654 pub spawnflags: u32,
3655 #[serde(deserialize_with = "deserialize_bool")]
3656 #[serde(default)]
3657 pub startdisabled: bool,
3658 #[serde(default)]
3659 pub targetname: Option<&'a str>,
3660}
3661#[derive(Debug, Clone, Deserialize)]
3662pub struct ShadowControl {
3663 pub angles: Angles,
3664 pub color: Color,
3665 #[serde(deserialize_with = "deserialize_bool")]
3666 #[serde(default)]
3667 pub disableallshadows: bool,
3668 pub distance: u8,
3669 pub origin: Vector,
3670}
3671#[derive(Debug, Clone, Deserialize)]
3672pub struct SkyCamera {
3673 pub angles: Angles,
3674 #[serde(deserialize_with = "deserialize_bool")]
3675 #[serde(default)]
3676 pub fogblend: bool,
3677 pub fogcolor: Color,
3678 pub fogcolor2: Color,
3679 pub fogdir: Vector,
3680 #[serde(deserialize_with = "deserialize_bool")]
3681 #[serde(default)]
3682 pub fogenable: bool,
3683 pub fogend: f32,
3684 #[serde(default)]
3685 pub fogmaxdensity: Option<f32>,
3686 pub fogstart: f32,
3687 pub origin: Vector,
3688 pub scale: u8,
3689 #[serde(deserialize_with = "deserialize_bool")]
3690 #[serde(default)]
3691 pub use_angles: bool,
3692}
3693#[derive(Debug, Clone, Deserialize)]
3694pub struct TriggerGravity<'a> {
3695 pub gravity: f32,
3696 pub model: &'a str,
3697 #[serde(default)]
3698 pub onstarttouch: Option<&'a str>,
3699 pub origin: Vector,
3700 pub spawnflags: u32,
3701 #[serde(deserialize_with = "deserialize_bool")]
3702 pub startdisabled: bool,
3703}
3704#[derive(Debug, Clone, Deserialize)]
3705pub struct TriggerHurt<'a> {
3706 #[serde(default)]
3707 pub angles: Option<Angles>,
3708 pub damage: f32,
3709 pub damagecap: f32,
3710 #[serde(deserialize_with = "deserialize_bool")]
3711 pub damagemodel: bool,
3712 pub damagetype: u16,
3713 pub model: &'a str,
3714 #[serde(deserialize_with = "deserialize_bool")]
3715 #[serde(default)]
3716 pub nodmgforce: bool,
3717 #[serde(default)]
3718 pub onhurtplayer: Option<&'a str>,
3719 #[serde(default)]
3720 pub onstarttouch: Option<&'a str>,
3721 pub origin: Vector,
3722 #[serde(default)]
3723 pub parentname: Option<&'a str>,
3724 pub spawnflags: u32,
3725 #[serde(deserialize_with = "deserialize_bool")]
3726 pub startdisabled: bool,
3727 #[serde(default)]
3728 pub targetname: Option<&'a str>,
3729}
3730#[derive(Debug, Clone, Deserialize)]
3731pub struct TriggerLook<'a> {
3732 pub fieldofview: f32,
3733 pub looktime: u8,
3734 pub model: &'a str,
3735 pub ontrigger: &'a str,
3736 pub origin: Vector,
3737 pub spawnflags: u32,
3738 #[serde(deserialize_with = "deserialize_bool")]
3739 pub startdisabled: bool,
3740 pub target: &'a str,
3741 #[serde(deserialize_with = "deserialize_bool")]
3742 pub timeout: bool,
3743}
3744#[derive(Debug, Clone, Deserialize)]
3745pub struct TriggerMultiple<'a> {
3746 #[serde(default)]
3747 pub angles: Option<Angles>,
3748 #[serde(default)]
3749 pub filtername: Option<&'a str>,
3750 #[serde(default)]
3751 pub model: Option<&'a str>,
3752 #[serde(default)]
3753 pub onendtouch: Option<&'a str>,
3754 #[serde(default)]
3755 pub onendtouchall: Option<&'a str>,
3756 #[serde(default)]
3757 pub onstarttouch: Option<&'a str>,
3758 #[serde(default)]
3759 pub onstarttouchall: Option<&'a str>,
3760 pub ontrigger: &'a str,
3761 pub origin: Vector,
3762 #[serde(default)]
3763 pub parentname: Option<&'a str>,
3764 pub spawnflags: u32,
3765 #[serde(default)]
3766 pub speed: Option<u16>,
3767 #[serde(deserialize_with = "deserialize_bool")]
3768 #[serde(default)]
3769 pub startdisabled: bool,
3770 #[serde(default)]
3771 pub target: Option<&'a str>,
3772 #[serde(default)]
3773 pub targetname: Option<&'a str>,
3774 pub wait: f32,
3775}
3776#[derive(Debug, Clone, Deserialize)]
3777pub struct TriggerOnce<'a> {
3778 #[serde(default)]
3779 pub angles: Option<Angles>,
3780 pub model: &'a str,
3781 #[serde(default)]
3782 pub onstarttouch: Option<&'a str>,
3783 pub ontrigger: &'a str,
3784 pub origin: Vector,
3785 pub spawnflags: u32,
3786 #[serde(deserialize_with = "deserialize_bool")]
3787 pub startdisabled: bool,
3788 #[serde(default)]
3789 pub targetname: Option<&'a str>,
3790 #[serde(default)]
3791 pub wait: Option<i32>,
3792}
3793#[derive(Debug, Clone, Deserialize)]
3794pub struct TriggerProximity<'a> {
3795 pub model: &'a str,
3796 pub onstarttouch: &'a str,
3797 pub origin: Vector,
3798 pub radius: u16,
3799 pub spawnflags: u32,
3800 #[serde(deserialize_with = "deserialize_bool")]
3801 pub startdisabled: bool,
3802}
3803#[derive(Debug, Clone, Deserialize)]
3804pub struct TriggerPush<'a> {
3805 #[serde(deserialize_with = "deserialize_bool")]
3806 #[serde(default)]
3807 pub alternateticksfix: bool,
3808 #[serde(default)]
3809 pub angles: Option<Angles>,
3810 #[serde(default)]
3811 pub filtername: Option<&'a str>,
3812 pub model: &'a str,
3813 #[serde(default)]
3814 pub onendtouch: Option<&'a str>,
3815 #[serde(default)]
3816 pub onstarttouch: Option<&'a str>,
3817 pub origin: Vector,
3818 #[serde(default)]
3819 pub parentname: Option<&'a str>,
3820 pub pushdir: Vector,
3821 pub spawnflags: u32,
3822 pub speed: f32,
3823 #[serde(deserialize_with = "deserialize_bool")]
3824 pub startdisabled: bool,
3825 #[serde(default)]
3826 pub targetname: Option<&'a str>,
3827}
3828#[derive(Debug, Clone, Deserialize)]
3829pub struct TriggerSoundscape<'a> {
3830 #[serde(default)]
3831 pub angles: Option<Angles>,
3832 pub model: &'a str,
3833 #[serde(default)]
3834 pub onstarttouch: Option<&'a str>,
3835 pub origin: Vector,
3836 pub soundscape: &'a str,
3837 pub spawnflags: u32,
3838 #[serde(deserialize_with = "deserialize_bool")]
3839 pub startdisabled: bool,
3840 #[serde(default)]
3841 pub targetname: Option<&'a str>,
3842}
3843#[derive(Debug, Clone, Deserialize)]
3844pub struct TriggerTeleport<'a> {
3845 #[serde(default)]
3846 pub angles: Option<Angles>,
3847 #[serde(default)]
3848 pub filtername: Option<&'a str>,
3849 #[serde(default)]
3850 pub model: Option<&'a str>,
3851 #[serde(default)]
3852 pub onendtouch: Option<&'a str>,
3853 #[serde(default)]
3854 pub onstarttouch: Option<&'a str>,
3855 #[serde(default)]
3856 pub ontrigger: Option<&'a str>,
3857 pub origin: Vector,
3858 #[serde(default)]
3859 pub parentname: Option<&'a str>,
3860 pub spawnflags: u32,
3861 #[serde(default)]
3862 pub speed: Option<u16>,
3863 #[serde(deserialize_with = "deserialize_bool")]
3864 pub startdisabled: bool,
3865 #[serde(default)]
3866 pub target: Option<&'a str>,
3867 #[serde(default)]
3868 pub targetname: Option<&'a str>,
3869}
3870#[derive(Debug, Clone, Deserialize)]
3871pub struct TriggerVphysicsMotion<'a> {
3872 pub model: &'a str,
3873 pub origin: Vector,
3874 pub particletrailendsize: u8,
3875 pub particletraillifetime: u8,
3876 pub particletrailmaterial: &'a str,
3877 pub particletrailstartsize: u8,
3878 #[serde(deserialize_with = "deserialize_bool")]
3879 pub setadditionalairdensity: bool,
3880 pub setangvelocitylimit: f32,
3881 pub setangvelocityscale: f32,
3882 pub setgravityscale: f32,
3883 pub setlinearforce: f32,
3884 pub setlinearforceangles: Angles,
3885 pub setvelocitylimit: f32,
3886 pub setvelocitylimitdelta: f32,
3887 pub setvelocityscale: f32,
3888 pub spawnflags: u32,
3889 #[serde(deserialize_with = "deserialize_bool")]
3890 pub startdisabled: bool,
3891}
3892#[derive(Debug, Clone, Deserialize)]
3893pub struct TriggerWind<'a> {
3894 pub angles: Angles,
3895 pub directionnoise: u8,
3896 #[serde(deserialize_with = "deserialize_bool")]
3897 pub holdnoise: bool,
3898 #[serde(deserialize_with = "deserialize_bool")]
3899 pub holdtime: bool,
3900 pub model: &'a str,
3901 pub origin: Vector,
3902 pub spawnflags: u32,
3903 pub speed: u16,
3904 pub speednoise: u8,
3905 #[serde(deserialize_with = "deserialize_bool")]
3906 pub startdisabled: bool,
3907}
3908#[derive(Debug, Clone, Deserialize)]
3909pub struct WaterLodControl<'a> {
3910 pub cheapwaterenddistance: f32,
3911 pub cheapwaterstartdistance: f32,
3912 #[serde(default)]
3913 pub origin: Option<Vector>,
3914 #[serde(default)]
3915 pub targetname: Option<&'a str>,
3916}
3917#[derive(Debug, Clone, Deserialize)]
3918pub struct WeaponAk47<'a> {
3919 #[serde(default)]
3920 pub _minlight: Option<f32>,
3921 #[serde(default)]
3922 pub ammo: Option<u16>,
3923 pub angles: Angles,
3924 #[serde(default)]
3925 pub onplayerpickup: Option<&'a str>,
3926 pub origin: Vector,
3927 #[serde(default)]
3928 pub renderamt: Option<u8>,
3929 #[serde(default)]
3930 pub rendercolor: Option<Color>,
3931 #[serde(default)]
3932 pub spawnflags: Option<u32>,
3933 #[serde(default)]
3934 pub targetname: Option<&'a str>,
3935}
3936#[derive(Debug, Clone, Deserialize)]
3937pub struct WeaponAwp<'a> {
3938 #[serde(default)]
3939 pub _minlight: Option<f32>,
3940 #[serde(default)]
3941 pub ammo: Option<u16>,
3942 pub angles: Angles,
3943 #[serde(default)]
3944 pub fademaxdist: Option<f32>,
3945 #[serde(default)]
3946 pub fademindist: Option<f32>,
3947 #[serde(default)]
3948 pub fadescale: Option<f32>,
3949 pub origin: Vector,
3950 #[serde(default)]
3951 pub renderamt: Option<u8>,
3952 #[serde(default)]
3953 pub rendercolor: Option<Color>,
3954 #[serde(default)]
3955 pub spawnflags: Option<u32>,
3956 #[serde(default)]
3957 pub targetname: Option<&'a str>,
3958}
3959#[derive(Debug, Clone, Deserialize)]
3960pub struct WeaponDeagle<'a> {
3961 #[serde(default)]
3962 pub _minlight: Option<f32>,
3963 #[serde(default)]
3964 pub ammo: Option<u16>,
3965 pub angles: Angles,
3966 pub origin: Vector,
3967 #[serde(default)]
3968 pub renderamt: Option<u8>,
3969 #[serde(default)]
3970 pub rendercolor: Option<Color>,
3971 #[serde(default)]
3972 pub spawnflags: Option<u32>,
3973 #[serde(default)]
3974 pub targetname: Option<&'a str>,
3975}
3976#[derive(Debug, Clone, Deserialize)]
3977pub struct WeaponElite<'a> {
3978 pub ammo: u16,
3979 pub angles: Angles,
3980 #[serde(default)]
3981 pub fademaxdist: Option<f32>,
3982 #[serde(default)]
3983 pub fademindist: Option<f32>,
3984 #[serde(default)]
3985 pub fadescale: Option<f32>,
3986 pub origin: Vector,
3987 #[serde(default)]
3988 pub renderamt: Option<u8>,
3989 #[serde(default)]
3990 pub rendercolor: Option<Color>,
3991 #[serde(default)]
3992 pub spawnflags: Option<u32>,
3993 #[serde(default)]
3994 pub targetname: Option<&'a str>,
3995}
3996#[derive(Debug, Clone, Deserialize)]
3997pub struct WeaponFamas {
3998 pub ammo: u16,
3999 pub angles: Angles,
4000 pub fademaxdist: f32,
4001 pub fademindist: f32,
4002 pub fadescale: f32,
4003 #[serde(deserialize_with = "deserialize_bool")]
4004 pub maxdxlevel: bool,
4005 #[serde(deserialize_with = "deserialize_bool")]
4006 pub mindxlevel: bool,
4007 #[serde(deserialize_with = "deserialize_bool")]
4008 pub nodamageforces: bool,
4009 pub origin: Vector,
4010 pub renderamt: u8,
4011 pub rendercolor: Color,
4012 #[serde(deserialize_with = "deserialize_bool")]
4013 pub renderfx: bool,
4014 #[serde(deserialize_with = "deserialize_bool")]
4015 pub rendermode: bool,
4016 #[serde(deserialize_with = "deserialize_bool")]
4017 pub shadowcastdist: bool,
4018 pub spawnflags: u32,
4019}
4020#[derive(Debug, Clone, Deserialize)]
4021pub struct WeaponFiveseven<'a> {
4022 pub ammo: u16,
4023 pub angles: Angles,
4024 pub origin: Vector,
4025 pub spawnflags: u32,
4026 pub targetname: &'a str,
4027}
4028#[derive(Debug, Clone, Deserialize)]
4029pub struct WeaponFlashbang<'a> {
4030 pub angles: Angles,
4031 #[serde(default)]
4032 pub fademaxdist: Option<f32>,
4033 #[serde(default)]
4034 pub fademindist: Option<f32>,
4035 #[serde(default)]
4036 pub fadescale: Option<f32>,
4037 pub origin: Vector,
4038 #[serde(default)]
4039 pub renderamt: Option<u8>,
4040 #[serde(default)]
4041 pub rendercolor: Option<Color>,
4042 #[serde(default)]
4043 pub spawnflags: Option<u32>,
4044 pub targetname: &'a str,
4045}
4046#[derive(Debug, Clone, Deserialize)]
4047pub struct WeaponG3sg1 {
4048 pub ammo: u16,
4049 pub angles: Angles,
4050 pub fademaxdist: f32,
4051 pub fademindist: f32,
4052 pub fadescale: f32,
4053 #[serde(deserialize_with = "deserialize_bool")]
4054 pub maxdxlevel: bool,
4055 #[serde(deserialize_with = "deserialize_bool")]
4056 pub mindxlevel: bool,
4057 #[serde(deserialize_with = "deserialize_bool")]
4058 pub nodamageforces: bool,
4059 pub origin: Vector,
4060 pub renderamt: u8,
4061 pub rendercolor: Color,
4062 #[serde(deserialize_with = "deserialize_bool")]
4063 pub renderfx: bool,
4064 #[serde(deserialize_with = "deserialize_bool")]
4065 pub rendermode: bool,
4066 #[serde(deserialize_with = "deserialize_bool")]
4067 pub shadowcastdist: bool,
4068 pub spawnflags: u32,
4069}
4070#[derive(Debug, Clone, Deserialize)]
4071pub struct WeaponGlock<'a> {
4072 #[serde(default)]
4073 pub _minlight: Option<f32>,
4074 pub ammo: u16,
4075 pub angles: Angles,
4076 pub origin: Vector,
4077 #[serde(default)]
4078 pub renderamt: Option<u8>,
4079 #[serde(default)]
4080 pub rendercolor: Option<Color>,
4081 pub spawnflags: u32,
4082 pub targetname: &'a str,
4083}
4084#[derive(Debug, Clone, Deserialize)]
4085pub struct WeaponHegrenade<'a> {
4086 #[serde(default)]
4087 pub _minlight: Option<f32>,
4088 pub angles: Angles,
4089 #[serde(deserialize_with = "deserialize_bool")]
4090 #[serde(default)]
4091 pub disablereceiveshadows: bool,
4092 #[serde(deserialize_with = "deserialize_bool")]
4093 #[serde(default)]
4094 pub disableshadows: bool,
4095 #[serde(default)]
4096 pub fademaxdist: Option<f32>,
4097 #[serde(default)]
4098 pub fademindist: Option<f32>,
4099 #[serde(default)]
4100 pub fadescale: Option<f32>,
4101 #[serde(deserialize_with = "deserialize_bool")]
4102 #[serde(default)]
4103 pub maxdxlevel: bool,
4104 #[serde(deserialize_with = "deserialize_bool")]
4105 #[serde(default)]
4106 pub mindxlevel: bool,
4107 #[serde(deserialize_with = "deserialize_bool")]
4108 #[serde(default)]
4109 pub nodamageforces: bool,
4110 pub origin: Vector,
4111 #[serde(default)]
4112 pub renderamt: Option<u8>,
4113 #[serde(default)]
4114 pub rendercolor: Option<Color>,
4115 #[serde(deserialize_with = "deserialize_bool")]
4116 #[serde(default)]
4117 pub renderfx: bool,
4118 #[serde(deserialize_with = "deserialize_bool")]
4119 #[serde(default)]
4120 pub rendermode: bool,
4121 #[serde(deserialize_with = "deserialize_bool")]
4122 #[serde(default)]
4123 pub shadowcastdist: bool,
4124 #[serde(default)]
4125 pub spawnflags: Option<u32>,
4126 #[serde(default)]
4127 pub targetname: Option<&'a str>,
4128}
4129#[derive(Debug, Clone, Deserialize)]
4130pub struct WeaponKnife<'a> {
4131 #[serde(default)]
4132 pub _minlight: Option<f32>,
4133 pub angles: Angles,
4134 #[serde(default)]
4135 pub onplayerpickup: Option<&'a str>,
4136 pub origin: Vector,
4137 #[serde(default)]
4138 pub renderamt: Option<u8>,
4139 #[serde(default)]
4140 pub rendercolor: Option<Color>,
4141 #[serde(default)]
4142 pub spawnflags: Option<u32>,
4143 #[serde(default)]
4144 pub targetname: Option<&'a str>,
4145}
4146#[derive(Debug, Clone, Deserialize)]
4147pub struct WeaponM249<'a> {
4148 #[serde(default)]
4149 pub _minlight: Option<f32>,
4150 #[serde(default)]
4151 pub ammo: Option<u16>,
4152 pub angles: Angles,
4153 #[serde(default)]
4154 pub fademaxdist: Option<f32>,
4155 #[serde(default)]
4156 pub fademindist: Option<f32>,
4157 #[serde(default)]
4158 pub fadescale: Option<f32>,
4159 pub origin: Vector,
4160 #[serde(default)]
4161 pub renderamt: Option<u8>,
4162 #[serde(default)]
4163 pub rendercolor: Option<Color>,
4164 #[serde(default)]
4165 pub spawnflags: Option<u32>,
4166 #[serde(default)]
4167 pub targetname: Option<&'a str>,
4168}
4169#[derive(Debug, Clone, Deserialize)]
4170pub struct WeaponM3<'a> {
4171 #[serde(default)]
4172 pub _minlight: Option<f32>,
4173 #[serde(default)]
4174 pub ammo: Option<u16>,
4175 pub angles: Angles,
4176 pub origin: Vector,
4177 #[serde(default)]
4178 pub renderamt: Option<u8>,
4179 #[serde(default)]
4180 pub rendercolor: Option<Color>,
4181 #[serde(default)]
4182 pub spawnflags: Option<u32>,
4183 pub targetname: &'a str,
4184}
4185#[derive(Debug, Clone, Deserialize)]
4186pub struct WeaponM4a1<'a> {
4187 #[serde(default)]
4188 pub ammo: Option<u16>,
4189 pub angles: Angles,
4190 #[serde(default)]
4191 pub fademaxdist: Option<f32>,
4192 #[serde(default)]
4193 pub fademindist: Option<f32>,
4194 #[serde(default)]
4195 pub fadescale: Option<f32>,
4196 #[serde(deserialize_with = "deserialize_bool")]
4197 #[serde(default)]
4198 pub maxdxlevel: bool,
4199 #[serde(deserialize_with = "deserialize_bool")]
4200 #[serde(default)]
4201 pub mindxlevel: bool,
4202 #[serde(deserialize_with = "deserialize_bool")]
4203 #[serde(default)]
4204 pub nodamageforces: bool,
4205 pub origin: Vector,
4206 #[serde(default)]
4207 pub renderamt: Option<u8>,
4208 #[serde(default)]
4209 pub rendercolor: Option<Color>,
4210 #[serde(deserialize_with = "deserialize_bool")]
4211 #[serde(default)]
4212 pub renderfx: bool,
4213 #[serde(deserialize_with = "deserialize_bool")]
4214 #[serde(default)]
4215 pub rendermode: bool,
4216 #[serde(deserialize_with = "deserialize_bool")]
4217 #[serde(default)]
4218 pub shadowcastdist: bool,
4219 #[serde(default)]
4220 pub spawnflags: Option<u32>,
4221 #[serde(default)]
4222 pub targetname: Option<&'a str>,
4223}
4224#[derive(Debug, Clone, Deserialize)]
4225pub struct WeaponMac10 {
4226 pub ammo: u16,
4227 pub angles: Angles,
4228 pub fademaxdist: f32,
4229 pub fademindist: f32,
4230 pub fadescale: f32,
4231 #[serde(deserialize_with = "deserialize_bool")]
4232 pub maxdxlevel: bool,
4233 #[serde(deserialize_with = "deserialize_bool")]
4234 pub mindxlevel: bool,
4235 #[serde(deserialize_with = "deserialize_bool")]
4236 pub nodamageforces: bool,
4237 pub origin: Vector,
4238 pub renderamt: u8,
4239 pub rendercolor: Color,
4240 #[serde(deserialize_with = "deserialize_bool")]
4241 pub renderfx: bool,
4242 #[serde(deserialize_with = "deserialize_bool")]
4243 pub rendermode: bool,
4244 #[serde(deserialize_with = "deserialize_bool")]
4245 pub shadowcastdist: bool,
4246 pub spawnflags: u32,
4247}
4248#[derive(Debug, Clone, Deserialize)]
4249pub struct WeaponP228<'a> {
4250 pub ammo: u16,
4251 pub angles: Angles,
4252 pub origin: Vector,
4253 pub spawnflags: u32,
4254 pub targetname: &'a str,
4255}
4256#[derive(Debug, Clone, Deserialize)]
4257pub struct WeaponP90<'a> {
4258 #[serde(default)]
4259 pub ammo: Option<u16>,
4260 pub angles: Angles,
4261 #[serde(default)]
4262 pub fademaxdist: Option<f32>,
4263 #[serde(default)]
4264 pub fademindist: Option<f32>,
4265 #[serde(default)]
4266 pub fadescale: Option<f32>,
4267 #[serde(deserialize_with = "deserialize_bool")]
4268 #[serde(default)]
4269 pub maxdxlevel: bool,
4270 #[serde(deserialize_with = "deserialize_bool")]
4271 #[serde(default)]
4272 pub mindxlevel: bool,
4273 #[serde(deserialize_with = "deserialize_bool")]
4274 #[serde(default)]
4275 pub nodamageforces: bool,
4276 pub origin: Vector,
4277 #[serde(default)]
4278 pub renderamt: Option<u8>,
4279 #[serde(default)]
4280 pub rendercolor: Option<Color>,
4281 #[serde(deserialize_with = "deserialize_bool")]
4282 #[serde(default)]
4283 pub renderfx: bool,
4284 #[serde(deserialize_with = "deserialize_bool")]
4285 #[serde(default)]
4286 pub rendermode: bool,
4287 #[serde(deserialize_with = "deserialize_bool")]
4288 #[serde(default)]
4289 pub shadowcastdist: bool,
4290 pub spawnflags: u32,
4291 #[serde(default)]
4292 pub targetname: Option<&'a str>,
4293}
4294#[derive(Debug, Clone, Deserialize)]
4295pub struct WeaponScout<'a> {
4296 #[serde(default)]
4297 pub _minlight: Option<f32>,
4298 #[serde(default)]
4299 pub ammo: Option<u16>,
4300 pub angles: Angles,
4301 #[serde(deserialize_with = "deserialize_bool")]
4302 #[serde(default)]
4303 pub disablereceiveshadows: bool,
4304 #[serde(deserialize_with = "deserialize_bool")]
4305 #[serde(default)]
4306 pub disableshadows: bool,
4307 #[serde(default)]
4308 pub fademaxdist: Option<f32>,
4309 #[serde(default)]
4310 pub fademindist: Option<f32>,
4311 #[serde(default)]
4312 pub fadescale: Option<f32>,
4313 #[serde(default)]
4314 pub onplayerpickup: Option<&'a str>,
4315 pub origin: Vector,
4316 #[serde(default)]
4317 pub renderamt: Option<u8>,
4318 #[serde(default)]
4319 pub rendercolor: Option<Color>,
4320 #[serde(default)]
4321 pub renderfx: Option<u8>,
4322 #[serde(default)]
4323 pub rendermode: Option<u8>,
4324 #[serde(default)]
4325 pub spawnflags: Option<u32>,
4326 #[serde(default)]
4327 pub targetname: Option<&'a str>,
4328}
4329#[derive(Debug, Clone, Deserialize)]
4330pub struct WeaponSg550 {
4331 pub ammo: u16,
4332 pub angles: Angles,
4333 pub fademaxdist: f32,
4334 pub fademindist: f32,
4335 pub fadescale: f32,
4336 #[serde(deserialize_with = "deserialize_bool")]
4337 pub maxdxlevel: bool,
4338 #[serde(deserialize_with = "deserialize_bool")]
4339 pub mindxlevel: bool,
4340 #[serde(deserialize_with = "deserialize_bool")]
4341 pub nodamageforces: bool,
4342 pub origin: Vector,
4343 pub renderamt: u8,
4344 pub rendercolor: Color,
4345 #[serde(deserialize_with = "deserialize_bool")]
4346 pub renderfx: bool,
4347 #[serde(deserialize_with = "deserialize_bool")]
4348 pub rendermode: bool,
4349 #[serde(deserialize_with = "deserialize_bool")]
4350 pub shadowcastdist: bool,
4351 pub spawnflags: u32,
4352}
4353#[derive(Debug, Clone, Deserialize)]
4354pub struct WeaponSmokegrenade<'a> {
4355 pub angles: Angles,
4356 pub origin: Vector,
4357 #[serde(default)]
4358 pub spawnflags: Option<u32>,
4359 pub targetname: &'a str,
4360}
4361#[derive(Debug, Clone, Deserialize)]
4362pub struct WeaponTmp {
4363 pub ammo: u16,
4364 pub angles: Angles,
4365 pub fademaxdist: f32,
4366 pub fademindist: f32,
4367 pub fadescale: f32,
4368 #[serde(deserialize_with = "deserialize_bool")]
4369 pub maxdxlevel: bool,
4370 #[serde(deserialize_with = "deserialize_bool")]
4371 pub mindxlevel: bool,
4372 #[serde(deserialize_with = "deserialize_bool")]
4373 pub nodamageforces: bool,
4374 pub origin: Vector,
4375 pub renderamt: u8,
4376 pub rendercolor: Color,
4377 #[serde(deserialize_with = "deserialize_bool")]
4378 pub renderfx: bool,
4379 #[serde(deserialize_with = "deserialize_bool")]
4380 pub rendermode: bool,
4381 #[serde(deserialize_with = "deserialize_bool")]
4382 pub shadowcastdist: bool,
4383 pub spawnflags: u32,
4384}
4385#[derive(Debug, Clone, Deserialize)]
4386pub struct WeaponUmp45<'a> {
4387 pub ammo: u16,
4388 pub angles: Angles,
4389 #[serde(default)]
4390 pub fademaxdist: Option<f32>,
4391 #[serde(default)]
4392 pub fademindist: Option<f32>,
4393 #[serde(default)]
4394 pub fadescale: Option<f32>,
4395 #[serde(deserialize_with = "deserialize_bool")]
4396 #[serde(default)]
4397 pub maxdxlevel: bool,
4398 #[serde(deserialize_with = "deserialize_bool")]
4399 #[serde(default)]
4400 pub mindxlevel: bool,
4401 #[serde(deserialize_with = "deserialize_bool")]
4402 #[serde(default)]
4403 pub nodamageforces: bool,
4404 pub origin: Vector,
4405 #[serde(default)]
4406 pub renderamt: Option<u8>,
4407 #[serde(default)]
4408 pub rendercolor: Option<Color>,
4409 #[serde(deserialize_with = "deserialize_bool")]
4410 #[serde(default)]
4411 pub renderfx: bool,
4412 #[serde(deserialize_with = "deserialize_bool")]
4413 #[serde(default)]
4414 pub rendermode: bool,
4415 #[serde(deserialize_with = "deserialize_bool")]
4416 #[serde(default)]
4417 pub shadowcastdist: bool,
4418 pub spawnflags: u32,
4419 #[serde(default)]
4420 pub targetname: Option<&'a str>,
4421}
4422#[derive(Debug, Clone, Deserialize)]
4423pub struct WeaponUsp<'a> {
4424 #[serde(default)]
4425 pub _minlight: Option<f32>,
4426 #[serde(default)]
4427 pub ammo: Option<u16>,
4428 pub angles: Angles,
4429 #[serde(default)]
4430 pub onplayerpickup: Option<&'a str>,
4431 pub origin: Vector,
4432 #[serde(default)]
4433 pub renderamt: Option<u8>,
4434 #[serde(default)]
4435 pub rendercolor: Option<Color>,
4436 pub spawnflags: u32,
4437 pub targetname: &'a str,
4438}
4439#[derive(Debug, Clone, Deserialize)]
4440pub struct WeaponXm1014<'a> {
4441 pub ammo: u32,
4442 pub angles: Angles,
4443 #[serde(default)]
4444 pub fademaxdist: Option<f32>,
4445 #[serde(default)]
4446 pub fademindist: Option<f32>,
4447 #[serde(default)]
4448 pub fadescale: Option<f32>,
4449 #[serde(deserialize_with = "deserialize_bool")]
4450 #[serde(default)]
4451 pub maxdxlevel: bool,
4452 #[serde(deserialize_with = "deserialize_bool")]
4453 #[serde(default)]
4454 pub mindxlevel: bool,
4455 #[serde(deserialize_with = "deserialize_bool")]
4456 #[serde(default)]
4457 pub nodamageforces: bool,
4458 pub origin: Vector,
4459 #[serde(default)]
4460 pub renderamt: Option<u8>,
4461 #[serde(default)]
4462 pub rendercolor: Option<Color>,
4463 #[serde(deserialize_with = "deserialize_bool")]
4464 #[serde(default)]
4465 pub renderfx: bool,
4466 #[serde(deserialize_with = "deserialize_bool")]
4467 #[serde(default)]
4468 pub rendermode: bool,
4469 #[serde(deserialize_with = "deserialize_bool")]
4470 #[serde(default)]
4471 pub shadowcastdist: bool,
4472 pub spawnflags: u32,
4473 #[serde(default)]
4474 pub targetname: Option<&'a str>,
4475}
4476#[derive(Debug, Clone, Deserialize)]
4477pub struct Worldspawn<'a> {
4478 #[serde(default)]
4479 pub _minlight: Option<f32>,
4480 #[serde(default)]
4481 pub chaptertitle: Option<&'a str>,
4482 #[serde(deserialize_with = "deserialize_bool")]
4483 #[serde(default)]
4484 pub coldworld: bool,
4485 #[serde(default)]
4486 pub comment: Option<&'a str>,
4487 #[serde(default)]
4488 pub csg_options: Option<&'a str>,
4489 #[serde(deserialize_with = "deserialize_bool")]
4490 #[serde(default)]
4491 pub defaultteam: bool,
4492 #[serde(default)]
4493 pub detailmaterial: Option<&'a str>,
4494 #[serde(default)]
4495 pub detailvbsp: Option<&'a str>,
4496 #[serde(default)]
4497 pub fogcolor: Option<Color>,
4498 #[serde(default)]
4499 pub fogcolor2: Option<Color>,
4500 #[serde(default)]
4501 pub fogdir: Option<Vector>,
4502 #[serde(deserialize_with = "deserialize_bool")]
4503 #[serde(default)]
4504 pub fogenable: bool,
4505 #[serde(default)]
4506 pub fogend: Option<f32>,
4507 #[serde(default)]
4508 pub fogstart: Option<u16>,
4509 #[serde(deserialize_with = "deserialize_bool")]
4510 #[serde(default)]
4511 pub gametitle: bool,
4512 #[serde(default)]
4513 pub light: Option<u8>,
4514 #[serde(default)]
4515 pub mapversion: Option<u16>,
4516 #[serde(default)]
4517 pub maxoccludeearea: Option<f32>,
4518 pub maxpropscreenwidth: f32,
4519 #[serde(default)]
4520 pub maxrange: Option<u16>,
4521 #[serde(default)]
4522 pub message: Option<&'a str>,
4523 #[serde(default)]
4524 pub minoccluderarea: Option<f32>,
4525 #[serde(default)]
4526 pub minpropscreenwidth: Option<f32>,
4527 #[serde(deserialize_with = "deserialize_bool")]
4528 #[serde(default)]
4529 pub newunit: bool,
4530 #[serde(deserialize_with = "deserialize_bool")]
4531 #[serde(default)]
4532 pub no_decomp: bool,
4533 pub skyname: &'a str,
4534 #[serde(deserialize_with = "deserialize_bool")]
4535 #[serde(default)]
4536 pub sounds: bool,
4537 #[serde(default)]
4538 pub spawnflags: Option<u32>,
4539 #[serde(deserialize_with = "deserialize_bool")]
4540 #[serde(default)]
4541 pub startdark: bool,
4542 #[serde(default)]
4543 pub waveheight: Option<f32>,
4544 pub world_maxs: Vector,
4545 pub world_mins: Vector,
4546 #[serde(deserialize_with = "deserialize_bool")]
4547 #[serde(default)]
4548 pub worldtype: bool,
4549}