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