1use serde::Deserialize;
2use vbsp_common::deserialize_bool;
3use vbsp_common::{Angles, Color, LightColor, Negated, Vector};
4#[derive(Debug, Clone, Deserialize)]
5#[non_exhaustive]
6#[serde(tag = "classname")]
7pub enum Entity<'a> {
8 #[serde(rename = "ambient_generic")]
9 #[serde(borrow)]
10 AmbientGeneric(AmbientGeneric<'a>),
11 #[serde(rename = "base_boss")]
12 #[serde(borrow)]
13 BaseBoss(BaseBoss<'a>),
14 #[serde(rename = "bot_action_point")]
15 #[serde(borrow)]
16 BotActionPoint(BotActionPoint<'a>),
17 #[serde(rename = "bot_generator")]
18 #[serde(borrow)]
19 BotGenerator(BotGenerator<'a>),
20 #[serde(rename = "bot_hint_engineer_nest")]
21 #[serde(borrow)]
22 BotHintEngineerNest(BotHintEngineerNest<'a>),
23 #[serde(rename = "bot_hint_sentrygun")]
24 #[serde(borrow)]
25 BotHintSentrygun(BotHintSentrygun<'a>),
26 #[serde(rename = "bot_hint_sniper_spot")]
27 #[serde(borrow)]
28 BotHintSniperSpot(BotHintSniperSpot<'a>),
29 #[serde(rename = "bot_hint_teleporter_exit")]
30 #[serde(borrow)]
31 BotHintTeleporterExit(BotHintTeleporterExit<'a>),
32 #[serde(rename = "bot_roster")]
33 #[serde(borrow)]
34 BotRoster(BotRoster<'a>),
35 #[serde(rename = "color_correction")]
36 #[serde(borrow)]
37 ColorCorrection(ColorCorrection<'a>),
38 #[serde(rename = "dispenser_touch_trigger")]
39 #[serde(borrow)]
40 DispenserTouchTrigger(DispenserTouchTrigger<'a>),
41 #[serde(rename = "editor_text")]
42 #[serde(borrow)]
43 EditorText(EditorText<'a>),
44 #[serde(rename = "entity_spawn_manager")]
45 #[serde(borrow)]
46 EntitySpawnManager(EntitySpawnManager<'a>),
47 #[serde(rename = "entity_spawn_point")]
48 #[serde(borrow)]
49 EntitySpawnPoint(EntitySpawnPoint<'a>),
50 #[serde(rename = "env_beam")]
51 #[serde(borrow)]
52 EnvBeam(EnvBeam<'a>),
53 #[serde(rename = "env_bubbles")]
54 #[serde(borrow)]
55 EnvBubbles(EnvBubbles<'a>),
56 #[serde(rename = "env_entity_maker")]
57 #[serde(borrow)]
58 EnvEntityMaker(EnvEntityMaker<'a>),
59 #[serde(rename = "env_explosion")]
60 #[serde(borrow)]
61 EnvExplosion(EnvExplosion<'a>),
62 #[serde(rename = "env_fade")]
63 #[serde(borrow)]
64 EnvFade(EnvFade<'a>),
65 #[serde(rename = "env_fog_controller")]
66 #[serde(borrow)]
67 EnvFogController(EnvFogController<'a>),
68 #[serde(rename = "env_glow")]
69 #[serde(borrow)]
70 EnvGlow(EnvGlow<'a>),
71 #[serde(rename = "env_laser")]
72 #[serde(borrow)]
73 EnvLaser(EnvLaser<'a>),
74 #[serde(rename = "env_lightglow")]
75 #[serde(borrow)]
76 EnvLightglow(EnvLightglow<'a>),
77 #[serde(rename = "env_physexplosion")]
78 #[serde(borrow)]
79 EnvPhysexplosion(EnvPhysexplosion<'a>),
80 #[serde(rename = "env_screenoverlay")]
81 #[serde(borrow)]
82 EnvScreenoverlay(EnvScreenoverlay<'a>),
83 #[serde(rename = "env_shake")]
84 #[serde(borrow)]
85 EnvShake(EnvShake<'a>),
86 #[serde(rename = "env_shooter")]
87 #[serde(borrow)]
88 EnvShooter(EnvShooter<'a>),
89 #[serde(rename = "env_smokestack")]
90 #[serde(borrow)]
91 EnvSmokestack(EnvSmokestack<'a>),
92 #[serde(rename = "env_soundscape")]
93 #[serde(borrow)]
94 EnvSoundscape(EnvSoundscape<'a>),
95 #[serde(rename = "env_soundscape_proxy")]
96 #[serde(borrow)]
97 EnvSoundscapeProxy(EnvSoundscapeProxy<'a>),
98 #[serde(rename = "env_soundscape_triggerable")]
99 #[serde(borrow)]
100 EnvSoundscapeTriggerable(EnvSoundscapeTriggerable<'a>),
101 #[serde(rename = "env_spark")]
102 #[serde(borrow)]
103 EnvSpark(EnvSpark<'a>),
104 #[serde(rename = "env_sprite")]
105 #[serde(borrow)]
106 EnvSprite(EnvSprite<'a>),
107 #[serde(rename = "env_steam")]
108 #[serde(borrow)]
109 EnvSteam(EnvSteam<'a>),
110 #[serde(rename = "env_sun")]
111 #[serde(borrow)]
112 EnvSun(EnvSun<'a>),
113 #[serde(rename = "env_texturetoggle")]
114 #[serde(borrow)]
115 EnvTexturetoggle(EnvTexturetoggle<'a>),
116 #[serde(rename = "env_tonemap_controller")]
117 #[serde(borrow)]
118 EnvTonemapController(EnvTonemapController<'a>),
119 #[serde(rename = "env_wind")]
120 #[serde(borrow)]
121 EnvWind(EnvWind<'a>),
122 #[serde(rename = "eyeball_boss")]
123 #[serde(borrow)]
124 EyeballBoss(EyeballBoss<'a>),
125 #[serde(rename = "filter_activator_class")]
126 #[serde(borrow)]
127 FilterActivatorClass(FilterActivatorClass<'a>),
128 #[serde(rename = "filter_activator_name")]
129 #[serde(borrow)]
130 FilterActivatorName(FilterActivatorName<'a>),
131 #[serde(rename = "filter_activator_team")]
132 #[serde(borrow)]
133 FilterActivatorTeam(FilterActivatorTeam<'a>),
134 #[serde(rename = "filter_activator_tfteam")]
135 #[serde(borrow)]
136 FilterActivatorTfteam(FilterActivatorTfteam<'a>),
137 #[serde(rename = "filter_base")]
138 #[serde(borrow)]
139 FilterBase(FilterBase<'a>),
140 #[serde(rename = "filter_damage_type")]
141 #[serde(borrow)]
142 FilterDamageType(FilterDamageType<'a>),
143 #[serde(rename = "filter_multi")]
144 #[serde(borrow)]
145 FilterMulti(FilterMulti<'a>),
146 #[serde(rename = "filter_tf_bot_has_tag")]
147 #[serde(borrow)]
148 FilterTfBotHasTag(FilterTfBotHasTag<'a>),
149 #[serde(rename = "filter_tf_class")]
150 #[serde(borrow)]
151 FilterTfClass(FilterTfClass<'a>),
152 #[serde(rename = "filter_tf_condition")]
153 #[serde(borrow)]
154 FilterTfCondition(FilterTfCondition<'a>),
155 #[serde(rename = "filter_tf_damaged_by_weapon_in_slot")]
156 #[serde(borrow)]
157 FilterTfDamagedByWeaponInSlot(FilterTfDamagedByWeaponInSlot<'a>),
158 #[serde(rename = "func_achievement")]
159 #[serde(borrow)]
160 FuncAchievement(FuncAchievement<'a>),
161 #[serde(rename = "func_areaportal")]
162 #[serde(borrow)]
163 FuncAreaportal(FuncAreaportal<'a>),
164 #[serde(rename = "func_areaportalwindow")]
165 #[serde(borrow)]
166 FuncAreaportalwindow(FuncAreaportalwindow<'a>),
167 #[serde(rename = "func_breakable")]
168 #[serde(borrow)]
169 FuncBreakable(FuncBreakable<'a>),
170 #[serde(rename = "func_brush")]
171 #[serde(borrow)]
172 FuncBrush(FuncBrush<'a>),
173 #[serde(rename = "func_button")]
174 #[serde(borrow)]
175 FuncButton(FuncButton<'a>),
176 #[serde(rename = "func_capturezone")]
177 #[serde(borrow)]
178 FuncCapturezone(FuncCapturezone<'a>),
179 #[serde(rename = "func_clip_vphysics")]
180 #[serde(borrow)]
181 FuncClipVphysics(FuncClipVphysics<'a>),
182 #[serde(rename = "func_croc")]
183 #[serde(borrow)]
184 FuncCroc(FuncCroc<'a>),
185 #[serde(rename = "func_detail_blocker")]
186 #[serde(borrow)]
187 FuncDetailBlocker(FuncDetailBlocker<'a>),
188 #[serde(rename = "func_door")]
189 #[serde(borrow)]
190 FuncDoor(FuncDoor<'a>),
191 #[serde(rename = "func_door_rotating")]
192 #[serde(borrow)]
193 FuncDoorRotating(FuncDoorRotating<'a>),
194 #[serde(rename = "func_dustcloud")]
195 #[serde(borrow)]
196 FuncDustcloud(FuncDustcloud<'a>),
197 #[serde(rename = "func_dustmotes")]
198 #[serde(borrow)]
199 FuncDustmotes(FuncDustmotes<'a>),
200 #[serde(rename = "func_fish_pool")]
201 #[serde(borrow)]
202 FuncFishPool(FuncFishPool<'a>),
203 #[serde(rename = "func_flag_alert")]
204 #[serde(borrow)]
205 FuncFlagAlert(FuncFlagAlert<'a>),
206 #[serde(rename = "func_flagdetectionzone")]
207 #[serde(borrow)]
208 FuncFlagdetectionzone(FuncFlagdetectionzone<'a>),
209 #[serde(rename = "func_illusionary")]
210 #[serde(borrow)]
211 FuncIllusionary(FuncIllusionary<'a>),
212 #[serde(rename = "func_lod")]
213 #[serde(borrow)]
214 FuncLod(FuncLod<'a>),
215 #[serde(rename = "func_monitor")]
216 #[serde(borrow)]
217 FuncMonitor(FuncMonitor<'a>),
218 #[serde(rename = "func_movelinear")]
219 #[serde(borrow)]
220 FuncMovelinear(FuncMovelinear<'a>),
221 #[serde(rename = "func_nav_avoid")]
222 #[serde(borrow)]
223 FuncNavAvoid(FuncNavAvoid<'a>),
224 #[serde(rename = "func_nav_blocker")]
225 #[serde(borrow)]
226 FuncNavBlocker(FuncNavBlocker<'a>),
227 #[serde(rename = "func_nav_prefer")]
228 #[serde(borrow)]
229 FuncNavPrefer(FuncNavPrefer<'a>),
230 #[serde(rename = "func_nav_prerequisite")]
231 #[serde(borrow)]
232 FuncNavPrerequisite(FuncNavPrerequisite<'a>),
233 #[serde(rename = "func_nobuild")]
234 #[serde(borrow)]
235 FuncNobuild(FuncNobuild<'a>),
236 #[serde(rename = "func_nogrenades")]
237 #[serde(borrow)]
238 FuncNogrenades(FuncNogrenades<'a>),
239 #[serde(rename = "func_occluder")]
240 #[serde(borrow)]
241 FuncOccluder(FuncOccluder<'a>),
242 #[serde(rename = "func_passtime_goal")]
243 #[serde(borrow)]
244 FuncPasstimeGoal(FuncPasstimeGoal<'a>),
245 #[serde(rename = "func_passtime_goalie_zone")]
246 #[serde(borrow)]
247 FuncPasstimeGoalieZone(FuncPasstimeGoalieZone<'a>),
248 #[serde(rename = "func_passtime_no_ball_zone")]
249 #[serde(borrow)]
250 FuncPasstimeNoBallZone(FuncPasstimeNoBallZone<'a>),
251 #[serde(rename = "func_physbox")]
252 #[serde(borrow)]
253 FuncPhysbox(FuncPhysbox<'a>),
254 #[serde(rename = "func_physbox_multiplayer")]
255 #[serde(borrow)]
256 FuncPhysboxMultiplayer(FuncPhysboxMultiplayer<'a>),
257 #[serde(rename = "func_powerupvolume")]
258 #[serde(borrow)]
259 FuncPowerupvolume(FuncPowerupvolume<'a>),
260 #[serde(rename = "func_precipitation")]
261 #[serde(borrow)]
262 FuncPrecipitation(FuncPrecipitation<'a>),
263 #[serde(rename = "func_regenerate")]
264 #[serde(borrow)]
265 FuncRegenerate(FuncRegenerate<'a>),
266 #[serde(rename = "func_respawnflag")]
267 #[serde(borrow)]
268 FuncRespawnflag(FuncRespawnflag<'a>),
269 #[serde(rename = "func_respawnroom")]
270 #[serde(borrow)]
271 FuncRespawnroom(FuncRespawnroom<'a>),
272 #[serde(rename = "func_respawnroomvisualizer")]
273 #[serde(borrow)]
274 FuncRespawnroomvisualizer(FuncRespawnroomvisualizer<'a>),
275 #[serde(rename = "func_rotating")]
276 #[serde(borrow)]
277 FuncRotating(FuncRotating<'a>),
278 #[serde(rename = "func_smokevolume")]
279 #[serde(borrow)]
280 FuncSmokevolume(FuncSmokevolume<'a>),
281 #[serde(rename = "func_suggested_build")]
282 #[serde(borrow)]
283 FuncSuggestedBuild(FuncSuggestedBuild<'a>),
284 #[serde(rename = "func_tanktrain")]
285 #[serde(borrow)]
286 FuncTanktrain(FuncTanktrain<'a>),
287 #[serde(rename = "func_tfbot_hint")]
288 #[serde(borrow)]
289 FuncTfbotHint(FuncTfbotHint<'a>),
290 #[serde(rename = "func_tracktrain")]
291 #[serde(borrow)]
292 FuncTracktrain(FuncTracktrain<'a>),
293 #[serde(rename = "func_upgradestation")]
294 #[serde(borrow)]
295 FuncUpgradestation(FuncUpgradestation<'a>),
296 #[serde(rename = "func_wall")]
297 #[serde(borrow)]
298 FuncWall(FuncWall<'a>),
299 #[serde(rename = "func_wall_toggle")]
300 #[serde(borrow)]
301 FuncWallToggle(FuncWallToggle<'a>),
302 #[serde(rename = "func_water_analog")]
303 #[serde(borrow)]
304 FuncWaterAnalog(FuncWaterAnalog<'a>),
305 #[serde(rename = "game_end")]
306 #[serde(borrow)]
307 GameEnd(GameEnd<'a>),
308 #[serde(rename = "game_forcerespawn")]
309 #[serde(borrow)]
310 GameForcerespawn(GameForcerespawn<'a>),
311 #[serde(rename = "game_intro_viewpoint")]
312 #[serde(borrow)]
313 GameIntroViewpoint(GameIntroViewpoint<'a>),
314 #[serde(rename = "game_round_win")]
315 #[serde(borrow)]
316 GameRoundWin(GameRoundWin<'a>),
317 #[serde(rename = "game_text")]
318 #[serde(borrow)]
319 GameText(GameText<'a>),
320 #[serde(rename = "game_text_tf")]
321 #[serde(borrow)]
322 GameTextTf(GameTextTf<'a>),
323 #[serde(rename = "halloween_fortune_teller")]
324 #[serde(borrow)]
325 HalloweenFortuneTeller(HalloweenFortuneTeller<'a>),
326 #[serde(rename = "halloween_zapper")]
327 #[serde(borrow)]
328 HalloweenZapper(HalloweenZapper<'a>),
329 #[serde(rename = "headless_hatman")]
330 #[serde(borrow)]
331 HeadlessHatman(HeadlessHatman<'a>),
332 #[serde(rename = "info_camera_link")]
333 #[serde(borrow)]
334 InfoCameraLink(InfoCameraLink<'a>),
335 #[serde(rename = "info_intermission")]
336 #[serde(borrow)]
337 InfoIntermission(InfoIntermission<'a>),
338 #[serde(rename = "info_landmark")]
339 #[serde(borrow)]
340 InfoLandmark(InfoLandmark<'a>),
341 #[serde(rename = "info_null")]
342 #[serde(borrow)]
343 InfoNull(InfoNull<'a>),
344 #[serde(rename = "info_observer_point")]
345 #[serde(borrow)]
346 InfoObserverPoint(InfoObserverPoint<'a>),
347 #[serde(rename = "info_overlay_accessor")]
348 #[serde(borrow)]
349 InfoOverlayAccessor(InfoOverlayAccessor<'a>),
350 #[serde(rename = "info_particle_system")]
351 #[serde(borrow)]
352 InfoParticleSystem(InfoParticleSystem<'a>),
353 #[serde(rename = "info_passtime_ball_spawn")]
354 #[serde(borrow)]
355 InfoPasstimeBallSpawn(InfoPasstimeBallSpawn<'a>),
356 #[serde(rename = "info_player_start")]
357 InfoPlayerStart(InfoPlayerStart),
358 #[serde(rename = "info_player_teamspawn")]
359 #[serde(borrow)]
360 InfoPlayerTeamspawn(InfoPlayerTeamspawn<'a>),
361 #[serde(rename = "info_powerup_spawn")]
362 InfoPowerupSpawn(InfoPowerupSpawn),
363 #[serde(rename = "info_target")]
364 #[serde(borrow)]
365 InfoTarget(InfoTarget<'a>),
366 #[serde(rename = "info_teleport_destination")]
367 #[serde(borrow)]
368 InfoTeleportDestination(InfoTeleportDestination<'a>),
369 #[serde(rename = "infodecal")]
370 #[serde(borrow)]
371 Infodecal(Infodecal<'a>),
372 #[serde(rename = "item_ammopack_full")]
373 #[serde(borrow)]
374 ItemAmmopackFull(ItemAmmopackFull<'a>),
375 #[serde(rename = "item_ammopack_medium")]
376 #[serde(borrow)]
377 ItemAmmopackMedium(ItemAmmopackMedium<'a>),
378 #[serde(rename = "item_ammopack_small")]
379 #[serde(borrow)]
380 ItemAmmopackSmall(ItemAmmopackSmall<'a>),
381 #[serde(rename = "item_healthammokit")]
382 ItemHealthammokit(ItemHealthammokit),
383 #[serde(rename = "item_healthkit_full")]
384 #[serde(borrow)]
385 ItemHealthkitFull(ItemHealthkitFull<'a>),
386 #[serde(rename = "item_healthkit_medium")]
387 #[serde(borrow)]
388 ItemHealthkitMedium(ItemHealthkitMedium<'a>),
389 #[serde(rename = "item_healthkit_small")]
390 #[serde(borrow)]
391 ItemHealthkitSmall(ItemHealthkitSmall<'a>),
392 #[serde(rename = "item_teamflag")]
393 #[serde(borrow)]
394 ItemTeamflag(ItemTeamflag<'a>),
395 #[serde(rename = "keyframe_rope")]
396 #[serde(borrow)]
397 KeyframeRope(KeyframeRope<'a>),
398 #[serde(rename = "light")]
399 #[serde(borrow)]
400 Light(Light<'a>),
401 #[serde(rename = "light_environment")]
402 #[serde(borrow)]
403 LightEnvironment(LightEnvironment<'a>),
404 #[serde(rename = "light_spot")]
405 #[serde(borrow)]
406 LightSpot(LightSpot<'a>),
407 #[serde(rename = "logic_auto")]
408 #[serde(borrow)]
409 LogicAuto(LogicAuto<'a>),
410 #[serde(rename = "logic_branch")]
411 #[serde(borrow)]
412 LogicBranch(LogicBranch<'a>),
413 #[serde(rename = "logic_branch_listener")]
414 #[serde(borrow)]
415 LogicBranchListener(LogicBranchListener<'a>),
416 #[serde(rename = "logic_case")]
417 #[serde(borrow)]
418 LogicCase(LogicCase<'a>),
419 #[serde(rename = "logic_collision_pair")]
420 #[serde(borrow)]
421 LogicCollisionPair(LogicCollisionPair<'a>),
422 #[serde(rename = "logic_compare")]
423 #[serde(borrow)]
424 LogicCompare(LogicCompare<'a>),
425 #[serde(rename = "logic_measure_movement")]
426 #[serde(borrow)]
427 LogicMeasureMovement(LogicMeasureMovement<'a>),
428 #[serde(rename = "logic_relay")]
429 #[serde(borrow)]
430 LogicRelay(LogicRelay<'a>),
431 #[serde(rename = "logic_script")]
432 #[serde(borrow)]
433 LogicScript(LogicScript<'a>),
434 #[serde(rename = "logic_timer")]
435 #[serde(borrow)]
436 LogicTimer(LogicTimer<'a>),
437 #[serde(rename = "mapobj_cart_dispenser")]
438 #[serde(borrow)]
439 MapobjCartDispenser(MapobjCartDispenser<'a>),
440 #[serde(rename = "material_modify_control")]
441 MaterialModifyControl(MaterialModifyControl),
442 #[serde(rename = "math_counter")]
443 #[serde(borrow)]
444 MathCounter(MathCounter<'a>),
445 #[serde(rename = "math_remap")]
446 #[serde(borrow)]
447 MathRemap(MathRemap<'a>),
448 #[serde(rename = "merasmus")]
449 #[serde(borrow)]
450 Merasmus(Merasmus<'a>),
451 #[serde(rename = "momentary_rot_button")]
452 #[serde(borrow)]
453 MomentaryRotButton(MomentaryRotButton<'a>),
454 #[serde(rename = "move_rope")]
455 #[serde(borrow)]
456 MoveRope(MoveRope<'a>),
457 #[serde(rename = "obj_dispenser")]
458 #[serde(borrow)]
459 ObjDispenser(ObjDispenser<'a>),
460 #[serde(rename = "obj_sentrygun")]
461 #[serde(borrow)]
462 ObjSentrygun(ObjSentrygun<'a>),
463 #[serde(rename = "obj_teleporter")]
464 #[serde(borrow)]
465 ObjTeleporter(ObjTeleporter<'a>),
466 #[serde(rename = "passtime_logic")]
467 #[serde(borrow)]
468 PasstimeLogic(PasstimeLogic<'a>),
469 #[serde(rename = "path_corner")]
470 #[serde(borrow)]
471 PathCorner(PathCorner<'a>),
472 #[serde(rename = "path_track")]
473 #[serde(borrow)]
474 PathTrack(PathTrack<'a>),
475 #[serde(rename = "phys_constraint")]
476 #[serde(borrow)]
477 PhysConstraint(PhysConstraint<'a>),
478 #[serde(rename = "phys_hinge")]
479 #[serde(borrow)]
480 PhysHinge(PhysHinge<'a>),
481 #[serde(rename = "phys_ragdollmagnet")]
482 #[serde(borrow)]
483 PhysRagdollmagnet(PhysRagdollmagnet<'a>),
484 #[serde(rename = "phys_thruster")]
485 #[serde(borrow)]
486 PhysThruster(PhysThruster<'a>),
487 #[serde(rename = "point_camera")]
488 #[serde(borrow)]
489 PointCamera(PointCamera<'a>),
490 #[serde(rename = "point_clientcommand")]
491 #[serde(borrow)]
492 PointClientcommand(PointClientcommand<'a>),
493 #[serde(rename = "point_devshot_camera")]
494 #[serde(borrow)]
495 PointDevshotCamera(PointDevshotCamera<'a>),
496 #[serde(rename = "point_hurt")]
497 #[serde(borrow)]
498 PointHurt(PointHurt<'a>),
499 #[serde(rename = "point_populator_interface")]
500 #[serde(borrow)]
501 PointPopulatorInterface(PointPopulatorInterface<'a>),
502 #[serde(rename = "point_push")]
503 #[serde(borrow)]
504 PointPush(PointPush<'a>),
505 #[serde(rename = "point_servercommand")]
506 #[serde(borrow)]
507 PointServercommand(PointServercommand<'a>),
508 #[serde(rename = "point_spotlight")]
509 #[serde(borrow)]
510 PointSpotlight(PointSpotlight<'a>),
511 #[serde(rename = "point_teleport")]
512 #[serde(borrow)]
513 PointTeleport(PointTeleport<'a>),
514 #[serde(rename = "point_template")]
515 #[serde(borrow)]
516 PointTemplate(PointTemplate<'a>),
517 #[serde(rename = "point_tesla")]
518 #[serde(borrow)]
519 PointTesla(PointTesla<'a>),
520 #[serde(rename = "point_viewcontrol")]
521 #[serde(borrow)]
522 PointViewcontrol(PointViewcontrol<'a>),
523 #[serde(rename = "prop_door_rotating")]
524 #[serde(borrow)]
525 PropDoorRotating(PropDoorRotating<'a>),
526 #[serde(rename = "prop_dynamic")]
527 #[serde(borrow)]
528 PropDynamic(PropDynamic<'a>),
529 #[serde(rename = "prop_dynamic_ornament")]
530 #[serde(borrow)]
531 PropDynamicOrnament(PropDynamicOrnament<'a>),
532 #[serde(rename = "prop_dynamic_override")]
533 #[serde(borrow)]
534 PropDynamicOverride(PropDynamicOverride<'a>),
535 #[serde(rename = "prop_physics")]
536 #[serde(borrow)]
537 PropPhysics(PropPhysics<'a>),
538 #[serde(rename = "prop_physics_multiplayer")]
539 #[serde(borrow)]
540 PropPhysicsMultiplayer(PropPhysicsMultiplayer<'a>),
541 #[serde(rename = "prop_physics_override")]
542 #[serde(borrow)]
543 PropPhysicsOverride(PropPhysicsOverride<'a>),
544 #[serde(rename = "prop_ragdoll")]
545 #[serde(borrow)]
546 PropRagdoll(PropRagdoll<'a>),
547 #[serde(rename = "prop_soccer_ball")]
548 #[serde(borrow)]
549 PropSoccerBall(PropSoccerBall<'a>),
550 #[serde(rename = "shadow_control")]
551 #[serde(borrow)]
552 ShadowControl(ShadowControl<'a>),
553 #[serde(rename = "sky_camera")]
554 #[serde(borrow)]
555 SkyCamera(SkyCamera<'a>),
556 #[serde(rename = "team_control_point")]
557 #[serde(borrow)]
558 TeamControlPoint(TeamControlPoint<'a>),
559 #[serde(rename = "team_control_point_master")]
560 #[serde(borrow)]
561 TeamControlPointMaster(TeamControlPointMaster<'a>),
562 #[serde(rename = "team_control_point_round")]
563 #[serde(borrow)]
564 TeamControlPointRound(TeamControlPointRound<'a>),
565 #[serde(rename = "team_round_timer")]
566 #[serde(borrow)]
567 TeamRoundTimer(TeamRoundTimer<'a>),
568 #[serde(rename = "team_train_watcher")]
569 #[serde(borrow)]
570 TeamTrainWatcher(TeamTrainWatcher<'a>),
571 #[serde(rename = "tf_base_minigame")]
572 TfBaseMinigame(TfBaseMinigame),
573 #[serde(rename = "tf_gamerules")]
574 #[serde(borrow)]
575 TfGamerules(TfGamerules<'a>),
576 #[serde(rename = "tf_generic_bomb")]
577 #[serde(borrow)]
578 TfGenericBomb(TfGenericBomb<'a>),
579 #[serde(rename = "tf_glow")]
580 #[serde(borrow)]
581 TfGlow(TfGlow<'a>),
582 #[serde(rename = "tf_halloween_gift_spawn_location")]
583 #[serde(borrow)]
584 TfHalloweenGiftSpawnLocation(TfHalloweenGiftSpawnLocation<'a>),
585 #[serde(rename = "tf_halloween_minigame")]
586 #[serde(borrow)]
587 TfHalloweenMinigame(TfHalloweenMinigame<'a>),
588 #[serde(rename = "tf_halloween_minigame_falling_platforms")]
589 #[serde(borrow)]
590 TfHalloweenMinigameFallingPlatforms(TfHalloweenMinigameFallingPlatforms<'a>),
591 #[serde(rename = "tf_halloween_pickup")]
592 #[serde(borrow)]
593 TfHalloweenPickup(TfHalloweenPickup<'a>),
594 #[serde(rename = "tf_logic_arena")]
595 #[serde(borrow)]
596 TfLogicArena(TfLogicArena<'a>),
597 #[serde(rename = "tf_logic_competitive")]
598 #[serde(borrow)]
599 TfLogicCompetitive(TfLogicCompetitive<'a>),
600 #[serde(rename = "tf_logic_cp_timer")]
601 #[serde(borrow)]
602 TfLogicCpTimer(TfLogicCpTimer<'a>),
603 #[serde(rename = "tf_logic_holiday")]
604 #[serde(borrow)]
605 TfLogicHoliday(TfLogicHoliday<'a>),
606 #[serde(rename = "tf_logic_hybrid_ctf_cp")]
607 TfLogicHybridCtfCp(TfLogicHybridCtfCp),
608 #[serde(rename = "tf_logic_koth")]
609 #[serde(borrow)]
610 TfLogicKoth(TfLogicKoth<'a>),
611 #[serde(rename = "tf_logic_mann_vs_machine")]
612 #[serde(borrow)]
613 TfLogicMannVsMachine(TfLogicMannVsMachine<'a>),
614 #[serde(rename = "tf_logic_mannpower")]
615 TfLogicMannpower(TfLogicMannpower),
616 #[serde(rename = "tf_logic_medieval")]
617 #[serde(borrow)]
618 TfLogicMedieval(TfLogicMedieval<'a>),
619 #[serde(rename = "tf_logic_minigames")]
620 #[serde(borrow)]
621 TfLogicMinigames(TfLogicMinigames<'a>),
622 #[serde(rename = "tf_logic_multiple_escort")]
623 TfLogicMultipleEscort(TfLogicMultipleEscort),
624 #[serde(rename = "tf_logic_on_holiday")]
625 #[serde(borrow)]
626 TfLogicOnHoliday(TfLogicOnHoliday<'a>),
627 #[serde(rename = "tf_logic_player_destruction")]
628 #[serde(borrow)]
629 TfLogicPlayerDestruction(TfLogicPlayerDestruction<'a>),
630 #[serde(rename = "tf_logic_robot_destruction")]
631 #[serde(borrow)]
632 TfLogicRobotDestruction(TfLogicRobotDestruction<'a>),
633 #[serde(rename = "tf_logic_training_mode")]
634 #[serde(borrow)]
635 TfLogicTrainingMode(TfLogicTrainingMode<'a>),
636 #[serde(rename = "tf_point_nav_interface")]
637 #[serde(borrow)]
638 TfPointNavInterface(TfPointNavInterface<'a>),
639 #[serde(rename = "tf_point_weapon_mimic")]
640 #[serde(borrow)]
641 TfPointWeaponMimic(TfPointWeaponMimic<'a>),
642 #[serde(rename = "tf_pumpkin_bomb")]
643 TfPumpkinBomb(TfPumpkinBomb),
644 #[serde(rename = "tf_robot_destruction_robot_spawn")]
645 #[serde(borrow)]
646 TfRobotDestructionRobotSpawn(TfRobotDestructionRobotSpawn<'a>),
647 #[serde(rename = "tf_robot_destruction_spawn_group")]
648 #[serde(borrow)]
649 TfRobotDestructionSpawnGroup(TfRobotDestructionSpawnGroup<'a>),
650 #[serde(rename = "tf_spell_pickup")]
651 #[serde(borrow)]
652 TfSpellPickup(TfSpellPickup<'a>),
653 #[serde(rename = "tf_teleport_location")]
654 #[serde(borrow)]
655 TfTeleportLocation(TfTeleportLocation<'a>),
656 #[serde(rename = "tf_zombie")]
657 #[serde(borrow)]
658 TfZombie(TfZombie<'a>),
659 #[serde(rename = "tf_zombie_spawner")]
660 #[serde(borrow)]
661 TfZombieSpawner(TfZombieSpawner<'a>),
662 #[serde(rename = "training_annotation")]
663 #[serde(borrow)]
664 TrainingAnnotation(TrainingAnnotation<'a>),
665 #[serde(rename = "training_prop_dynamic")]
666 #[serde(borrow)]
667 TrainingPropDynamic(TrainingPropDynamic<'a>),
668 #[serde(rename = "trigger_add_or_remove_tf_player_attributes")]
669 #[serde(borrow)]
670 TriggerAddOrRemoveTfPlayerAttributes(TriggerAddOrRemoveTfPlayerAttributes<'a>),
671 #[serde(rename = "trigger_add_tf_player_condition")]
672 #[serde(borrow)]
673 TriggerAddTfPlayerCondition(TriggerAddTfPlayerCondition<'a>),
674 #[serde(rename = "trigger_apply_impulse")]
675 #[serde(borrow)]
676 TriggerApplyImpulse(TriggerApplyImpulse<'a>),
677 #[serde(rename = "trigger_brush")]
678 #[serde(borrow)]
679 TriggerBrush(TriggerBrush<'a>),
680 #[serde(rename = "trigger_capture_area")]
681 #[serde(borrow)]
682 TriggerCaptureArea(TriggerCaptureArea<'a>),
683 #[serde(rename = "trigger_catapult")]
684 #[serde(borrow)]
685 TriggerCatapult(TriggerCatapult<'a>),
686 #[serde(rename = "trigger_gravity")]
687 #[serde(borrow)]
688 TriggerGravity(TriggerGravity<'a>),
689 #[serde(rename = "trigger_hurt")]
690 #[serde(borrow)]
691 TriggerHurt(TriggerHurt<'a>),
692 #[serde(rename = "trigger_ignite")]
693 #[serde(borrow)]
694 TriggerIgnite(TriggerIgnite<'a>),
695 #[serde(rename = "trigger_ignite_arrows")]
696 #[serde(borrow)]
697 TriggerIgniteArrows(TriggerIgniteArrows<'a>),
698 #[serde(rename = "trigger_look")]
699 #[serde(borrow)]
700 TriggerLook(TriggerLook<'a>),
701 #[serde(rename = "trigger_multiple")]
702 #[serde(borrow)]
703 TriggerMultiple(TriggerMultiple<'a>),
704 #[serde(rename = "trigger_once")]
705 #[serde(borrow)]
706 TriggerOnce(TriggerOnce<'a>),
707 #[serde(rename = "trigger_passtime_ball")]
708 #[serde(borrow)]
709 TriggerPasstimeBall(TriggerPasstimeBall<'a>),
710 #[serde(rename = "trigger_player_respawn_override")]
711 #[serde(borrow)]
712 TriggerPlayerRespawnOverride(TriggerPlayerRespawnOverride<'a>),
713 #[serde(rename = "trigger_push")]
714 #[serde(borrow)]
715 TriggerPush(TriggerPush<'a>),
716 #[serde(rename = "trigger_rd_vault_trigger")]
717 #[serde(borrow)]
718 TriggerRdVaultTrigger(TriggerRdVaultTrigger<'a>),
719 #[serde(rename = "trigger_remove_tf_player_condition")]
720 #[serde(borrow)]
721 TriggerRemoveTfPlayerCondition(TriggerRemoveTfPlayerCondition<'a>),
722 #[serde(rename = "trigger_soundscape")]
723 #[serde(borrow)]
724 TriggerSoundscape(TriggerSoundscape<'a>),
725 #[serde(rename = "trigger_stun")]
726 #[serde(borrow)]
727 TriggerStun(TriggerStun<'a>),
728 #[serde(rename = "trigger_teleport")]
729 #[serde(borrow)]
730 TriggerTeleport(TriggerTeleport<'a>),
731 #[serde(rename = "trigger_teleport_relative")]
732 #[serde(borrow)]
733 TriggerTeleportRelative(TriggerTeleportRelative<'a>),
734 #[serde(rename = "trigger_timer_door")]
735 #[serde(borrow)]
736 TriggerTimerDoor(TriggerTimerDoor<'a>),
737 #[serde(rename = "trigger_vphysics_motion")]
738 #[serde(borrow)]
739 TriggerVphysicsMotion(TriggerVphysicsMotion<'a>),
740 #[serde(rename = "water_lod_control")]
741 #[serde(borrow)]
742 WaterLodControl(WaterLodControl<'a>),
743 #[serde(rename = "wheel_of_doom")]
744 #[serde(borrow)]
745 WheelOfDoom(WheelOfDoom<'a>),
746 #[serde(rename = "worldspawn")]
747 #[serde(borrow)]
748 Worldspawn(Worldspawn<'a>),
749}
750#[derive(Debug, Clone, Deserialize)]
751pub struct AmbientGeneric<'a> {
752 #[serde(default)]
753 pub angles: Option<Angles>,
754 #[serde(default)]
755 pub cspinup: Option<i32>,
756 #[serde(default)]
757 pub fadeinsecs: Option<i32>,
758 #[serde(default)]
759 pub fadeoutsecs: Option<i32>,
760 pub health: f32,
761 #[serde(default)]
762 pub lfomodpitch: Option<i32>,
763 #[serde(default)]
764 pub lfomodvol: Option<i32>,
765 #[serde(default)]
766 pub lforate: Option<i32>,
767 #[serde(default)]
768 pub lfotype: Option<i32>,
769 #[serde(default)]
770 pub message: Option<&'a str>,
771 #[serde(default)]
772 pub onuser1: Option<&'a str>,
773 pub origin: Vector,
774 #[serde(default)]
775 pub parentname: Option<&'a str>,
776 pub pitch: i32,
777 pub pitchstart: i32,
778 #[serde(default)]
779 pub preset: Option<i32>,
780 pub radius: f32,
781 #[serde(default)]
782 pub sourceentityname: Option<&'a str>,
783 pub spawnflags: u32,
784 #[serde(default)]
785 pub spindown: Option<i32>,
786 #[serde(default)]
787 pub spinup: Option<i32>,
788 #[serde(default)]
789 pub targetname: Option<&'a str>,
790 #[serde(default)]
791 pub volstart: Option<i32>,
792}
793#[derive(Debug, Clone, Deserialize)]
794pub struct BaseBoss<'a> {
795 pub angles: Angles,
796 pub health: i32,
797 pub model: &'a str,
798 pub origin: Vector,
799 #[serde(deserialize_with = "deserialize_bool")]
800 pub playbackrate: bool,
801 pub skin: u8,
802 pub speed: f32,
803 pub targetname: &'a str,
804 pub vscripts: &'a str,
805}
806#[derive(Debug, Clone, Deserialize)]
807pub struct BotActionPoint<'a> {
808 #[serde(default)]
809 pub command: Option<&'a str>,
810 pub desired_distance: f32,
811 #[serde(default)]
812 pub next_action_point: Option<&'a str>,
813 #[serde(default)]
814 pub onbotreached: Option<&'a str>,
815 pub origin: Vector,
816 #[serde(default)]
817 pub stay_time: Option<f32>,
818 pub targetname: &'a str,
819}
820#[derive(Debug, Clone, Deserialize)]
821pub struct BotGenerator<'a> {
822 #[serde(default)]
823 pub action_point: Option<&'a str>,
824 #[serde(deserialize_with = "deserialize_bool")]
825 pub actionondeath: bool,
826 pub angles: Angles,
827 pub class: &'a str,
828 pub count: i32,
829 #[serde(default)]
830 pub difficulty: Option<i32>,
831 #[serde(deserialize_with = "deserialize_bool")]
832 pub disabledodge: bool,
833 #[serde(default)]
834 pub initial_command: Option<&'a str>,
835 pub interval: f32,
836 pub maxactive: u8,
837 #[serde(default)]
838 pub onbotkilled: Option<&'a str>,
839 #[serde(default)]
840 pub onspawned: Option<&'a str>,
841 pub origin: Vector,
842 #[serde(deserialize_with = "deserialize_bool")]
843 #[serde(default)]
844 pub removeondeath: bool,
845 #[serde(deserialize_with = "deserialize_bool")]
846 #[serde(default)]
847 pub retainbuildings: bool,
848 #[serde(default)]
849 pub spawnflags: Option<u32>,
850 #[serde(deserialize_with = "deserialize_bool")]
851 #[serde(default)]
852 pub spectateondeath: bool,
853 #[serde(deserialize_with = "deserialize_bool")]
854 pub suppressfire: bool,
855 pub targetname: &'a str,
856 pub team: &'a str,
857 #[serde(deserialize_with = "deserialize_bool")]
858 #[serde(default)]
859 pub useteamspawnpoint: bool,
860}
861#[derive(Debug, Clone, Deserialize)]
862pub struct BotHintEngineerNest<'a> {
863 pub angles: Angles,
864 pub origin: Vector,
865 #[serde(default)]
866 pub spawnflags: Option<u32>,
867 #[serde(deserialize_with = "deserialize_bool")]
868 #[serde(default)]
869 pub startdisabled: bool,
870 pub targetname: &'a str,
871 pub teamnum: u8,
872}
873#[derive(Debug, Clone, Deserialize)]
874pub struct BotHintSentrygun<'a> {
875 pub angles: Angles,
876 pub origin: Vector,
877 #[serde(default)]
878 pub rangehelper: Option<u16>,
879 #[serde(default)]
880 pub sequence: Option<u8>,
881 #[serde(default)]
882 pub spawnflags: Option<u32>,
883 #[serde(deserialize_with = "deserialize_bool")]
884 #[serde(default)]
885 pub startdisabled: bool,
886 #[serde(deserialize_with = "deserialize_bool")]
887 #[serde(default)]
888 pub sticky: bool,
889 #[serde(default)]
890 pub targetname: Option<&'a str>,
891 pub teamnum: u8,
892}
893#[derive(Debug, Clone, Deserialize)]
894pub struct BotHintSniperSpot<'a> {
895 pub angles: Angles,
896 pub origin: Vector,
897 pub radius: u16,
898 #[serde(default)]
899 pub spawnflags: Option<u32>,
900 pub targetname: &'a str,
901 pub teamnum: u8,
902}
903#[derive(Debug, Clone, Deserialize)]
904pub struct BotHintTeleporterExit<'a> {
905 pub angles: Angles,
906 pub origin: Vector,
907 #[serde(default)]
908 pub spawnflags: Option<u32>,
909 #[serde(deserialize_with = "deserialize_bool")]
910 #[serde(default)]
911 pub startdisabled: bool,
912 #[serde(default)]
913 pub targetname: Option<&'a str>,
914 pub teamnum: u8,
915}
916#[derive(Debug, Clone, Deserialize)]
917pub struct BotRoster<'a> {
918 #[serde(deserialize_with = "deserialize_bool")]
919 pub allowclasschanges: bool,
920 #[serde(deserialize_with = "deserialize_bool")]
921 pub allowdemoman: bool,
922 #[serde(deserialize_with = "deserialize_bool")]
923 pub allowengineer: bool,
924 #[serde(deserialize_with = "deserialize_bool")]
925 pub allowheavy: bool,
926 #[serde(deserialize_with = "deserialize_bool")]
927 pub allowmedic: bool,
928 #[serde(deserialize_with = "deserialize_bool")]
929 pub allowpyro: bool,
930 #[serde(deserialize_with = "deserialize_bool")]
931 pub allowscout: bool,
932 #[serde(deserialize_with = "deserialize_bool")]
933 pub allowsniper: bool,
934 #[serde(deserialize_with = "deserialize_bool")]
935 pub allowsoldier: bool,
936 #[serde(deserialize_with = "deserialize_bool")]
937 pub allowspy: bool,
938 pub origin: Vector,
939 pub targetname: &'a str,
940 pub team: &'a str,
941}
942#[derive(Debug, Clone, Deserialize)]
943pub struct ColorCorrection<'a> {
944 #[serde(default)]
945 pub angles: Option<Angles>,
946 pub fadeinduration: f32,
947 pub fadeoutduration: f32,
948 #[serde(default)]
949 pub filename: Option<&'a str>,
950 pub maxfalloff: f32,
951 pub maxweight: f32,
952 pub minfalloff: f32,
953 #[serde(default)]
954 pub onmultinewround: Option<&'a str>,
955 pub origin: Vector,
956 #[serde(default)]
957 pub spawnflags: Option<u32>,
958 #[serde(deserialize_with = "deserialize_bool")]
959 #[serde(default)]
960 pub startdisabled: bool,
961 #[serde(default)]
962 pub targetname: Option<&'a str>,
963}
964#[derive(Debug, Clone, Deserialize)]
965pub struct DispenserTouchTrigger<'a> {
966 #[serde(default)]
967 pub angles: Option<Angles>,
968 #[serde(default)]
969 pub filtername: Option<&'a str>,
970 pub model: &'a str,
971 #[serde(default)]
972 pub origin: Option<Vector>,
973 #[serde(default)]
974 pub parentname: Option<&'a str>,
975 #[serde(deserialize_with = "deserialize_bool")]
976 #[serde(default)]
977 pub solid: bool,
978 #[serde(default)]
979 pub spawnflags: Option<u32>,
980 #[serde(deserialize_with = "deserialize_bool")]
981 #[serde(default)]
982 pub startdisabled: bool,
983 pub targetname: &'a str,
984}
985#[derive(Debug, Clone, Deserialize)]
986pub struct EditorText<'a> {
987 pub angles: Angles,
988 pub color: Color,
989 pub message: &'a str,
990 pub origin: Vector,
991 pub textsize: u8,
992}
993#[derive(Debug, Clone, Deserialize)]
994pub struct EntitySpawnManager<'a> {
995 #[serde(deserialize_with = "deserialize_bool")]
996 #[serde(default)]
997 pub drop_to_ground: bool,
998 #[serde(default)]
999 pub entity_count: Option<i32>,
1000 #[serde(default)]
1001 pub entity_name: Option<&'a str>,
1002 pub origin: Vector,
1003 #[serde(deserialize_with = "deserialize_bool")]
1004 #[serde(default)]
1005 pub random_rotation: bool,
1006 #[serde(default)]
1007 pub respawn_time: Option<i32>,
1008 #[serde(default)]
1009 pub spawnflags: Option<u32>,
1010 #[serde(default)]
1011 pub targetname: Option<&'a str>,
1012}
1013#[derive(Debug, Clone, Deserialize)]
1014pub struct EntitySpawnPoint<'a> {
1015 #[serde(default)]
1016 pub angles: Option<Angles>,
1017 pub origin: Vector,
1018 pub spawn_manager_name: &'a str,
1019 #[serde(default)]
1020 pub targetname: Option<&'a str>,
1021}
1022#[derive(Debug, Clone, Deserialize)]
1023pub struct EnvBeam<'a> {
1024 pub boltwidth: u8,
1025 pub damage: f32,
1026 pub decalname: &'a str,
1027 #[serde(default)]
1028 pub dissolvetype: Option<i32>,
1029 #[serde(deserialize_with = "deserialize_bool")]
1030 #[serde(default)]
1031 pub effects: bool,
1032 #[serde(deserialize_with = "deserialize_bool")]
1033 pub framerate: bool,
1034 pub framestart: i32,
1035 pub hdrcolorscale: f32,
1036 pub life: f32,
1037 #[serde(default)]
1038 pub lightningend: Option<&'a str>,
1039 pub lightningstart: &'a str,
1040 pub noiseamplitude: u8,
1041 pub origin: Vector,
1042 pub radius: u16,
1043 pub renderamt: u8,
1044 pub rendercolor: Color,
1045 #[serde(deserialize_with = "deserialize_bool")]
1046 pub renderfx: bool,
1047 #[serde(deserialize_with = "deserialize_bool")]
1048 #[serde(default)]
1049 pub rendermode: bool,
1050 pub spawnflags: u32,
1051 pub striketime: f32,
1052 pub targetname: &'a str,
1053 pub texture: &'a str,
1054 pub texturescroll: u8,
1055 #[serde(deserialize_with = "deserialize_bool")]
1056 pub touchtype: bool,
1057}
1058#[derive(Debug, Clone, Deserialize)]
1059pub struct EnvBubbles<'a> {
1060 pub current: f32,
1061 pub density: i32,
1062 pub frequency: i32,
1063 pub model: &'a str,
1064 pub spawnflags: u32,
1065}
1066#[derive(Debug, Clone, Deserialize)]
1067pub struct EnvEntityMaker<'a> {
1068 pub angles: Angles,
1069 pub entitytemplate: &'a str,
1070 #[serde(default)]
1071 pub model: Option<&'a str>,
1072 #[serde(default)]
1073 pub onentityspawned: Option<&'a str>,
1074 #[serde(default)]
1075 pub onuser1: Option<&'a str>,
1076 pub origin: Vector,
1077 #[serde(default)]
1078 pub parentname: Option<&'a str>,
1079 pub postspawndirection: Vector,
1080 pub postspawndirectionvariance: f32,
1081 #[serde(deserialize_with = "deserialize_bool")]
1082 #[serde(default)]
1083 pub postspawninheritangles: bool,
1084 #[serde(default)]
1085 pub postspawnspeed: Option<u16>,
1086 #[serde(default)]
1087 pub spawnflags: Option<u32>,
1088 pub targetname: &'a str,
1089}
1090#[derive(Debug, Clone, Deserialize)]
1091pub struct EnvExplosion<'a> {
1092 #[serde(default)]
1093 pub angles: Option<Angles>,
1094 pub fireballsprite: &'a str,
1095 #[serde(default)]
1096 pub ignoredentity: Option<&'a str>,
1097 pub imagnitude: u16,
1098 pub iradiusoverride: u16,
1099 pub origin: Vector,
1100 #[serde(default)]
1101 pub parentname: Option<&'a str>,
1102 pub rendermode: u8,
1103 pub spawnflags: u32,
1104 pub targetname: &'a str,
1105}
1106#[derive(Debug, Clone, Deserialize)]
1107pub struct EnvFade<'a> {
1108 pub duration: f32,
1109 pub holdtime: f32,
1110 pub origin: Vector,
1111 pub renderamt: u8,
1112 pub rendercolor: Color,
1113 pub spawnflags: u32,
1114 pub targetname: &'a str,
1115}
1116#[derive(Debug, Clone, Deserialize)]
1117pub struct EnvFogController<'a> {
1118 pub angles: Angles,
1119 #[serde(deserialize_with = "deserialize_bool")]
1120 #[serde(default)]
1121 pub disablex360: bool,
1122 pub farz: f32,
1123 #[serde(deserialize_with = "deserialize_bool")]
1124 #[serde(default)]
1125 pub fogblend: bool,
1126 pub fogcolor: Color,
1127 pub fogcolor2: Color,
1128 pub fogdir: Vector,
1129 #[serde(deserialize_with = "deserialize_bool")]
1130 #[serde(default)]
1131 pub fogenable: bool,
1132 pub fogend: f32,
1133 #[serde(default)]
1134 pub foglerptime: Option<f32>,
1135 pub fogmaxdensity: f32,
1136 pub fogstart: f32,
1137 #[serde(deserialize_with = "deserialize_bool")]
1138 #[serde(default)]
1139 pub hdrcolorscale: bool,
1140 #[serde(deserialize_with = "deserialize_bool")]
1141 #[serde(default)]
1142 pub maxcpulevel: bool,
1143 #[serde(deserialize_with = "deserialize_bool")]
1144 #[serde(default)]
1145 pub maxdxlevel: bool,
1146 #[serde(deserialize_with = "deserialize_bool")]
1147 #[serde(default)]
1148 pub maxgpulevel: bool,
1149 #[serde(deserialize_with = "deserialize_bool")]
1150 #[serde(default)]
1151 pub mincpulevel: bool,
1152 #[serde(deserialize_with = "deserialize_bool")]
1153 #[serde(default)]
1154 pub mindxlevel: bool,
1155 #[serde(deserialize_with = "deserialize_bool")]
1156 #[serde(default)]
1157 pub mingpulevel: bool,
1158 pub origin: Vector,
1159 #[serde(default)]
1160 pub spawnflags: Option<u32>,
1161 #[serde(default)]
1162 pub targetname: Option<&'a str>,
1163 #[serde(deserialize_with = "deserialize_bool")]
1164 #[serde(default)]
1165 pub use_angles: bool,
1166 #[serde(deserialize_with = "deserialize_bool")]
1167 #[serde(default)]
1168 pub zoomfogscale: bool,
1169}
1170#[derive(Debug, Clone, Deserialize)]
1171pub struct EnvGlow<'a> {
1172 pub angles: Angles,
1173 #[serde(deserialize_with = "deserialize_bool")]
1174 #[serde(default)]
1175 pub disablereceiveshadows: bool,
1176 #[serde(deserialize_with = "deserialize_bool")]
1177 #[serde(default)]
1178 pub effects: bool,
1179 #[serde(default)]
1180 pub frame: Option<f32>,
1181 pub framerate: f32,
1182 pub glowproxysize: u8,
1183 pub hdrcolorscale: f32,
1184 #[serde(deserialize_with = "deserialize_bool")]
1185 #[serde(default)]
1186 pub maxdxlevel: bool,
1187 #[serde(deserialize_with = "deserialize_bool")]
1188 #[serde(default)]
1189 pub mindxlevel: bool,
1190 pub model: &'a str,
1191 pub origin: Vector,
1192 #[serde(default)]
1193 pub parentname: Option<&'a str>,
1194 pub renderamt: u8,
1195 pub rendercolor: Color,
1196 #[serde(deserialize_with = "deserialize_bool")]
1197 pub renderfx: bool,
1198 pub rendermode: u8,
1199 pub scale: f32,
1200 pub spawnflags: u32,
1201 #[serde(default)]
1202 pub targetname: Option<&'a str>,
1203}
1204#[derive(Debug, Clone, Deserialize)]
1205pub struct EnvLaser<'a> {
1206 #[serde(default)]
1207 pub angles: Option<Angles>,
1208 pub damage: f32,
1209 pub dissolvetype: i32,
1210 #[serde(deserialize_with = "deserialize_bool")]
1211 #[serde(default)]
1212 pub effects: bool,
1213 #[serde(default)]
1214 pub endsprite: Option<&'a str>,
1215 #[serde(default)]
1216 pub framestart: Option<f32>,
1217 #[serde(default)]
1218 pub hdrcolorscale: Option<f32>,
1219 pub lasertarget: &'a str,
1220 pub noiseamplitude: u8,
1221 pub origin: Vector,
1222 #[serde(default)]
1223 pub parentname: Option<&'a str>,
1224 pub renderamt: u8,
1225 pub rendercolor: Color,
1226 #[serde(deserialize_with = "deserialize_bool")]
1227 #[serde(default)]
1228 pub renderfx: bool,
1229 #[serde(deserialize_with = "deserialize_bool")]
1230 #[serde(default)]
1231 pub rendermode: bool,
1232 pub spawnflags: u32,
1233 #[serde(default)]
1234 pub targetname: Option<&'a str>,
1235 pub texture: &'a str,
1236 pub texturescroll: u8,
1237 pub width: u8,
1238}
1239#[derive(Debug, Clone, Deserialize)]
1240pub struct EnvLightglow<'a> {
1241 #[serde(default)]
1242 pub _light: Option<LightColor>,
1243 pub angles: Angles,
1244 pub glowproxysize: f32,
1245 pub hdrcolorscale: f32,
1246 pub horizontalglowsize: u8,
1247 pub maxdist: f32,
1248 pub mindist: i32,
1249 pub origin: Vector,
1250 #[serde(default)]
1251 pub outermaxdist: Option<u16>,
1252 #[serde(default)]
1253 pub parentname: Option<&'a str>,
1254 #[serde(default)]
1255 pub renderamt: Option<i32>,
1256 pub rendercolor: Color,
1257 #[serde(default)]
1258 pub spawnflags: Option<u32>,
1259 #[serde(default)]
1260 pub targetname: Option<&'a str>,
1261 pub verticalglowsize: f32,
1262}
1263#[derive(Debug, Clone, Deserialize)]
1264pub struct EnvPhysexplosion<'a> {
1265 pub inner_radius: f32,
1266 pub magnitude: f32,
1267 pub origin: Vector,
1268 #[serde(default)]
1269 pub radius: Option<f32>,
1270 pub spawnflags: u32,
1271 pub targetname: &'a str,
1272}
1273#[derive(Debug, Clone, Deserialize)]
1274pub struct EnvScreenoverlay<'a> {
1275 pub origin: Vector,
1276 pub overlayname1: &'a str,
1277 #[serde(default)]
1278 pub overlayname10: Option<&'a str>,
1279 #[serde(default)]
1280 pub overlayname2: Option<&'a str>,
1281 #[serde(default)]
1282 pub overlayname3: Option<&'a str>,
1283 #[serde(default)]
1284 pub overlayname4: Option<&'a str>,
1285 #[serde(default)]
1286 pub overlayname5: Option<&'a str>,
1287 #[serde(default)]
1288 pub overlayname6: Option<&'a str>,
1289 #[serde(default)]
1290 pub overlayname7: Option<&'a str>,
1291 #[serde(default)]
1292 pub overlayname8: Option<&'a str>,
1293 #[serde(default)]
1294 pub overlayname9: Option<&'a str>,
1295 pub overlaytime1: f32,
1296 pub overlaytime10: f32,
1297 pub overlaytime2: f32,
1298 pub overlaytime3: f32,
1299 pub overlaytime4: f32,
1300 pub overlaytime5: f32,
1301 pub overlaytime6: f32,
1302 pub overlaytime7: f32,
1303 pub overlaytime8: f32,
1304 pub overlaytime9: f32,
1305 pub targetname: &'a str,
1306}
1307#[derive(Debug, Clone, Deserialize)]
1308pub struct EnvShake<'a> {
1309 pub amplitude: f32,
1310 #[serde(default)]
1311 pub angles: Option<Angles>,
1312 pub duration: f32,
1313 pub frequency: f32,
1314 #[serde(default)]
1315 pub onuser1: Option<&'a str>,
1316 pub origin: Vector,
1317 #[serde(default)]
1318 pub parentname: Option<&'a str>,
1319 pub radius: f32,
1320 pub spawnflags: u32,
1321 pub targetname: &'a str,
1322}
1323#[derive(Debug, Clone, Deserialize)]
1324pub struct EnvShooter<'a> {
1325 pub angles: Angles,
1326 pub delay: f32,
1327 #[serde(deserialize_with = "deserialize_bool")]
1328 pub disablereceiveshadows: bool,
1329 pub gibangles: Vector,
1330 pub gibanglevelocity: f32,
1331 pub gibgravityscale: f32,
1332 pub m_flgiblife: u8,
1333 pub m_flvariance: f32,
1334 pub m_flvelocity: u16,
1335 pub m_igibs: u8,
1336 pub massoverride: f32,
1337 #[serde(deserialize_with = "deserialize_bool")]
1338 pub nogibshadows: bool,
1339 pub origin: Vector,
1340 pub renderamt: u8,
1341 pub rendercolor: Color,
1342 #[serde(deserialize_with = "deserialize_bool")]
1343 pub renderfx: bool,
1344 #[serde(deserialize_with = "deserialize_bool")]
1345 pub rendermode: bool,
1346 pub shootmodel: &'a str,
1347 pub shootsounds: i32,
1348 #[serde(deserialize_with = "deserialize_bool")]
1349 pub simulation: bool,
1350 pub skin: i32,
1351 pub spawnflags: u32,
1352 pub targetname: &'a str,
1353}
1354#[derive(Debug, Clone, Deserialize)]
1355pub struct EnvSmokestack<'a> {
1356 pub angles: Angles,
1357 pub basespread: u8,
1358 pub endsize: u8,
1359 #[serde(deserialize_with = "deserialize_bool")]
1360 pub initialstate: bool,
1361 pub jetlength: u16,
1362 pub origin: Vector,
1363 #[serde(default)]
1364 pub parentname: Option<&'a str>,
1365 pub rate: u8,
1366 pub renderamt: u8,
1367 pub rendercolor: Color,
1368 pub roll: u8,
1369 pub smokematerial: &'a str,
1370 pub speed: u8,
1371 pub spreadspeed: u8,
1372 pub startsize: u8,
1373 #[serde(default)]
1374 pub targetname: Option<&'a str>,
1375 pub twist: u8,
1376 #[serde(default)]
1377 pub windangle: Option<i32>,
1378 #[serde(default)]
1379 pub windspeed: Option<u8>,
1380}
1381#[derive(Debug, Clone, Deserialize)]
1382pub struct EnvSoundscape<'a> {
1383 #[serde(default)]
1384 pub angles: Option<Angles>,
1385 pub origin: Vector,
1386 #[serde(default)]
1387 pub position0: Option<&'a str>,
1388 #[serde(default)]
1389 pub position1: Option<&'a str>,
1390 #[serde(default)]
1391 pub position2: Option<&'a str>,
1392 #[serde(default)]
1393 pub position3: Option<&'a str>,
1394 #[serde(default)]
1395 pub position4: Option<&'a str>,
1396 #[serde(default)]
1397 pub position5: Option<&'a str>,
1398 #[serde(default)]
1399 pub position6: Option<&'a str>,
1400 #[serde(default)]
1401 pub position7: Option<&'a str>,
1402 pub radius: f32,
1403 pub soundscape: &'a str,
1404 #[serde(deserialize_with = "deserialize_bool")]
1405 #[serde(default)]
1406 pub startdisabled: bool,
1407 #[serde(default)]
1408 pub targetname: Option<&'a str>,
1409}
1410#[derive(Debug, Clone, Deserialize)]
1411pub struct EnvSoundscapeProxy<'a> {
1412 #[serde(default)]
1413 pub angles: Option<Angles>,
1414 #[serde(default)]
1415 pub mainsoundscapename: Option<&'a str>,
1416 pub origin: Vector,
1417 pub radius: f32,
1418 #[serde(default)]
1419 pub sides: Option<&'a str>,
1420 #[serde(default)]
1421 pub targetname: Option<&'a str>,
1422}
1423#[derive(Debug, Clone, Deserialize)]
1424pub struct EnvSoundscapeTriggerable<'a> {
1425 pub origin: Vector,
1426 #[serde(default)]
1427 pub position0: Option<&'a str>,
1428 #[serde(default)]
1429 pub position1: Option<&'a str>,
1430 #[serde(default)]
1431 pub position2: Option<&'a str>,
1432 #[serde(default)]
1433 pub position3: Option<&'a str>,
1434 #[serde(default)]
1435 pub position4: Option<&'a str>,
1436 #[serde(default)]
1437 pub position5: Option<&'a str>,
1438 #[serde(default)]
1439 pub position6: Option<&'a str>,
1440 pub radius: f32,
1441 pub soundscape: &'a str,
1442 #[serde(deserialize_with = "deserialize_bool")]
1443 #[serde(default)]
1444 pub startdisabled: bool,
1445 pub targetname: &'a str,
1446}
1447#[derive(Debug, Clone, Deserialize)]
1448pub struct EnvSpark<'a> {
1449 pub angles: Angles,
1450 pub magnitude: u8,
1451 #[serde(default)]
1452 pub maxdelay: Option<f32>,
1453 pub origin: Vector,
1454 #[serde(default)]
1455 pub parentname: Option<&'a str>,
1456 pub spawnflags: u32,
1457 #[serde(default)]
1458 pub targetname: Option<&'a str>,
1459 pub traillength: u8,
1460}
1461#[derive(Debug, Clone, Deserialize)]
1462pub struct EnvSprite<'a> {
1463 #[serde(default)]
1464 pub _cone: Option<u8>,
1465 #[serde(deserialize_with = "deserialize_bool")]
1466 #[serde(default)]
1467 pub _inner_cone: bool,
1468 #[serde(default)]
1469 pub _light: Option<LightColor>,
1470 #[serde(default)]
1471 pub angles: Option<Angles>,
1472 #[serde(deserialize_with = "deserialize_bool")]
1473 #[serde(default)]
1474 pub disablereceiveshadows: bool,
1475 #[serde(deserialize_with = "deserialize_bool")]
1476 #[serde(default)]
1477 pub effects: bool,
1478 #[serde(default)]
1479 pub fademaxdist: Option<u16>,
1480 #[serde(default)]
1481 pub fademindist: Option<u16>,
1482 #[serde(default)]
1483 pub frame: Option<f32>,
1484 pub framerate: f32,
1485 pub glowproxysize: f32,
1486 pub hdrcolorscale: f32,
1487 #[serde(deserialize_with = "deserialize_bool")]
1488 #[serde(default)]
1489 pub maxdxlevel: bool,
1490 #[serde(default)]
1491 pub mindxlevel: Option<u8>,
1492 pub model: &'a str,
1493 pub origin: Vector,
1494 #[serde(default)]
1495 pub parentname: Option<&'a str>,
1496 pub renderamt: u8,
1497 pub rendercolor: &'a str,
1498 #[serde(default)]
1499 pub renderfx: Option<u8>,
1500 pub rendermode: u8,
1501 #[serde(default)]
1502 pub scale: Option<f32>,
1503 #[serde(default)]
1504 pub spawnflags: Option<u32>,
1505 #[serde(default)]
1506 pub targetname: Option<&'a str>,
1507}
1508#[derive(Debug, Clone, Deserialize)]
1509pub struct EnvSteam<'a> {
1510 pub angles: Angles,
1511 #[serde(deserialize_with = "deserialize_bool")]
1512 #[serde(default)]
1513 pub effects: bool,
1514 pub endsize: u16,
1515 #[serde(deserialize_with = "deserialize_bool")]
1516 #[serde(default)]
1517 pub initialstate: bool,
1518 pub jetlength: u16,
1519 pub origin: Vector,
1520 #[serde(default)]
1521 pub parentname: Option<&'a str>,
1522 #[serde(deserialize_with = "deserialize_bool")]
1523 #[serde(default)]
1524 pub r#type: bool,
1525 pub rate: u8,
1526 pub renderamt: u8,
1527 pub rendercolor: Color,
1528 #[serde(deserialize_with = "deserialize_bool")]
1529 #[serde(default)]
1530 pub renderfx: bool,
1531 #[serde(deserialize_with = "deserialize_bool")]
1532 #[serde(default)]
1533 pub rendermode: bool,
1534 pub rollspeed: u8,
1535 pub spawnflags: u32,
1536 pub speed: u8,
1537 pub spreadspeed: u8,
1538 pub startsize: u16,
1539 #[serde(default)]
1540 pub targetname: Option<&'a str>,
1541}
1542#[derive(Debug, Clone, Deserialize)]
1543pub struct EnvSun<'a> {
1544 pub angles: Angles,
1545 pub hdrcolorscale: f32,
1546 pub material: &'a str,
1547 pub origin: Vector,
1548 pub overlaycolor: Color,
1549 pub overlaymaterial: &'a str,
1550 pub overlaysize: i32,
1551 #[serde(default)]
1552 pub pitch: Option<f32>,
1553 pub rendercolor: Color,
1554 pub size: i32,
1555 pub use_angles: i32,
1556}
1557#[derive(Debug, Clone, Deserialize)]
1558pub struct EnvTexturetoggle<'a> {
1559 pub origin: Vector,
1560 pub target: &'a str,
1561 pub targetname: &'a str,
1562}
1563#[derive(Debug, Clone, Deserialize)]
1564pub struct EnvTonemapController<'a> {
1565 #[serde(default)]
1566 pub angles: Option<Angles>,
1567 pub origin: Vector,
1568 #[serde(default)]
1569 pub spawnflags: Option<u32>,
1570 pub targetname: &'a str,
1571}
1572#[derive(Debug, Clone, Deserialize)]
1573pub struct EnvWind<'a> {
1574 pub angles: Angles,
1575 pub gustdirchange: i32,
1576 pub gustduration: f32,
1577 pub maxgust: i32,
1578 pub maxgustdelay: f32,
1579 pub maxwind: i32,
1580 pub mingust: i32,
1581 pub mingustdelay: f32,
1582 pub minwind: i32,
1583 pub origin: Vector,
1584 #[serde(default)]
1585 pub targetname: Option<&'a str>,
1586}
1587#[derive(Debug, Clone, Deserialize)]
1588pub struct EyeballBoss<'a> {
1589 #[serde(default)]
1590 pub angles: Option<Angles>,
1591 pub origin: Vector,
1592 #[serde(default)]
1593 pub physdamagescale: Option<f32>,
1594 #[serde(default)]
1595 pub renderamt: Option<u8>,
1596 #[serde(default)]
1597 pub rendercolor: Option<Color>,
1598 #[serde(default)]
1599 pub spawnflags: Option<u32>,
1600 pub targetname: &'a str,
1601 #[serde(default)]
1602 pub team: Option<u8>,
1603 pub teamnum: u8,
1604}
1605#[derive(Debug, Clone, Deserialize)]
1606pub struct FilterActivatorClass<'a> {
1607 #[serde(default)]
1608 pub angles: Option<Angles>,
1609 pub filterclass: &'a str,
1610 #[serde(default)]
1611 pub negated: Option<Negated>,
1612 pub origin: Vector,
1613 pub targetname: &'a str,
1614}
1615#[derive(Debug, Clone, Deserialize)]
1616pub struct FilterActivatorName<'a> {
1617 #[serde(default)]
1618 pub angles: Option<Angles>,
1619 #[serde(default)]
1620 pub filtername: Option<&'a str>,
1621 #[serde(default)]
1622 pub negated: Option<Negated>,
1623 #[serde(default)]
1624 pub onpass: Option<&'a str>,
1625 pub origin: Vector,
1626 #[serde(default)]
1627 pub targetname: Option<&'a str>,
1628}
1629#[derive(Debug, Clone, Deserialize)]
1630pub struct FilterActivatorTeam<'a> {
1631 pub filterteam: i32,
1632 #[serde(deserialize_with = "deserialize_bool")]
1633 pub negated: bool,
1634 pub origin: Vector,
1635 pub targetname: &'a str,
1636}
1637#[derive(Debug, Clone, Deserialize)]
1638pub struct FilterActivatorTfteam<'a> {
1639 #[serde(default)]
1640 pub angles: Option<Angles>,
1641 #[serde(default)]
1642 pub controlpoint: Option<&'a str>,
1643 #[serde(default)]
1644 pub linedivider1: Option<&'a str>,
1645 #[serde(default)]
1646 pub negated: Option<Negated>,
1647 #[serde(default)]
1648 pub onfail: Option<&'a str>,
1649 #[serde(default)]
1650 pub onpass: Option<&'a str>,
1651 pub origin: Vector,
1652 pub targetname: &'a str,
1653 #[serde(default)]
1654 pub teamnum: Option<u8>,
1655}
1656#[derive(Debug, Clone, Deserialize)]
1657pub struct FilterBase<'a> {
1658 #[serde(deserialize_with = "deserialize_bool")]
1659 pub negated: bool,
1660 pub origin: Vector,
1661 pub targetname: &'a str,
1662}
1663#[derive(Debug, Clone, Deserialize)]
1664pub struct FilterDamageType<'a> {
1665 pub damagetype: i32,
1666 pub negated: Negated,
1667 pub origin: Vector,
1668 pub targetname: &'a str,
1669}
1670#[derive(Debug, Clone, Deserialize)]
1671pub struct FilterMulti<'a> {
1672 #[serde(default)]
1673 pub filter01: Option<&'a str>,
1674 #[serde(default)]
1675 pub filter02: Option<&'a str>,
1676 #[serde(default)]
1677 pub filter03: Option<&'a str>,
1678 #[serde(default)]
1679 pub filter04: Option<&'a str>,
1680 #[serde(default)]
1681 pub filter05: Option<&'a str>,
1682 #[serde(deserialize_with = "deserialize_bool")]
1683 pub filtertype: bool,
1684 #[serde(default)]
1685 pub negated: Option<Negated>,
1686 pub origin: Vector,
1687 pub targetname: &'a str,
1688}
1689#[derive(Debug, Clone, Deserialize)]
1690pub struct FilterTfBotHasTag<'a> {
1691 pub negated: Negated,
1692 pub origin: Vector,
1693 #[serde(deserialize_with = "deserialize_bool")]
1694 pub require_all_tags: bool,
1695 pub tags: &'a str,
1696 pub targetname: &'a str,
1697}
1698#[derive(Debug, Clone, Deserialize)]
1699pub struct FilterTfClass<'a> {
1700 pub negated: Negated,
1701 pub origin: Vector,
1702 pub targetname: &'a str,
1703 pub tfclass: i32,
1704}
1705#[derive(Debug, Clone, Deserialize)]
1706pub struct FilterTfCondition<'a> {
1707 pub condition: i32,
1708 #[serde(default)]
1709 pub negated: Option<Negated>,
1710 pub origin: Vector,
1711 pub targetname: &'a str,
1712}
1713#[derive(Debug, Clone, Deserialize)]
1714pub struct FilterTfDamagedByWeaponInSlot<'a> {
1715 pub negated: Negated,
1716 pub origin: Vector,
1717 #[serde(default)]
1718 pub spawnflags: Option<u32>,
1719 pub targetname: &'a str,
1720 pub weaponslot: u8,
1721}
1722#[derive(Debug, Clone, Deserialize)]
1723pub struct FuncAchievement<'a> {
1724 pub model: &'a str,
1725 #[serde(default)]
1726 pub origin: Option<Vector>,
1727 #[serde(default)]
1728 pub parentname: Option<&'a str>,
1729 #[serde(deserialize_with = "deserialize_bool")]
1730 pub startdisabled: bool,
1731 #[serde(default)]
1732 pub targetname: Option<&'a str>,
1733 #[serde(deserialize_with = "deserialize_bool")]
1734 pub teamnum: bool,
1735 #[serde(default)]
1736 pub zone_id: Option<i32>,
1737}
1738#[derive(Debug, Clone, Deserialize)]
1739pub struct FuncAreaportal<'a> {
1740 #[serde(default)]
1741 pub angles: Option<Angles>,
1742 #[serde(default)]
1743 pub origin: Option<Vector>,
1744 pub portalnumber: i32,
1745 #[serde(deserialize_with = "deserialize_bool")]
1746 #[serde(default)]
1747 pub portalversion: bool,
1748 #[serde(deserialize_with = "deserialize_bool")]
1749 pub startopen: bool,
1750 #[serde(default)]
1751 pub target: Option<&'a str>,
1752 #[serde(default)]
1753 pub targetname: Option<&'a str>,
1754}
1755#[derive(Debug, Clone, Deserialize)]
1756pub struct FuncAreaportalwindow<'a> {
1757 #[serde(default)]
1758 pub angles: Option<Angles>,
1759 #[serde(default)]
1760 pub backgroundbmodel: Option<&'a str>,
1761 pub fadedist: u16,
1762 pub fadestartdist: u16,
1763 #[serde(default)]
1764 pub origin: Option<Vector>,
1765 pub portalnumber: i32,
1766 #[serde(deserialize_with = "deserialize_bool")]
1767 pub portalversion: bool,
1768 #[serde(default)]
1769 pub target: Option<&'a str>,
1770 #[serde(default)]
1771 pub targetname: Option<&'a str>,
1772 pub translucencylimit: f32,
1773}
1774#[derive(Debug, Clone, Deserialize)]
1775pub struct FuncBreakable<'a> {
1776 #[serde(default)]
1777 pub angles: Option<Angles>,
1778 #[serde(deserialize_with = "deserialize_bool")]
1779 pub disablereceiveshadows: bool,
1780 #[serde(deserialize_with = "deserialize_bool")]
1781 #[serde(default)]
1782 pub disableshadows: bool,
1783 #[serde(deserialize_with = "deserialize_bool")]
1784 #[serde(default)]
1785 pub effects: bool,
1786 #[serde(deserialize_with = "deserialize_bool")]
1787 #[serde(default)]
1788 pub explodedamage: bool,
1789 #[serde(default)]
1790 pub explodemagnitude: Option<i32>,
1791 #[serde(deserialize_with = "deserialize_bool")]
1792 #[serde(default)]
1793 pub exploderadius: bool,
1794 pub explosion: i32,
1795 pub gibdir: Vector,
1796 pub health: i32,
1797 pub material: i32,
1798 pub minhealthdmg: i32,
1799 pub model: &'a str,
1800 #[serde(deserialize_with = "deserialize_bool")]
1801 #[serde(default)]
1802 pub nodamageforces: bool,
1803 #[serde(default)]
1804 pub onbreak: Option<&'a str>,
1805 pub origin: Vector,
1806 pub performancemode: u8,
1807 pub physdamagescale: f32,
1808 #[serde(deserialize_with = "deserialize_bool")]
1809 #[serde(default)]
1810 pub pressuredelay: bool,
1811 pub propdata: i32,
1812 pub renderamt: i32,
1813 pub rendercolor: Color,
1814 #[serde(deserialize_with = "deserialize_bool")]
1815 pub renderfx: bool,
1816 pub rendermode: u8,
1817 pub spawnflags: u32,
1818 #[serde(default)]
1819 pub spawnobject: Option<i32>,
1820 #[serde(default)]
1821 pub targetname: Option<&'a str>,
1822 #[serde(deserialize_with = "deserialize_bool")]
1823 #[serde(default)]
1824 pub texframeindex: bool,
1825 #[serde(deserialize_with = "deserialize_bool")]
1826 #[serde(default)]
1827 pub vrad_brush_cast_shadows: bool,
1828}
1829#[derive(Debug, Clone, Deserialize)]
1830pub struct FuncBrush<'a> {
1831 #[serde(deserialize_with = "deserialize_bool")]
1832 #[serde(default)]
1833 pub _minlight: bool,
1834 #[serde(default)]
1835 pub angles: Option<Angles>,
1836 #[serde(deserialize_with = "deserialize_bool")]
1837 #[serde(default)]
1838 pub disablereceiveshadows: bool,
1839 #[serde(deserialize_with = "deserialize_bool")]
1840 #[serde(default)]
1841 pub disableshadows: bool,
1842 #[serde(deserialize_with = "deserialize_bool")]
1843 #[serde(default)]
1844 pub effects: bool,
1845 #[serde(default)]
1846 pub inputfilter: Option<u8>,
1847 #[serde(deserialize_with = "deserialize_bool")]
1848 #[serde(default)]
1849 pub invert_exclusion: bool,
1850 #[serde(deserialize_with = "deserialize_bool")]
1851 #[serde(default)]
1852 pub maxdxlevel: bool,
1853 #[serde(deserialize_with = "deserialize_bool")]
1854 #[serde(default)]
1855 pub mindxlevel: bool,
1856 #[serde(default)]
1857 pub model: Option<&'a str>,
1858 #[serde(default)]
1859 pub onfullyopen: Option<&'a str>,
1860 pub origin: Vector,
1861 #[serde(default)]
1862 pub parentname: Option<&'a str>,
1863 pub renderamt: i32,
1864 pub rendercolor: Color,
1865 #[serde(default)]
1866 pub renderfx: Option<u8>,
1867 #[serde(default)]
1868 pub rendermode: Option<u8>,
1869 #[serde(deserialize_with = "deserialize_bool")]
1870 #[serde(default)]
1871 pub solid: bool,
1872 #[serde(deserialize_with = "deserialize_bool")]
1873 #[serde(default)]
1874 pub solidbsp: bool,
1875 #[serde(default)]
1876 pub solidity: Option<u8>,
1877 pub spawnflags: u32,
1878 #[serde(deserialize_with = "deserialize_bool")]
1879 #[serde(default)]
1880 pub startdisabled: bool,
1881 #[serde(default)]
1882 pub targetname: Option<&'a str>,
1883 #[serde(deserialize_with = "deserialize_bool")]
1884 #[serde(default)]
1885 pub texframeindex: bool,
1886 #[serde(deserialize_with = "deserialize_bool")]
1887 #[serde(default)]
1888 pub vrad_brush_cast_shadows: bool,
1889}
1890#[derive(Debug, Clone, Deserialize)]
1891pub struct FuncButton<'a> {
1892 #[serde(default)]
1893 pub angles: Option<Angles>,
1894 #[serde(default)]
1895 pub damagefilter: Option<&'a str>,
1896 #[serde(deserialize_with = "deserialize_bool")]
1897 #[serde(default)]
1898 pub disablereceiveshadows: bool,
1899 #[serde(deserialize_with = "deserialize_bool")]
1900 #[serde(default)]
1901 pub effects: bool,
1902 #[serde(deserialize_with = "deserialize_bool")]
1903 #[serde(default)]
1904 pub health: bool,
1905 pub lip: i32,
1906 #[serde(deserialize_with = "deserialize_bool")]
1907 #[serde(default)]
1908 pub locked_sentence: bool,
1909 #[serde(deserialize_with = "deserialize_bool")]
1910 #[serde(default)]
1911 pub locked_sound: bool,
1912 pub model: &'a str,
1913 pub movedir: Vector,
1914 pub ondamaged: &'a str,
1915 #[serde(default)]
1916 pub onin: Option<&'a str>,
1917 #[serde(default)]
1918 pub onout: Option<&'a str>,
1919 pub onpressed: &'a str,
1920 pub origin: Vector,
1921 #[serde(default)]
1922 pub parentname: Option<&'a str>,
1923 pub renderamt: u8,
1924 pub rendercolor: Color,
1925 #[serde(deserialize_with = "deserialize_bool")]
1926 pub renderfx: bool,
1927 pub rendermode: u8,
1928 #[serde(default)]
1929 pub sounds: Option<i32>,
1930 pub spawnflags: u32,
1931 pub speed: u16,
1932 #[serde(default)]
1933 pub targetname: Option<&'a str>,
1934 #[serde(deserialize_with = "deserialize_bool")]
1935 #[serde(default)]
1936 pub texframeindex: bool,
1937 #[serde(deserialize_with = "deserialize_bool")]
1938 #[serde(default)]
1939 pub unlocked_sentence: bool,
1940 #[serde(deserialize_with = "deserialize_bool")]
1941 #[serde(default)]
1942 pub unlocked_sound: bool,
1943 #[serde(deserialize_with = "deserialize_bool")]
1944 #[serde(default)]
1945 pub vrad_brush_cast_shadows: bool,
1946 pub wait: f32,
1947}
1948#[derive(Debug, Clone, Deserialize)]
1949pub struct FuncCapturezone<'a> {
1950 #[serde(default)]
1951 pub angles: Option<Angles>,
1952 #[serde(default)]
1953 pub capture_delay: Option<f32>,
1954 #[serde(default)]
1955 pub capture_delay_offset: Option<f32>,
1956 #[serde(deserialize_with = "deserialize_bool")]
1957 pub capturepoint: bool,
1958 pub model: &'a str,
1959 #[serde(default)]
1960 pub oncapteam1: Option<&'a str>,
1961 #[serde(default)]
1962 pub oncapteam1_pd: Option<&'a str>,
1963 #[serde(default)]
1964 pub oncapteam2: Option<&'a str>,
1965 #[serde(default)]
1966 pub oncapteam2_pd: Option<&'a str>,
1967 #[serde(default)]
1968 pub oncapture: Option<&'a str>,
1969 #[serde(default)]
1970 pub origin: Option<Vector>,
1971 #[serde(default)]
1972 pub parentname: Option<&'a str>,
1973 #[serde(deserialize_with = "deserialize_bool")]
1974 #[serde(default)]
1975 pub shouldblock: bool,
1976 #[serde(default)]
1977 pub spawnflags: Option<u32>,
1978 #[serde(deserialize_with = "deserialize_bool")]
1979 #[serde(default)]
1980 pub startdisabled: bool,
1981 #[serde(default)]
1982 pub targetname: Option<&'a str>,
1983 pub teamnum: u8,
1984}
1985#[derive(Debug, Clone, Deserialize)]
1986pub struct FuncClipVphysics<'a> {
1987 #[serde(default)]
1988 pub filtername: Option<&'a str>,
1989 pub model: &'a str,
1990 #[serde(default)]
1991 pub origin: Option<Vector>,
1992 #[serde(default)]
1993 pub renderamt: Option<i32>,
1994 #[serde(default)]
1995 pub rendercolor: Option<Color>,
1996 #[serde(deserialize_with = "deserialize_bool")]
1997 pub startdisabled: bool,
1998}
1999#[derive(Debug, Clone, Deserialize)]
2000pub struct FuncCroc<'a> {
2001 #[serde(default)]
2002 pub angles: Option<Angles>,
2003 #[serde(default)]
2004 pub croc_model: Option<&'a str>,
2005 #[serde(default)]
2006 pub filtername: Option<&'a str>,
2007 #[serde(default)]
2008 pub kill_icon: Option<&'a str>,
2009 pub model: &'a str,
2010 #[serde(default)]
2011 pub oneat: Option<&'a str>,
2012 #[serde(default)]
2013 pub origin: Option<Vector>,
2014 #[serde(default)]
2015 pub spawnflags: Option<u32>,
2016 #[serde(deserialize_with = "deserialize_bool")]
2017 #[serde(default)]
2018 pub startdisabled: bool,
2019 #[serde(default)]
2020 pub targetname: Option<&'a str>,
2021 #[serde(deserialize_with = "deserialize_bool")]
2022 #[serde(default)]
2023 pub teamnum: bool,
2024}
2025#[derive(Debug, Clone, Deserialize)]
2026pub struct FuncDetailBlocker<'a> {
2027 pub model: &'a str,
2028}
2029#[derive(Debug, Clone, Deserialize)]
2030pub struct FuncDoor<'a> {
2031 #[serde(deserialize_with = "deserialize_bool")]
2032 #[serde(default)]
2033 pub _minlight: bool,
2034 #[serde(default)]
2035 pub angles: Option<Angles>,
2036 #[serde(default)]
2037 pub closesound: Option<&'a str>,
2038 #[serde(deserialize_with = "deserialize_bool")]
2039 #[serde(default)]
2040 pub disablereceiveshadows: bool,
2041 #[serde(deserialize_with = "deserialize_bool")]
2042 #[serde(default)]
2043 pub disableshadows: bool,
2044 #[serde(default)]
2045 pub dmg: Option<f32>,
2046 #[serde(deserialize_with = "deserialize_bool")]
2047 #[serde(default)]
2048 pub effects: bool,
2049 #[serde(default)]
2050 pub filtername: Option<&'a str>,
2051 #[serde(deserialize_with = "deserialize_bool")]
2052 pub forceclosed: bool,
2053 #[serde(deserialize_with = "deserialize_bool")]
2054 #[serde(default)]
2055 pub health: bool,
2056 #[serde(deserialize_with = "deserialize_bool")]
2057 #[serde(default)]
2058 pub ignoredebris: bool,
2059 #[serde(default)]
2060 pub lip: Option<i32>,
2061 #[serde(deserialize_with = "deserialize_bool")]
2062 #[serde(default)]
2063 pub locked_sentence: bool,
2064 #[serde(deserialize_with = "deserialize_bool")]
2065 pub loopmovesound: bool,
2066 #[serde(deserialize_with = "deserialize_bool")]
2067 #[serde(default)]
2068 pub maxdxlevel: bool,
2069 #[serde(deserialize_with = "deserialize_bool")]
2070 #[serde(default)]
2071 pub mindxlevel: bool,
2072 pub model: &'a str,
2073 pub movedir: Vector,
2074 #[serde(default)]
2075 pub noise1: Option<&'a str>,
2076 #[serde(default)]
2077 pub noise2: Option<&'a str>,
2078 #[serde(default)]
2079 pub onclose: Option<&'a str>,
2080 #[serde(default)]
2081 pub onfullyclosed: Option<&'a str>,
2082 #[serde(default)]
2083 pub onfullyopen: Option<&'a str>,
2084 #[serde(default)]
2085 pub onopen: Option<&'a str>,
2086 pub origin: Vector,
2087 #[serde(default)]
2088 pub parentname: Option<&'a str>,
2089 pub renderamt: u8,
2090 pub rendercolor: Color,
2091 #[serde(deserialize_with = "deserialize_bool")]
2092 pub renderfx: bool,
2093 pub rendermode: u8,
2094 #[serde(deserialize_with = "deserialize_bool")]
2095 #[serde(default)]
2096 pub solid: bool,
2097 pub spawnflags: u32,
2098 #[serde(default)]
2099 pub spawnpos: Option<i32>,
2100 pub speed: f32,
2101 #[serde(default)]
2102 pub startclosesound: Option<&'a str>,
2103 #[serde(default)]
2104 pub targetname: Option<&'a str>,
2105 #[serde(deserialize_with = "deserialize_bool")]
2106 #[serde(default)]
2107 pub texframeindex: bool,
2108 #[serde(deserialize_with = "deserialize_bool")]
2109 #[serde(default)]
2110 pub unlocked_sentence: bool,
2111 #[serde(deserialize_with = "deserialize_bool")]
2112 #[serde(default)]
2113 pub vrad_brush_cast_shadows: bool,
2114 pub wait: f32,
2115}
2116#[derive(Debug, Clone, Deserialize)]
2117pub struct FuncDoorRotating<'a> {
2118 pub angles: Angles,
2119 #[serde(default)]
2120 pub closesound: Option<&'a str>,
2121 #[serde(deserialize_with = "deserialize_bool")]
2122 pub disablereceiveshadows: bool,
2123 #[serde(deserialize_with = "deserialize_bool")]
2124 #[serde(default)]
2125 pub disableshadows: bool,
2126 pub distance: f32,
2127 pub dmg: f32,
2128 #[serde(deserialize_with = "deserialize_bool")]
2129 #[serde(default)]
2130 pub effects: bool,
2131 #[serde(deserialize_with = "deserialize_bool")]
2132 pub forceclosed: bool,
2133 #[serde(deserialize_with = "deserialize_bool")]
2134 #[serde(default)]
2135 pub health: bool,
2136 #[serde(deserialize_with = "deserialize_bool")]
2137 pub ignoredebris: bool,
2138 #[serde(default)]
2139 pub lip: Option<u8>,
2140 #[serde(deserialize_with = "deserialize_bool")]
2141 #[serde(default)]
2142 pub locked_sentence: bool,
2143 #[serde(deserialize_with = "deserialize_bool")]
2144 pub loopmovesound: bool,
2145 pub model: &'a str,
2146 #[serde(default)]
2147 pub noise1: Option<&'a str>,
2148 #[serde(default)]
2149 pub noise2: Option<&'a str>,
2150 #[serde(default)]
2151 pub onclose: Option<&'a str>,
2152 #[serde(default)]
2153 pub onfullyclosed: Option<&'a str>,
2154 #[serde(default)]
2155 pub onfullyopen: Option<&'a str>,
2156 #[serde(default)]
2157 pub onopen: Option<&'a str>,
2158 pub origin: Vector,
2159 #[serde(default)]
2160 pub parentname: Option<&'a str>,
2161 pub renderamt: u8,
2162 pub rendercolor: Color,
2163 #[serde(deserialize_with = "deserialize_bool")]
2164 pub renderfx: bool,
2165 pub rendermode: u8,
2166 #[serde(deserialize_with = "deserialize_bool")]
2167 pub solidbsp: bool,
2168 pub spawnflags: u32,
2169 #[serde(default)]
2170 pub spawnpos: Option<i32>,
2171 pub speed: f32,
2172 #[serde(default)]
2173 pub startclosesound: Option<&'a str>,
2174 pub targetname: &'a str,
2175 #[serde(deserialize_with = "deserialize_bool")]
2176 #[serde(default)]
2177 pub texframeindex: bool,
2178 #[serde(deserialize_with = "deserialize_bool")]
2179 #[serde(default)]
2180 pub unlocked_sentence: bool,
2181 #[serde(deserialize_with = "deserialize_bool")]
2182 #[serde(default)]
2183 pub vrad_brush_cast_shadows: bool,
2184 pub wait: i32,
2185}
2186#[derive(Debug, Clone, Deserialize)]
2187pub struct FuncDustcloud<'a> {
2188 pub alpha: u8,
2189 pub color: Color,
2190 pub distmax: u16,
2191 #[serde(deserialize_with = "deserialize_bool")]
2192 pub frozen: bool,
2193 pub lifetimemax: u8,
2194 pub lifetimemin: u8,
2195 pub model: &'a str,
2196 pub sizemax: u8,
2197 pub sizemin: u8,
2198 pub spawnrate: u8,
2199 pub speedmax: u16,
2200 #[serde(deserialize_with = "deserialize_bool")]
2201 pub startdisabled: bool,
2202 pub targetname: &'a str,
2203}
2204#[derive(Debug, Clone, Deserialize)]
2205pub struct FuncDustmotes<'a> {
2206 pub alpha: u8,
2207 #[serde(default)]
2208 pub angles: Option<Angles>,
2209 pub color: Color,
2210 pub distmax: u16,
2211 #[serde(default)]
2212 pub fallspeed: Option<i32>,
2213 #[serde(deserialize_with = "deserialize_bool")]
2214 pub frozen: bool,
2215 pub lifetimemax: f32,
2216 pub lifetimemin: f32,
2217 pub model: &'a str,
2218 #[serde(default)]
2219 pub origin: Option<Vector>,
2220 pub sizemax: u16,
2221 pub sizemin: u8,
2222 pub spawnrate: u16,
2223 pub speedmax: u8,
2224 #[serde(deserialize_with = "deserialize_bool")]
2225 #[serde(default)]
2226 pub startdisabled: bool,
2227}
2228#[derive(Debug, Clone, Deserialize)]
2229pub struct FuncFishPool<'a> {
2230 pub fish_count: i32,
2231 pub max_range: u8,
2232 pub model: &'a str,
2233 pub origin: Vector,
2234}
2235#[derive(Debug, Clone, Deserialize)]
2236pub struct FuncFlagAlert<'a> {
2237 pub alert_delay: i32,
2238 pub model: &'a str,
2239 #[serde(deserialize_with = "deserialize_bool")]
2240 pub playsound: bool,
2241 #[serde(deserialize_with = "deserialize_bool")]
2242 pub startdisabled: bool,
2243 pub targetname: &'a str,
2244 #[serde(deserialize_with = "deserialize_bool")]
2245 pub teamnum: bool,
2246}
2247#[derive(Debug, Clone, Deserialize)]
2248pub struct FuncFlagdetectionzone<'a> {
2249 #[serde(deserialize_with = "deserialize_bool")]
2250 #[serde(default)]
2251 pub alarm: bool,
2252 pub model: &'a str,
2253 #[serde(default)]
2254 pub onendtouchflag: Option<&'a str>,
2255 pub onstarttouchflag: &'a str,
2256 #[serde(default)]
2257 pub origin: Option<Vector>,
2258 #[serde(default)]
2259 pub parentname: Option<&'a str>,
2260 #[serde(deserialize_with = "deserialize_bool")]
2261 pub startdisabled: bool,
2262 #[serde(default)]
2263 pub targetname: Option<&'a str>,
2264 pub teamnum: u8,
2265}
2266#[derive(Debug, Clone, Deserialize)]
2267pub struct FuncIllusionary<'a> {
2268 #[serde(default)]
2269 pub angles: Option<Angles>,
2270 #[serde(deserialize_with = "deserialize_bool")]
2271 #[serde(default)]
2272 pub disablereceiveshadows: bool,
2273 #[serde(deserialize_with = "deserialize_bool")]
2274 #[serde(default)]
2275 pub disableshadows: bool,
2276 #[serde(deserialize_with = "deserialize_bool")]
2277 #[serde(default)]
2278 pub effects: bool,
2279 #[serde(default)]
2280 pub fademaxdist: Option<i32>,
2281 #[serde(default)]
2282 pub fademindist: Option<i32>,
2283 #[serde(deserialize_with = "deserialize_bool")]
2284 #[serde(default)]
2285 pub maxdxlevel: bool,
2286 #[serde(deserialize_with = "deserialize_bool")]
2287 #[serde(default)]
2288 pub mindxlevel: bool,
2289 #[serde(default)]
2290 pub model: Option<&'a str>,
2291 pub origin: Vector,
2292 pub renderamt: i32,
2293 pub rendercolor: Color,
2294 #[serde(deserialize_with = "deserialize_bool")]
2295 #[serde(default)]
2296 pub renderfx: bool,
2297 #[serde(default)]
2298 pub rendermode: Option<u8>,
2299 #[serde(default)]
2300 pub spawnflags: Option<u32>,
2301 #[serde(default)]
2302 pub targetname: Option<&'a str>,
2303 #[serde(deserialize_with = "deserialize_bool")]
2304 #[serde(default)]
2305 pub texframeindex: bool,
2306 #[serde(deserialize_with = "deserialize_bool")]
2307 #[serde(default)]
2308 pub vrad_brush_cast_shadows: bool,
2309}
2310#[derive(Debug, Clone, Deserialize)]
2311pub struct FuncLod<'a> {
2312 #[serde(default)]
2313 pub angles: Option<Angles>,
2314 pub disappeardist: u16,
2315 #[serde(default)]
2316 pub model: Option<&'a str>,
2317 #[serde(default)]
2318 pub origin: Option<Vector>,
2319 #[serde(default)]
2320 pub renderamt: Option<i32>,
2321 #[serde(default)]
2322 pub rendercolor: Option<Color>,
2323 #[serde(deserialize_with = "deserialize_bool")]
2324 #[serde(default)]
2325 pub solid: bool,
2326 #[serde(deserialize_with = "deserialize_bool")]
2327 #[serde(default)]
2328 pub vrad_brush_cast_shadows: bool,
2329}
2330#[derive(Debug, Clone, Deserialize)]
2331pub struct FuncMonitor<'a> {
2332 pub angles: Angles,
2333 #[serde(deserialize_with = "deserialize_bool")]
2334 pub disablereceiveshadows: bool,
2335 #[serde(deserialize_with = "deserialize_bool")]
2336 pub effects: bool,
2337 #[serde(deserialize_with = "deserialize_bool")]
2338 pub invert_exclusion: bool,
2339 pub model: &'a str,
2340 pub origin: Vector,
2341 pub renderamt: u8,
2342 pub rendercolor: Color,
2343 #[serde(deserialize_with = "deserialize_bool")]
2344 pub renderfx: bool,
2345 #[serde(deserialize_with = "deserialize_bool")]
2346 pub rendermode: bool,
2347 #[serde(deserialize_with = "deserialize_bool")]
2348 pub solidbsp: bool,
2349 #[serde(deserialize_with = "deserialize_bool")]
2350 pub solidity: bool,
2351 pub spawnflags: u32,
2352 #[serde(deserialize_with = "deserialize_bool")]
2353 pub startdisabled: bool,
2354 pub target: &'a str,
2355 #[serde(deserialize_with = "deserialize_bool")]
2356 pub texframeindex: bool,
2357 #[serde(deserialize_with = "deserialize_bool")]
2358 pub vrad_brush_cast_shadows: bool,
2359}
2360#[derive(Debug, Clone, Deserialize)]
2361pub struct FuncMovelinear<'a> {
2362 #[serde(default)]
2363 pub angles: Option<Angles>,
2364 pub blockdamage: u16,
2365 #[serde(deserialize_with = "deserialize_bool")]
2366 pub disablereceiveshadows: bool,
2367 pub model: &'a str,
2368 pub movedir: Vector,
2369 pub movedistance: u16,
2370 #[serde(default)]
2371 pub onfullyclosed: Option<&'a str>,
2372 pub onfullyopen: &'a str,
2373 pub origin: Vector,
2374 pub renderamt: u8,
2375 pub rendercolor: Color,
2376 #[serde(deserialize_with = "deserialize_bool")]
2377 pub renderfx: bool,
2378 pub rendermode: u8,
2379 pub spawnflags: u32,
2380 pub speed: u16,
2381 #[serde(deserialize_with = "deserialize_bool")]
2382 pub startposition: bool,
2383 #[serde(default)]
2384 pub startsound: Option<&'a str>,
2385 #[serde(default)]
2386 pub stopsound: Option<&'a str>,
2387 #[serde(default)]
2388 pub targetname: Option<&'a str>,
2389}
2390#[derive(Debug, Clone, Deserialize)]
2391pub struct FuncNavAvoid<'a> {
2392 #[serde(default)]
2393 pub angles: Option<Angles>,
2394 #[serde(default)]
2395 pub avoid_groups: Option<&'a str>,
2396 pub model: &'a str,
2397 #[serde(default)]
2398 pub origin: Option<Vector>,
2399 #[serde(deserialize_with = "deserialize_bool")]
2400 pub start_disabled: bool,
2401 #[serde(default)]
2402 pub tags: Option<&'a str>,
2403 #[serde(default)]
2404 pub targetname: Option<&'a str>,
2405 pub team: i32,
2406}
2407#[derive(Debug, Clone, Deserialize)]
2408pub struct FuncNavBlocker<'a> {
2409 #[serde(deserialize_with = "deserialize_bool")]
2410 pub affectsflow: bool,
2411 #[serde(default)]
2412 pub angles: Option<Angles>,
2413 #[serde(deserialize_with = "deserialize_bool")]
2414 #[serde(default)]
2415 pub effects: bool,
2416 pub model: &'a str,
2417 #[serde(default)]
2418 pub origin: Option<Vector>,
2419 #[serde(deserialize_with = "deserialize_bool")]
2420 #[serde(default)]
2421 pub startdisabled: bool,
2422 pub teamtoblock: i32,
2423}
2424#[derive(Debug, Clone, Deserialize)]
2425pub struct FuncNavPrefer<'a> {
2426 pub model: &'a str,
2427 #[serde(deserialize_with = "deserialize_bool")]
2428 pub start_disabled: bool,
2429 pub tags: &'a str,
2430 #[serde(default)]
2431 pub targetname: Option<&'a str>,
2432 pub team: i32,
2433}
2434#[derive(Debug, Clone, Deserialize)]
2435pub struct FuncNavPrerequisite<'a> {
2436 pub entity: &'a str,
2437 pub filtername: &'a str,
2438 pub model: &'a str,
2439 pub origin: Vector,
2440 pub spawnflags: u32,
2441 #[serde(deserialize_with = "deserialize_bool")]
2442 pub start_disabled: bool,
2443 #[serde(deserialize_with = "deserialize_bool")]
2444 pub startdisabled: bool,
2445 pub targetname: &'a str,
2446 pub task: u8,
2447 #[serde(deserialize_with = "deserialize_bool")]
2448 #[serde(default)]
2449 pub value: bool,
2450}
2451#[derive(Debug, Clone, Deserialize)]
2452pub struct FuncNobuild<'a> {
2453 #[serde(deserialize_with = "deserialize_bool")]
2454 #[serde(default)]
2455 pub allowdispenser: bool,
2456 #[serde(deserialize_with = "deserialize_bool")]
2457 #[serde(default)]
2458 pub allowsentry: bool,
2459 #[serde(deserialize_with = "deserialize_bool")]
2460 #[serde(default)]
2461 pub allowteleporters: bool,
2462 #[serde(default)]
2463 pub angles: Option<Angles>,
2464 #[serde(deserialize_with = "deserialize_bool")]
2465 #[serde(default)]
2466 pub destroybuildings: bool,
2467 #[serde(deserialize_with = "deserialize_bool")]
2468 #[serde(default)]
2469 pub effects: bool,
2470 pub model: &'a str,
2471 #[serde(default)]
2472 pub onendtouchall: Option<&'a str>,
2473 #[serde(default)]
2474 pub onstarttouch: Option<&'a str>,
2475 #[serde(default)]
2476 pub origin: Option<Vector>,
2477 #[serde(default)]
2478 pub parentname: Option<&'a str>,
2479 #[serde(default)]
2480 pub spawnflags: Option<u32>,
2481 #[serde(deserialize_with = "deserialize_bool")]
2482 #[serde(default)]
2483 pub startdisabled: bool,
2484 #[serde(default)]
2485 pub targetname: Option<&'a str>,
2486 #[serde(default)]
2487 pub teamnum: Option<u8>,
2488}
2489#[derive(Debug, Clone, Deserialize)]
2490pub struct FuncNogrenades<'a> {
2491 #[serde(default)]
2492 pub angles: Option<Angles>,
2493 #[serde(default)]
2494 pub filtername: Option<&'a str>,
2495 pub model: &'a str,
2496 #[serde(default)]
2497 pub origin: Option<Vector>,
2498 #[serde(default)]
2499 pub spawnflags: Option<u32>,
2500 #[serde(deserialize_with = "deserialize_bool")]
2501 pub startdisabled: bool,
2502 #[serde(default)]
2503 pub targetname: Option<&'a str>,
2504 pub teamnum: u8,
2505}
2506#[derive(Debug, Clone, Deserialize)]
2507pub struct FuncOccluder<'a> {
2508 #[serde(default)]
2509 pub angles: Option<Angles>,
2510 pub model: &'a str,
2511 pub occludernumber: i32,
2512 #[serde(default)]
2513 pub origin: Option<Vector>,
2514 #[serde(deserialize_with = "deserialize_bool")]
2515 pub startactive: bool,
2516 #[serde(default)]
2517 pub targetname: Option<&'a str>,
2518}
2519#[derive(Debug, Clone, Deserialize)]
2520pub struct FuncPasstimeGoal<'a> {
2521 pub model: &'a str,
2522 pub onscoreblu: &'a str,
2523 pub onscorered: &'a str,
2524 pub origin: Vector,
2525 pub points: i32,
2526 pub spawnflags: u32,
2527 #[serde(deserialize_with = "deserialize_bool")]
2528 pub startdisabled: bool,
2529 #[serde(default)]
2530 pub targetname: Option<&'a str>,
2531 pub teamnum: u8,
2532}
2533#[derive(Debug, Clone, Deserialize)]
2534pub struct FuncPasstimeGoalieZone<'a> {
2535 pub model: &'a str,
2536 #[serde(deserialize_with = "deserialize_bool")]
2537 pub startdisabled: bool,
2538 pub teamnum: u8,
2539}
2540#[derive(Debug, Clone, Deserialize)]
2541pub struct FuncPasstimeNoBallZone<'a> {
2542 pub model: &'a str,
2543}
2544#[derive(Debug, Clone, Deserialize)]
2545pub struct FuncPhysbox<'a> {
2546 #[serde(default)]
2547 pub angles: Option<Angles>,
2548 pub damagetoenablemotion: i32,
2549 #[serde(deserialize_with = "deserialize_bool")]
2550 pub damagetype: bool,
2551 #[serde(deserialize_with = "deserialize_bool")]
2552 pub disablereceiveshadows: bool,
2553 #[serde(deserialize_with = "deserialize_bool")]
2554 pub disableshadows: bool,
2555 #[serde(deserialize_with = "deserialize_bool")]
2556 pub explodedamage: bool,
2557 pub explodemagnitude: i32,
2558 #[serde(deserialize_with = "deserialize_bool")]
2559 pub exploderadius: bool,
2560 pub explosion: i32,
2561 pub forcetoenablemotion: f32,
2562 pub gibdir: Vector,
2563 #[serde(deserialize_with = "deserialize_bool")]
2564 pub health: bool,
2565 #[serde(deserialize_with = "deserialize_bool")]
2566 pub massscale: bool,
2567 pub material: i32,
2568 pub model: &'a str,
2569 #[serde(deserialize_with = "deserialize_bool")]
2570 pub nodamageforces: bool,
2571 #[serde(deserialize_with = "deserialize_bool")]
2572 pub notsolid: bool,
2573 pub origin: Vector,
2574 #[serde(deserialize_with = "deserialize_bool")]
2575 pub performancemode: bool,
2576 #[serde(default)]
2577 pub physdamagescale: Option<f32>,
2578 pub preferredcarryangles: Vector,
2579 #[serde(deserialize_with = "deserialize_bool")]
2580 pub pressuredelay: bool,
2581 pub propdata: i32,
2582 pub renderamt: u8,
2583 pub rendercolor: Color,
2584 #[serde(deserialize_with = "deserialize_bool")]
2585 pub renderfx: bool,
2586 #[serde(deserialize_with = "deserialize_bool")]
2587 pub rendermode: bool,
2588 pub spawnflags: u32,
2589 pub spawnobject: i32,
2590 pub targetname: &'a str,
2591}
2592#[derive(Debug, Clone, Deserialize)]
2593pub struct FuncPhysboxMultiplayer<'a> {
2594 #[serde(default)]
2595 pub _minlight: Option<f32>,
2596 #[serde(default)]
2597 pub angles: Option<Angles>,
2598 pub damagetoenablemotion: i32,
2599 #[serde(deserialize_with = "deserialize_bool")]
2600 pub damagetype: bool,
2601 #[serde(deserialize_with = "deserialize_bool")]
2602 pub disablereceiveshadows: bool,
2603 #[serde(deserialize_with = "deserialize_bool")]
2604 #[serde(default)]
2605 pub disableshadows: bool,
2606 #[serde(deserialize_with = "deserialize_bool")]
2607 #[serde(default)]
2608 pub effects: bool,
2609 #[serde(deserialize_with = "deserialize_bool")]
2610 #[serde(default)]
2611 pub explodedamage: bool,
2612 #[serde(deserialize_with = "deserialize_bool")]
2613 #[serde(default)]
2614 pub explodemagnitude: bool,
2615 #[serde(deserialize_with = "deserialize_bool")]
2616 #[serde(default)]
2617 pub exploderadius: bool,
2618 #[serde(deserialize_with = "deserialize_bool")]
2619 pub explosion: bool,
2620 #[serde(default)]
2621 pub forcetoenablemotion: Option<f32>,
2622 pub gibdir: Angles,
2623 #[serde(deserialize_with = "deserialize_bool")]
2624 pub health: bool,
2625 pub massscale: u8,
2626 pub material: u8,
2627 #[serde(deserialize_with = "deserialize_bool")]
2628 #[serde(default)]
2629 pub minhealthdmg: bool,
2630 pub model: &'a str,
2631 #[serde(deserialize_with = "deserialize_bool")]
2632 pub nodamageforces: bool,
2633 #[serde(deserialize_with = "deserialize_bool")]
2634 pub notsolid: bool,
2635 #[serde(default)]
2636 pub ondamaged: Option<&'a str>,
2637 pub origin: Vector,
2638 #[serde(deserialize_with = "deserialize_bool")]
2639 pub performancemode: bool,
2640 #[serde(default)]
2641 pub physdamagescale: Option<f32>,
2642 pub preferredcarryangles: Vector,
2643 #[serde(deserialize_with = "deserialize_bool")]
2644 #[serde(default)]
2645 pub pressuredelay: bool,
2646 pub propdata: u8,
2647 pub renderamt: u8,
2648 pub rendercolor: Color,
2649 #[serde(deserialize_with = "deserialize_bool")]
2650 pub renderfx: bool,
2651 #[serde(deserialize_with = "deserialize_bool")]
2652 pub rendermode: bool,
2653 pub spawnflags: u32,
2654 #[serde(deserialize_with = "deserialize_bool")]
2655 #[serde(default)]
2656 pub spawnobject: bool,
2657 #[serde(default)]
2658 pub targetname: Option<&'a str>,
2659 #[serde(deserialize_with = "deserialize_bool")]
2660 #[serde(default)]
2661 pub texframeindex: bool,
2662 #[serde(deserialize_with = "deserialize_bool")]
2663 #[serde(default)]
2664 pub vrad_brush_cast_shadows: bool,
2665}
2666#[derive(Debug, Clone, Deserialize)]
2667pub struct FuncPowerupvolume<'a> {
2668 #[serde(default)]
2669 pub filtername: Option<&'a str>,
2670 pub model: &'a str,
2671 pub origin: Vector,
2672 pub spawnflags: u32,
2673 #[serde(deserialize_with = "deserialize_bool")]
2674 pub startdisabled: bool,
2675 pub targetname: &'a str,
2676 pub teamnum: u8,
2677}
2678#[derive(Debug, Clone, Deserialize)]
2679pub struct FuncPrecipitation<'a> {
2680 pub model: &'a str,
2681 pub preciptype: i32,
2682 pub renderamt: i32,
2683 pub rendercolor: Color,
2684 #[serde(default)]
2685 pub targetname: Option<&'a str>,
2686}
2687#[derive(Debug, Clone, Deserialize)]
2688pub struct FuncRegenerate<'a> {
2689 #[serde(default)]
2690 pub angles: Option<Angles>,
2691 #[serde(default)]
2692 pub associatedmodel: Option<&'a str>,
2693 pub model: &'a str,
2694 #[serde(default)]
2695 pub onendtouchall: Option<&'a str>,
2696 #[serde(default)]
2697 pub origin: Option<Vector>,
2698 #[serde(default)]
2699 pub parentname: Option<&'a str>,
2700 #[serde(deserialize_with = "deserialize_bool")]
2701 #[serde(default)]
2702 pub solid: bool,
2703 #[serde(default)]
2704 pub spawnflags: Option<u32>,
2705 #[serde(deserialize_with = "deserialize_bool")]
2706 #[serde(default)]
2707 pub startdisabled: bool,
2708 #[serde(default)]
2709 pub targetname: Option<&'a str>,
2710 #[serde(default)]
2711 pub teamnum: Option<u8>,
2712}
2713#[derive(Debug, Clone, Deserialize)]
2714pub struct FuncRespawnflag<'a> {
2715 #[serde(default)]
2716 pub angles: Option<Angles>,
2717 pub model: &'a str,
2718 #[serde(default)]
2719 pub origin: Option<Vector>,
2720 #[serde(default)]
2721 pub spawnflags: Option<u32>,
2722 #[serde(deserialize_with = "deserialize_bool")]
2723 pub startdisabled: bool,
2724 #[serde(default)]
2725 pub targetname: Option<&'a str>,
2726}
2727#[derive(Debug, Clone, Deserialize)]
2728pub struct FuncRespawnroom<'a> {
2729 #[serde(default)]
2730 pub angles: Option<Angles>,
2731 #[serde(default)]
2732 pub filtername: Option<&'a str>,
2733 pub model: &'a str,
2734 #[serde(default)]
2735 pub onstarttouch: Option<&'a str>,
2736 #[serde(default)]
2737 pub origin: Option<Vector>,
2738 #[serde(deserialize_with = "deserialize_bool")]
2739 #[serde(default)]
2740 pub rendermode: bool,
2741 #[serde(deserialize_with = "deserialize_bool")]
2742 #[serde(default)]
2743 pub solid: bool,
2744 #[serde(default)]
2745 pub spawnflags: Option<u32>,
2746 #[serde(deserialize_with = "deserialize_bool")]
2747 #[serde(default)]
2748 pub startdisabled: bool,
2749 #[serde(default)]
2750 pub targetname: Option<&'a str>,
2751 pub teamnum: u8,
2752}
2753#[derive(Debug, Clone, Deserialize)]
2754pub struct FuncRespawnroomvisualizer<'a> {
2755 #[serde(default)]
2756 pub angles: Option<Angles>,
2757 #[serde(deserialize_with = "deserialize_bool")]
2758 #[serde(default)]
2759 pub disablereceiveshadows: bool,
2760 #[serde(deserialize_with = "deserialize_bool")]
2761 #[serde(default)]
2762 pub disableshadows: bool,
2763 #[serde(deserialize_with = "deserialize_bool")]
2764 #[serde(default)]
2765 pub effects: bool,
2766 #[serde(default)]
2767 pub inputfilter: Option<u8>,
2768 #[serde(deserialize_with = "deserialize_bool")]
2769 #[serde(default)]
2770 pub invert_exclusion: bool,
2771 #[serde(deserialize_with = "deserialize_bool")]
2772 #[serde(default)]
2773 pub maxdxlevel: bool,
2774 #[serde(deserialize_with = "deserialize_bool")]
2775 #[serde(default)]
2776 pub mindxlevel: bool,
2777 pub model: &'a str,
2778 #[serde(default)]
2779 pub onclose: Option<&'a str>,
2780 #[serde(default)]
2781 pub onopen: Option<&'a str>,
2782 pub origin: Vector,
2783 pub renderamt: u8,
2784 pub rendercolor: Color,
2785 #[serde(deserialize_with = "deserialize_bool")]
2786 pub renderfx: bool,
2787 pub rendermode: u8,
2788 #[serde(default)]
2789 pub respawnroomname: Option<&'a str>,
2790 #[serde(deserialize_with = "deserialize_bool")]
2791 #[serde(default)]
2792 pub solid: bool,
2793 #[serde(deserialize_with = "deserialize_bool")]
2794 #[serde(default)]
2795 pub solid_to_enemies: bool,
2796 #[serde(deserialize_with = "deserialize_bool")]
2797 #[serde(default)]
2798 pub solidbsp: bool,
2799 #[serde(deserialize_with = "deserialize_bool")]
2800 pub solidity: bool,
2801 pub spawnflags: u32,
2802 #[serde(deserialize_with = "deserialize_bool")]
2803 pub startdisabled: bool,
2804 #[serde(default)]
2805 pub targetname: Option<&'a str>,
2806 #[serde(default)]
2807 pub teamnum: Option<u8>,
2808 #[serde(deserialize_with = "deserialize_bool")]
2809 #[serde(default)]
2810 pub texframeindex: bool,
2811 #[serde(deserialize_with = "deserialize_bool")]
2812 pub vrad_brush_cast_shadows: bool,
2813}
2814#[derive(Debug, Clone, Deserialize)]
2815pub struct FuncRotating<'a> {
2816 pub angles: Angles,
2817 #[serde(deserialize_with = "deserialize_bool")]
2818 pub disablereceiveshadows: bool,
2819 #[serde(deserialize_with = "deserialize_bool")]
2820 #[serde(default)]
2821 pub disableshadows: bool,
2822 #[serde(default)]
2823 pub dmg: Option<f32>,
2824 #[serde(deserialize_with = "deserialize_bool")]
2825 #[serde(default)]
2826 pub effects: bool,
2827 pub fanfriction: u8,
2828 pub maxspeed: f32,
2829 #[serde(default)]
2830 pub message: Option<&'a str>,
2831 pub model: &'a str,
2832 pub origin: Vector,
2833 #[serde(default)]
2834 pub parentname: Option<&'a str>,
2835 pub renderamt: i32,
2836 pub rendercolor: Color,
2837 #[serde(deserialize_with = "deserialize_bool")]
2838 pub renderfx: bool,
2839 pub rendermode: u8,
2840 #[serde(deserialize_with = "deserialize_bool")]
2841 pub solidbsp: bool,
2842 pub spawnflags: u32,
2843 #[serde(default)]
2844 pub targetname: Option<&'a str>,
2845 #[serde(deserialize_with = "deserialize_bool")]
2846 #[serde(default)]
2847 pub texframeindex: bool,
2848 pub volume: u8,
2849 #[serde(deserialize_with = "deserialize_bool")]
2850 #[serde(default)]
2851 pub vrad_brush_cast_shadows: bool,
2852}
2853#[derive(Debug, Clone, Deserialize)]
2854pub struct FuncSmokevolume<'a> {
2855 #[serde(default)]
2856 pub angles: Option<Angles>,
2857 pub color1: Color,
2858 pub color2: Color,
2859 pub density: f32,
2860 pub densityrampspeed: u8,
2861 pub material: &'a str,
2862 pub model: &'a str,
2863 pub movementspeed: u8,
2864 pub particledrawwidth: u8,
2865 pub particlespacingdistance: u8,
2866 pub rotationspeed: u8,
2867 #[serde(default)]
2868 pub spawnflags: Option<u32>,
2869}
2870#[derive(Debug, Clone, Deserialize)]
2871pub struct FuncSuggestedBuild<'a> {
2872 #[serde(default)]
2873 pub face_entity: Option<&'a str>,
2874 pub face_entity_fov: f32,
2875 pub model: &'a str,
2876 pub object_type: i32,
2877 #[serde(default)]
2878 pub onbuildingupgraded: Option<&'a str>,
2879 pub onbuildinsidearea: &'a str,
2880 #[serde(default)]
2881 pub onbuildnotfacing: Option<&'a str>,
2882 pub origin: Vector,
2883 pub spawnflags: u32,
2884 #[serde(deserialize_with = "deserialize_bool")]
2885 pub startdisabled: bool,
2886 pub targetname: &'a str,
2887 pub teamnum: u8,
2888}
2889#[derive(Debug, Clone, Deserialize)]
2890pub struct FuncTanktrain<'a> {
2891 pub bank: f32,
2892 #[serde(deserialize_with = "deserialize_bool")]
2893 pub disablereceiveshadows: bool,
2894 #[serde(deserialize_with = "deserialize_bool")]
2895 pub disableshadows: bool,
2896 pub dmg: f32,
2897 pub health: u32,
2898 pub height: f32,
2899 pub model: &'a str,
2900 pub movesoundmaxpitch: u8,
2901 #[serde(deserialize_with = "deserialize_bool")]
2902 pub movesoundmaxtime: bool,
2903 pub movesoundminpitch: u8,
2904 #[serde(deserialize_with = "deserialize_bool")]
2905 pub movesoundmintime: bool,
2906 pub orientationtype: i32,
2907 pub origin: Vector,
2908 pub renderamt: u8,
2909 pub rendercolor: Color,
2910 #[serde(deserialize_with = "deserialize_bool")]
2911 pub renderfx: bool,
2912 pub rendermode: u8,
2913 pub spawnflags: u32,
2914 pub speed: u16,
2915 pub startspeed: f32,
2916 pub target: &'a str,
2917 pub targetname: &'a str,
2918 pub velocitytype: i32,
2919 pub volume: i32,
2920 pub wheels: f32,
2921}
2922#[derive(Debug, Clone, Deserialize)]
2923pub struct FuncTfbotHint<'a> {
2924 pub hint: i32,
2925 pub model: &'a str,
2926 pub origin: Vector,
2927 #[serde(deserialize_with = "deserialize_bool")]
2928 pub startdisabled: bool,
2929 #[serde(default)]
2930 pub targetname: Option<&'a str>,
2931 pub team: i32,
2932}
2933#[derive(Debug, Clone, Deserialize)]
2934pub struct FuncTracktrain<'a> {
2935 #[serde(deserialize_with = "deserialize_bool")]
2936 #[serde(default)]
2937 pub _minlight: bool,
2938 #[serde(default)]
2939 pub angles: Option<Angles>,
2940 pub bank: f32,
2941 #[serde(deserialize_with = "deserialize_bool")]
2942 #[serde(default)]
2943 pub disablereceiveshadows: bool,
2944 #[serde(deserialize_with = "deserialize_bool")]
2945 #[serde(default)]
2946 pub disableshadows: bool,
2947 #[serde(default)]
2948 pub dmg: Option<f32>,
2949 #[serde(deserialize_with = "deserialize_bool")]
2950 #[serde(default)]
2951 pub effects: bool,
2952 pub height: f32,
2953 #[serde(default)]
2954 pub manualaccelspeed: Option<u8>,
2955 #[serde(default)]
2956 pub manualdecelspeed: Option<u8>,
2957 #[serde(deserialize_with = "deserialize_bool")]
2958 #[serde(default)]
2959 pub manualspeedchanges: bool,
2960 #[serde(deserialize_with = "deserialize_bool")]
2961 #[serde(default)]
2962 pub maxdxlevel: bool,
2963 #[serde(deserialize_with = "deserialize_bool")]
2964 #[serde(default)]
2965 pub mindxlevel: bool,
2966 pub model: &'a str,
2967 #[serde(default)]
2968 pub movesound: Option<&'a str>,
2969 pub movesoundmaxpitch: u16,
2970 #[serde(deserialize_with = "deserialize_bool")]
2971 pub movesoundmaxtime: bool,
2972 pub movesoundminpitch: u8,
2973 #[serde(deserialize_with = "deserialize_bool")]
2974 pub movesoundmintime: bool,
2975 #[serde(default)]
2976 pub onnext: Option<&'a str>,
2977 #[serde(default)]
2978 pub onstart: Option<&'a str>,
2979 #[serde(default)]
2980 pub onuser1: Option<&'a str>,
2981 #[serde(default)]
2982 pub onuser2: Option<&'a str>,
2983 #[serde(default)]
2984 pub onuser3: Option<&'a str>,
2985 #[serde(default)]
2986 pub onuser4: Option<&'a str>,
2987 pub orientationtype: i32,
2988 pub origin: Vector,
2989 pub renderamt: i32,
2990 pub rendercolor: Color,
2991 #[serde(deserialize_with = "deserialize_bool")]
2992 pub renderfx: bool,
2993 pub rendermode: u8,
2994 pub spawnflags: u32,
2995 pub speed: u8,
2996 #[serde(default)]
2997 pub startsound: Option<&'a str>,
2998 pub startspeed: f32,
2999 #[serde(default)]
3000 pub stopsound: Option<&'a str>,
3001 #[serde(default)]
3002 pub target: Option<&'a str>,
3003 pub targetname: &'a str,
3004 #[serde(deserialize_with = "deserialize_bool")]
3005 #[serde(default)]
3006 pub texframeindex: bool,
3007 pub velocitytype: i32,
3008 pub volume: i32,
3009 #[serde(deserialize_with = "deserialize_bool")]
3010 #[serde(default)]
3011 pub vrad_brush_cast_shadows: bool,
3012 pub wheels: f32,
3013}
3014#[derive(Debug, Clone, Deserialize)]
3015pub struct FuncUpgradestation<'a> {
3016 #[serde(default)]
3017 pub angles: Option<Angles>,
3018 pub model: &'a str,
3019 #[serde(default)]
3020 pub onendtouch: Option<&'a str>,
3021 #[serde(default)]
3022 pub onstarttouch: Option<&'a str>,
3023 #[serde(default)]
3024 pub origin: Option<Vector>,
3025 #[serde(deserialize_with = "deserialize_bool")]
3026 #[serde(default)]
3027 pub startdisabled: bool,
3028 #[serde(default)]
3029 pub targetname: Option<&'a str>,
3030}
3031#[derive(Debug, Clone, Deserialize)]
3032pub struct FuncWall<'a> {
3033 #[serde(deserialize_with = "deserialize_bool")]
3034 pub disablereceiveshadows: bool,
3035 #[serde(deserialize_with = "deserialize_bool")]
3036 pub disableshadows: bool,
3037 pub model: &'a str,
3038 pub renderamt: i32,
3039 pub rendercolor: Color,
3040 #[serde(deserialize_with = "deserialize_bool")]
3041 pub renderfx: bool,
3042 #[serde(deserialize_with = "deserialize_bool")]
3043 pub rendermode: bool,
3044}
3045#[derive(Debug, Clone, Deserialize)]
3046pub struct FuncWallToggle<'a> {
3047 #[serde(deserialize_with = "deserialize_bool")]
3048 pub disablereceiveshadows: bool,
3049 #[serde(deserialize_with = "deserialize_bool")]
3050 pub disableshadows: bool,
3051 pub model: &'a str,
3052 pub renderamt: u8,
3053 pub rendercolor: Color,
3054 #[serde(deserialize_with = "deserialize_bool")]
3055 pub renderfx: bool,
3056 #[serde(deserialize_with = "deserialize_bool")]
3057 pub rendermode: bool,
3058 pub spawnflags: u32,
3059 pub targetname: &'a str,
3060}
3061#[derive(Debug, Clone, Deserialize)]
3062pub struct FuncWaterAnalog<'a> {
3063 pub angles: Angles,
3064 #[serde(deserialize_with = "deserialize_bool")]
3065 #[serde(default)]
3066 pub blockdamage: bool,
3067 #[serde(deserialize_with = "deserialize_bool")]
3068 #[serde(default)]
3069 pub disablereceiveshadows: bool,
3070 #[serde(deserialize_with = "deserialize_bool")]
3071 #[serde(default)]
3072 pub effects: bool,
3073 pub model: &'a str,
3074 pub movedir: Vector,
3075 pub movedistance: u16,
3076 pub origin: Vector,
3077 pub renderamt: u8,
3078 pub rendercolor: Color,
3079 #[serde(deserialize_with = "deserialize_bool")]
3080 #[serde(default)]
3081 pub renderfx: bool,
3082 #[serde(deserialize_with = "deserialize_bool")]
3083 #[serde(default)]
3084 pub rendermode: bool,
3085 #[serde(default)]
3086 pub spawnflags: Option<u32>,
3087 pub speed: u8,
3088 pub startposition: f32,
3089 #[serde(default)]
3090 pub startsound: Option<&'a str>,
3091 #[serde(default)]
3092 pub targetname: Option<&'a str>,
3093 #[serde(deserialize_with = "deserialize_bool")]
3094 #[serde(default)]
3095 pub texframeindex: bool,
3096 #[serde(deserialize_with = "deserialize_bool")]
3097 #[serde(default)]
3098 pub vrad_brush_cast_shadows: bool,
3099 #[serde(default)]
3100 pub waveheight: Option<f32>,
3101}
3102#[derive(Debug, Clone, Deserialize)]
3103pub struct GameEnd<'a> {
3104 pub origin: Vector,
3105 pub targetname: &'a str,
3106}
3107#[derive(Debug, Clone, Deserialize)]
3108pub struct GameForcerespawn<'a> {
3109 #[serde(default)]
3110 pub angles: Option<Angles>,
3111 pub origin: Vector,
3112 pub targetname: &'a str,
3113}
3114#[derive(Debug, Clone, Deserialize)]
3115pub struct GameIntroViewpoint<'a> {
3116 pub angles: Angles,
3117 #[serde(default)]
3118 pub event_data_int: Option<i32>,
3119 pub event_delay: f32,
3120 #[serde(default)]
3121 pub event_to_fire: Option<&'a str>,
3122 #[serde(default)]
3123 pub fov: Option<f32>,
3124 #[serde(default)]
3125 pub hint_message: Option<&'a str>,
3126 pub origin: Vector,
3127 pub step_number: i32,
3128 #[serde(default)]
3129 pub teamnum: Option<u8>,
3130 pub time_delay: f32,
3131}
3132#[derive(Debug, Clone, Deserialize)]
3133pub struct GameRoundWin<'a> {
3134 #[serde(default)]
3135 pub angles: Option<Angles>,
3136 #[serde(deserialize_with = "deserialize_bool")]
3137 pub force_map_reset: bool,
3138 #[serde(default)]
3139 pub onroundwin: Option<&'a str>,
3140 #[serde(default)]
3141 pub onuser1: Option<&'a str>,
3142 pub origin: Vector,
3143 #[serde(deserialize_with = "deserialize_bool")]
3144 #[serde(default)]
3145 pub switch_teams: bool,
3146 pub targetname: &'a str,
3147 pub teamnum: u8,
3148 #[serde(default)]
3149 pub win_reason: Option<i32>,
3150}
3151#[derive(Debug, Clone, Deserialize)]
3152pub struct GameText<'a> {
3153 pub channel: i32,
3154 pub color: Color,
3155 pub color2: Color,
3156 pub effect: i32,
3157 pub fadein: f32,
3158 pub fadeout: f32,
3159 pub fxtime: f32,
3160 pub holdtime: f32,
3161 #[serde(default)]
3162 pub message: Option<&'a str>,
3163 pub origin: Vector,
3164 pub spawnflags: u32,
3165 pub targetname: &'a str,
3166 pub x: f32,
3167 pub y: f32,
3168}
3169#[derive(Debug, Clone, Deserialize)]
3170pub struct GameTextTf<'a> {
3171 #[serde(default)]
3172 pub background: Option<i32>,
3173 #[serde(default)]
3174 pub display_to_team: Option<i32>,
3175 #[serde(default)]
3176 pub icon: Option<&'a str>,
3177 pub message: &'a str,
3178 pub origin: Vector,
3179 pub targetname: &'a str,
3180}
3181#[derive(Debug, Clone, Deserialize)]
3182pub struct HalloweenFortuneTeller<'a> {
3183 pub angles: Angles,
3184 pub blue_teleport: &'a str,
3185 pub onfortunecurse: &'a str,
3186 pub onfortuneend: &'a str,
3187 pub onfortunewarning: &'a str,
3188 pub origin: Vector,
3189 pub red_teleport: &'a str,
3190 #[serde(deserialize_with = "deserialize_bool")]
3191 #[serde(default)]
3192 pub skin: bool,
3193 pub targetname: &'a str,
3194}
3195#[derive(Debug, Clone, Deserialize)]
3196pub struct HalloweenZapper<'a> {
3197 #[serde(default)]
3198 pub angles: Option<Angles>,
3199 pub origin: Vector,
3200 pub particleeffect: &'a str,
3201 pub targetname: &'a str,
3202 pub touch_trigger: &'a str,
3203 #[serde(deserialize_with = "deserialize_bool")]
3204 #[serde(default)]
3205 pub zappertype: bool,
3206}
3207#[derive(Debug, Clone, Deserialize)]
3208pub struct HeadlessHatman<'a> {
3209 #[serde(default)]
3210 pub angles: Option<Angles>,
3211 #[serde(deserialize_with = "deserialize_bool")]
3212 #[serde(default)]
3213 pub disablereceiveshadows: bool,
3214 #[serde(deserialize_with = "deserialize_bool")]
3215 #[serde(default)]
3216 pub disableshadows: bool,
3217 #[serde(deserialize_with = "deserialize_bool")]
3218 #[serde(default)]
3219 pub hintlimiting: bool,
3220 #[serde(deserialize_with = "deserialize_bool")]
3221 #[serde(default)]
3222 pub ignoreunseenenemies: bool,
3223 pub origin: Vector,
3224 #[serde(default)]
3225 pub physdamagescale: Option<f32>,
3226 #[serde(default)]
3227 pub renderamt: Option<u8>,
3228 #[serde(default)]
3229 pub rendercolor: Option<Color>,
3230 #[serde(deserialize_with = "deserialize_bool")]
3231 #[serde(default)]
3232 pub renderfx: bool,
3233 #[serde(deserialize_with = "deserialize_bool")]
3234 #[serde(default)]
3235 pub rendermode: bool,
3236 #[serde(deserialize_with = "deserialize_bool")]
3237 #[serde(default)]
3238 pub sleepstate: bool,
3239 pub spawnflags: u32,
3240 pub targetname: &'a str,
3241 #[serde(deserialize_with = "deserialize_bool")]
3242 #[serde(default)]
3243 pub wakeradius: bool,
3244 #[serde(deserialize_with = "deserialize_bool")]
3245 #[serde(default)]
3246 pub wakesquad: bool,
3247}
3248#[derive(Debug, Clone, Deserialize)]
3249pub struct InfoCameraLink<'a> {
3250 pub angles: Angles,
3251 pub origin: Vector,
3252 pub pointcamera: &'a str,
3253 pub target: &'a str,
3254}
3255#[derive(Debug, Clone, Deserialize)]
3256pub struct InfoIntermission<'a> {
3257 pub origin: Vector,
3258 pub target: &'a str,
3259}
3260#[derive(Debug, Clone, Deserialize)]
3261pub struct InfoLandmark<'a> {
3262 #[serde(default)]
3263 pub angles: Option<Angles>,
3264 pub origin: Vector,
3265 #[serde(default)]
3266 pub spawnflags: Option<u32>,
3267 pub targetname: &'a str,
3268}
3269#[derive(Debug, Clone, Deserialize)]
3270pub struct InfoNull<'a> {
3271 #[serde(default)]
3272 pub angles: Option<Angles>,
3273 pub origin: Vector,
3274 #[serde(default)]
3275 pub targetname: Option<&'a str>,
3276}
3277#[derive(Debug, Clone, Deserialize)]
3278pub struct InfoObserverPoint<'a> {
3279 pub angles: Angles,
3280 #[serde(default)]
3281 pub associated_team_entity: Option<&'a str>,
3282 #[serde(deserialize_with = "deserialize_bool")]
3283 #[serde(default)]
3284 pub defaultwelcome: bool,
3285 #[serde(default)]
3286 pub fov: Option<f32>,
3287 #[serde(deserialize_with = "deserialize_bool")]
3288 #[serde(default)]
3289 pub match_summary: bool,
3290 pub origin: Vector,
3291 #[serde(default)]
3292 pub parentname: Option<&'a str>,
3293 #[serde(deserialize_with = "deserialize_bool")]
3294 #[serde(default)]
3295 pub startdisabled: bool,
3296 #[serde(default)]
3297 pub target: Option<&'a str>,
3298 #[serde(default)]
3299 pub targetname: Option<&'a str>,
3300 #[serde(default)]
3301 pub teamnum: Option<u8>,
3302}
3303#[derive(Debug, Clone, Deserialize)]
3304pub struct InfoOverlayAccessor<'a> {
3305 #[serde(default)]
3306 pub angles: Option<Angles>,
3307 pub basisnormal: Vector,
3308 pub basisorigin: Vector,
3309 pub basisu: Vector,
3310 pub basisv: Vector,
3311 #[serde(deserialize_with = "deserialize_bool")]
3312 pub endu: bool,
3313 #[serde(deserialize_with = "deserialize_bool")]
3314 pub endv: bool,
3315 pub fademindist: i32,
3316 pub material: &'a str,
3317 pub origin: Vector,
3318 pub overlayid: u8,
3319 #[serde(deserialize_with = "deserialize_bool")]
3320 #[serde(default)]
3321 pub renderorder: bool,
3322 pub sides: &'a str,
3323 #[serde(deserialize_with = "deserialize_bool")]
3324 pub startu: bool,
3325 #[serde(deserialize_with = "deserialize_bool")]
3326 pub startv: bool,
3327 pub targetname: &'a str,
3328 pub uv0: Vector,
3329 pub uv1: Vector,
3330 pub uv2: Vector,
3331 pub uv3: Vector,
3332}
3333#[derive(Debug, Clone, Deserialize)]
3334pub struct InfoParticleSystem<'a> {
3335 #[serde(default)]
3336 pub _light: Option<LightColor>,
3337 pub angles: Angles,
3338 #[serde(default)]
3339 pub cpoint1: Option<&'a str>,
3340 #[serde(deserialize_with = "deserialize_bool")]
3341 #[serde(default)]
3342 pub cpoint1_parent: bool,
3343 #[serde(default)]
3344 pub cpoint2: Option<&'a str>,
3345 #[serde(deserialize_with = "deserialize_bool")]
3346 #[serde(default)]
3347 pub cpoint2_parent: bool,
3348 #[serde(default)]
3349 pub cpoint3: Option<&'a str>,
3350 #[serde(deserialize_with = "deserialize_bool")]
3351 #[serde(default)]
3352 pub cpoint3_parent: bool,
3353 #[serde(default)]
3354 pub cpoint4: Option<&'a str>,
3355 #[serde(deserialize_with = "deserialize_bool")]
3356 #[serde(default)]
3357 pub cpoint4_parent: bool,
3358 #[serde(deserialize_with = "deserialize_bool")]
3359 #[serde(default)]
3360 pub cpoint5_parent: bool,
3361 #[serde(deserialize_with = "deserialize_bool")]
3362 #[serde(default)]
3363 pub cpoint6_parent: bool,
3364 #[serde(deserialize_with = "deserialize_bool")]
3365 #[serde(default)]
3366 pub cpoint7_parent: bool,
3367 #[serde(default)]
3368 pub effect_name: Option<&'a str>,
3369 #[serde(default)]
3370 pub fademaxdist: Option<u16>,
3371 #[serde(default)]
3372 pub fademindist: Option<u16>,
3373 #[serde(deserialize_with = "deserialize_bool")]
3374 #[serde(default)]
3375 pub flag_as_weather: bool,
3376 #[serde(default)]
3377 pub onuser1: Option<&'a str>,
3378 pub origin: Vector,
3379 #[serde(default)]
3380 pub parentname: Option<&'a str>,
3381 #[serde(default)]
3382 pub spawnflags: Option<u32>,
3383 #[serde(deserialize_with = "deserialize_bool")]
3384 #[serde(default)]
3385 pub start_active: bool,
3386 #[serde(default)]
3387 pub targetname: Option<&'a str>,
3388}
3389#[derive(Debug, Clone, Deserialize)]
3390pub struct InfoPasstimeBallSpawn<'a> {
3391 pub origin: Vector,
3392 #[serde(deserialize_with = "deserialize_bool")]
3393 #[serde(default)]
3394 pub startdisabled: bool,
3395 #[serde(default)]
3396 pub targetname: Option<&'a str>,
3397}
3398#[derive(Debug, Clone, Deserialize)]
3399pub struct InfoPlayerStart {
3400 pub angles: Angles,
3401 pub origin: Vector,
3402 #[serde(default)]
3403 pub spawnflags: Option<u32>,
3404}
3405#[derive(Debug, Clone, Deserialize)]
3406pub struct InfoPlayerTeamspawn<'a> {
3407 #[serde(default)]
3408 pub activate_goal_no: Option<u16>,
3409 pub angles: Angles,
3410 #[serde(default)]
3411 pub controlpoint: Option<&'a str>,
3412 #[serde(default)]
3413 pub goal_activation: Option<u8>,
3414 #[serde(default)]
3415 pub goal_result: Option<u8>,
3416 #[serde(default)]
3417 pub goal_state: Option<u8>,
3418 #[serde(default)]
3419 pub group_no: Option<u8>,
3420 #[serde(default)]
3421 pub matchsummary: Option<u8>,
3422 #[serde(default)]
3423 pub model: Option<&'a str>,
3424 #[serde(default)]
3425 pub modelscale: Option<f32>,
3426 pub origin: Vector,
3427 #[serde(default)]
3428 pub round_bluespawn: Option<&'a str>,
3429 #[serde(default)]
3430 pub round_redspawn: Option<&'a str>,
3431 #[serde(deserialize_with = "deserialize_bool")]
3432 #[serde(default)]
3433 pub spawnarmor: bool,
3434 #[serde(default)]
3435 pub spawnflags: Option<u32>,
3436 #[serde(deserialize_with = "deserialize_bool")]
3437 #[serde(default)]
3438 pub spawngrenades: bool,
3439 #[serde(deserialize_with = "deserialize_bool")]
3440 #[serde(default)]
3441 pub spawnmode: bool,
3442 #[serde(deserialize_with = "deserialize_bool")]
3443 #[serde(default)]
3444 pub startdisabled: bool,
3445 #[serde(default)]
3446 pub targetname: Option<&'a str>,
3447 #[serde(default)]
3448 pub team_no: Option<u8>,
3449 #[serde(default)]
3450 pub teamnum: Option<u8>,
3451}
3452#[derive(Debug, Clone, Deserialize)]
3453pub struct InfoPowerupSpawn {
3454 #[serde(default)]
3455 pub angles: Option<Angles>,
3456 pub origin: Vector,
3457 #[serde(deserialize_with = "deserialize_bool")]
3458 #[serde(default)]
3459 pub startdisabled: bool,
3460 pub team: i32,
3461}
3462#[derive(Debug, Clone, Deserialize)]
3463pub struct InfoTarget<'a> {
3464 pub angles: Angles,
3465 #[serde(default)]
3466 pub model: Option<&'a str>,
3467 pub origin: Vector,
3468 #[serde(default)]
3469 pub parentname: Option<&'a str>,
3470 #[serde(default)]
3471 pub spawnflags: Option<u32>,
3472 #[serde(default)]
3473 pub targetname: Option<&'a str>,
3474 #[serde(default)]
3475 pub vscripts: Option<&'a str>,
3476}
3477#[derive(Debug, Clone, Deserialize)]
3478pub struct InfoTeleportDestination<'a> {
3479 pub angles: Angles,
3480 #[serde(default)]
3481 pub model: Option<&'a str>,
3482 #[serde(default)]
3483 pub modelscale: Option<f32>,
3484 pub origin: Vector,
3485 #[serde(default)]
3486 pub parentname: Option<&'a str>,
3487 #[serde(default)]
3488 pub spawnflags: Option<u32>,
3489 pub targetname: &'a str,
3490}
3491#[derive(Debug, Clone, Deserialize)]
3492pub struct Infodecal<'a> {
3493 #[serde(default)]
3494 pub angles: Option<Angles>,
3495 pub origin: Vector,
3496 pub texture: &'a str,
3497}
3498#[derive(Debug, Clone, Deserialize)]
3499pub struct ItemAmmopackFull<'a> {
3500 pub angles: Angles,
3501 #[serde(deserialize_with = "deserialize_bool")]
3502 #[serde(default)]
3503 pub automaterialize: bool,
3504 #[serde(deserialize_with = "deserialize_bool")]
3505 #[serde(default)]
3506 pub body: bool,
3507 #[serde(deserialize_with = "deserialize_bool")]
3508 #[serde(default)]
3509 pub disablereceiveshadows: bool,
3510 #[serde(deserialize_with = "deserialize_bool")]
3511 #[serde(default)]
3512 pub disableshadows: bool,
3513 #[serde(deserialize_with = "deserialize_bool")]
3514 #[serde(default)]
3515 pub effects: bool,
3516 #[serde(default)]
3517 pub fademaxdist: Option<u16>,
3518 #[serde(default)]
3519 pub fademindist: Option<i32>,
3520 #[serde(default)]
3521 pub fadescale: Option<f32>,
3522 #[serde(default)]
3523 pub modelscale: Option<f32>,
3524 #[serde(default)]
3525 pub onplayertouch: Option<&'a str>,
3526 pub origin: Vector,
3527 #[serde(default)]
3528 pub renderamt: Option<u8>,
3529 #[serde(default)]
3530 pub rendercolor: Option<Color>,
3531 #[serde(deserialize_with = "deserialize_bool")]
3532 #[serde(default)]
3533 pub renderfx: bool,
3534 #[serde(deserialize_with = "deserialize_bool")]
3535 #[serde(default)]
3536 pub rendermode: bool,
3537 #[serde(deserialize_with = "deserialize_bool")]
3538 #[serde(default)]
3539 pub screenspacefade: bool,
3540 #[serde(deserialize_with = "deserialize_bool")]
3541 #[serde(default)]
3542 pub setbodygroup: bool,
3543 #[serde(deserialize_with = "deserialize_bool")]
3544 #[serde(default)]
3545 pub shadowcastdist: bool,
3546 #[serde(deserialize_with = "deserialize_bool")]
3547 #[serde(default)]
3548 pub skin: bool,
3549 #[serde(default)]
3550 pub solid: Option<u8>,
3551 #[serde(default)]
3552 pub spawnflags: Option<u32>,
3553 #[serde(deserialize_with = "deserialize_bool")]
3554 #[serde(default)]
3555 pub startdisabled: bool,
3556 #[serde(default)]
3557 pub targetname: Option<&'a str>,
3558 #[serde(default)]
3559 pub teamnum: Option<u8>,
3560 #[serde(deserialize_with = "deserialize_bool")]
3561 #[serde(default)]
3562 pub texframeindex: bool,
3563}
3564#[derive(Debug, Clone, Deserialize)]
3565pub struct ItemAmmopackMedium<'a> {
3566 pub angles: Angles,
3567 #[serde(deserialize_with = "deserialize_bool")]
3568 #[serde(default)]
3569 pub automaterialize: bool,
3570 #[serde(deserialize_with = "deserialize_bool")]
3571 #[serde(default)]
3572 pub body: bool,
3573 #[serde(deserialize_with = "deserialize_bool")]
3574 #[serde(default)]
3575 pub disablereceiveshadows: bool,
3576 #[serde(deserialize_with = "deserialize_bool")]
3577 #[serde(default)]
3578 pub disableshadows: bool,
3579 #[serde(deserialize_with = "deserialize_bool")]
3580 #[serde(default)]
3581 pub effects: bool,
3582 #[serde(default)]
3583 pub fademaxdist: Option<u16>,
3584 #[serde(default)]
3585 pub fademindist: Option<i32>,
3586 #[serde(default)]
3587 pub fadescale: Option<f32>,
3588 #[serde(default)]
3589 pub modelscale: Option<f32>,
3590 #[serde(default)]
3591 pub onplayertouch: Option<&'a str>,
3592 pub origin: Vector,
3593 #[serde(default)]
3594 pub powerup_model: Option<&'a str>,
3595 #[serde(default)]
3596 pub renderamt: Option<u8>,
3597 #[serde(default)]
3598 pub rendercolor: Option<Color>,
3599 #[serde(deserialize_with = "deserialize_bool")]
3600 #[serde(default)]
3601 pub renderfx: bool,
3602 #[serde(deserialize_with = "deserialize_bool")]
3603 #[serde(default)]
3604 pub rendermode: bool,
3605 #[serde(deserialize_with = "deserialize_bool")]
3606 #[serde(default)]
3607 pub screenspacefade: bool,
3608 #[serde(deserialize_with = "deserialize_bool")]
3609 #[serde(default)]
3610 pub setbodygroup: bool,
3611 #[serde(deserialize_with = "deserialize_bool")]
3612 #[serde(default)]
3613 pub shadowcastdist: bool,
3614 #[serde(deserialize_with = "deserialize_bool")]
3615 #[serde(default)]
3616 pub skin: bool,
3617 #[serde(default)]
3618 pub solid: Option<u8>,
3619 #[serde(default)]
3620 pub spawnflags: Option<u32>,
3621 #[serde(deserialize_with = "deserialize_bool")]
3622 #[serde(default)]
3623 pub startdisabled: bool,
3624 #[serde(default)]
3625 pub targetname: Option<&'a str>,
3626 #[serde(default)]
3627 pub teamnum: Option<u8>,
3628 #[serde(deserialize_with = "deserialize_bool")]
3629 #[serde(default)]
3630 pub texframeindex: bool,
3631}
3632#[derive(Debug, Clone, Deserialize)]
3633pub struct ItemAmmopackSmall<'a> {
3634 pub angles: Angles,
3635 #[serde(deserialize_with = "deserialize_bool")]
3636 #[serde(default)]
3637 pub automaterialize: bool,
3638 #[serde(deserialize_with = "deserialize_bool")]
3639 #[serde(default)]
3640 pub body: bool,
3641 #[serde(deserialize_with = "deserialize_bool")]
3642 #[serde(default)]
3643 pub disablereceiveshadows: bool,
3644 #[serde(deserialize_with = "deserialize_bool")]
3645 #[serde(default)]
3646 pub disableshadows: bool,
3647 #[serde(deserialize_with = "deserialize_bool")]
3648 #[serde(default)]
3649 pub effects: bool,
3650 #[serde(default)]
3651 pub fademaxdist: Option<u16>,
3652 #[serde(default)]
3653 pub fademindist: Option<i32>,
3654 #[serde(default)]
3655 pub fadescale: Option<f32>,
3656 #[serde(default)]
3657 pub modelscale: Option<f32>,
3658 pub origin: Vector,
3659 #[serde(default)]
3660 pub powerup_model: Option<&'a str>,
3661 #[serde(default)]
3662 pub renderamt: Option<u8>,
3663 #[serde(default)]
3664 pub rendercolor: Option<Color>,
3665 #[serde(deserialize_with = "deserialize_bool")]
3666 #[serde(default)]
3667 pub renderfx: bool,
3668 #[serde(deserialize_with = "deserialize_bool")]
3669 #[serde(default)]
3670 pub rendermode: bool,
3671 #[serde(deserialize_with = "deserialize_bool")]
3672 #[serde(default)]
3673 pub screenspacefade: bool,
3674 #[serde(deserialize_with = "deserialize_bool")]
3675 #[serde(default)]
3676 pub setbodygroup: bool,
3677 #[serde(deserialize_with = "deserialize_bool")]
3678 #[serde(default)]
3679 pub shadowcastdist: bool,
3680 #[serde(deserialize_with = "deserialize_bool")]
3681 #[serde(default)]
3682 pub skin: bool,
3683 #[serde(default)]
3684 pub solid: Option<u8>,
3685 #[serde(default)]
3686 pub spawnflags: Option<u32>,
3687 #[serde(deserialize_with = "deserialize_bool")]
3688 #[serde(default)]
3689 pub startdisabled: bool,
3690 #[serde(default)]
3691 pub targetname: Option<&'a str>,
3692 #[serde(deserialize_with = "deserialize_bool")]
3693 #[serde(default)]
3694 pub teamnum: bool,
3695 #[serde(deserialize_with = "deserialize_bool")]
3696 #[serde(default)]
3697 pub texframeindex: bool,
3698}
3699#[derive(Debug, Clone, Deserialize)]
3700pub struct ItemHealthammokit {
3701 pub angles: Angles,
3702 #[serde(deserialize_with = "deserialize_bool")]
3703 pub automaterialize: bool,
3704 pub fademindist: i32,
3705 pub fadescale: f32,
3706 pub modelscale: f32,
3707 pub origin: Vector,
3708 pub renderamt: u8,
3709 pub rendercolor: Color,
3710}
3711#[derive(Debug, Clone, Deserialize)]
3712pub struct ItemHealthkitFull<'a> {
3713 pub angles: Angles,
3714 #[serde(deserialize_with = "deserialize_bool")]
3715 #[serde(default)]
3716 pub automaterialize: bool,
3717 #[serde(deserialize_with = "deserialize_bool")]
3718 #[serde(default)]
3719 pub body: bool,
3720 #[serde(deserialize_with = "deserialize_bool")]
3721 #[serde(default)]
3722 pub disableshadows: bool,
3723 #[serde(deserialize_with = "deserialize_bool")]
3724 #[serde(default)]
3725 pub effects: bool,
3726 #[serde(default)]
3727 pub fademaxdist: Option<u16>,
3728 #[serde(default)]
3729 pub fademindist: Option<i32>,
3730 #[serde(default)]
3731 pub fadescale: Option<f32>,
3732 #[serde(default)]
3733 pub modelscale: Option<f32>,
3734 pub origin: Vector,
3735 #[serde(default)]
3736 pub powerup_model: Option<&'a str>,
3737 #[serde(default)]
3738 pub renderamt: Option<u8>,
3739 #[serde(default)]
3740 pub rendercolor: Option<Color>,
3741 #[serde(deserialize_with = "deserialize_bool")]
3742 #[serde(default)]
3743 pub renderfx: bool,
3744 #[serde(deserialize_with = "deserialize_bool")]
3745 #[serde(default)]
3746 pub rendermode: bool,
3747 #[serde(deserialize_with = "deserialize_bool")]
3748 #[serde(default)]
3749 pub screenspacefade: bool,
3750 #[serde(deserialize_with = "deserialize_bool")]
3751 #[serde(default)]
3752 pub shadowcastdist: bool,
3753 #[serde(deserialize_with = "deserialize_bool")]
3754 #[serde(default)]
3755 pub skin: bool,
3756 #[serde(default)]
3757 pub solid: Option<u8>,
3758 #[serde(deserialize_with = "deserialize_bool")]
3759 #[serde(default)]
3760 pub startdisabled: bool,
3761 #[serde(default)]
3762 pub targetname: Option<&'a str>,
3763 #[serde(default)]
3764 pub teamnum: Option<u8>,
3765 #[serde(deserialize_with = "deserialize_bool")]
3766 #[serde(default)]
3767 pub texframeindex: bool,
3768}
3769#[derive(Debug, Clone, Deserialize)]
3770pub struct ItemHealthkitMedium<'a> {
3771 pub angles: Angles,
3772 #[serde(deserialize_with = "deserialize_bool")]
3773 #[serde(default)]
3774 pub automaterialize: bool,
3775 #[serde(deserialize_with = "deserialize_bool")]
3776 #[serde(default)]
3777 pub body: bool,
3778 #[serde(deserialize_with = "deserialize_bool")]
3779 #[serde(default)]
3780 pub disablereceiveshadows: bool,
3781 #[serde(deserialize_with = "deserialize_bool")]
3782 #[serde(default)]
3783 pub disableshadows: bool,
3784 #[serde(deserialize_with = "deserialize_bool")]
3785 #[serde(default)]
3786 pub effects: bool,
3787 #[serde(default)]
3788 pub fademaxdist: Option<u16>,
3789 #[serde(default)]
3790 pub fademindist: Option<i32>,
3791 #[serde(default)]
3792 pub fadescale: Option<f32>,
3793 #[serde(deserialize_with = "deserialize_bool")]
3794 #[serde(default)]
3795 pub maxdxlevel: bool,
3796 #[serde(deserialize_with = "deserialize_bool")]
3797 #[serde(default)]
3798 pub mindxlevel: bool,
3799 #[serde(default)]
3800 pub modelscale: Option<f32>,
3801 #[serde(default)]
3802 pub onplayertouch: Option<&'a str>,
3803 pub origin: Vector,
3804 #[serde(default)]
3805 pub powerup_model: Option<&'a str>,
3806 #[serde(default)]
3807 pub renderamt: Option<u8>,
3808 #[serde(default)]
3809 pub rendercolor: Option<Color>,
3810 #[serde(deserialize_with = "deserialize_bool")]
3811 #[serde(default)]
3812 pub renderfx: bool,
3813 #[serde(deserialize_with = "deserialize_bool")]
3814 #[serde(default)]
3815 pub rendermode: bool,
3816 #[serde(deserialize_with = "deserialize_bool")]
3817 #[serde(default)]
3818 pub screenspacefade: bool,
3819 #[serde(deserialize_with = "deserialize_bool")]
3820 #[serde(default)]
3821 pub setbodygroup: bool,
3822 #[serde(deserialize_with = "deserialize_bool")]
3823 #[serde(default)]
3824 pub shadowcastdist: bool,
3825 #[serde(deserialize_with = "deserialize_bool")]
3826 #[serde(default)]
3827 pub skin: bool,
3828 #[serde(default)]
3829 pub solid: Option<u8>,
3830 #[serde(default)]
3831 pub spawnflags: Option<u32>,
3832 #[serde(deserialize_with = "deserialize_bool")]
3833 #[serde(default)]
3834 pub startdisabled: bool,
3835 #[serde(default)]
3836 pub targetname: Option<&'a str>,
3837 #[serde(default)]
3838 pub teamnum: Option<u8>,
3839 #[serde(deserialize_with = "deserialize_bool")]
3840 #[serde(default)]
3841 pub texframeindex: bool,
3842}
3843#[derive(Debug, Clone, Deserialize)]
3844pub struct ItemHealthkitSmall<'a> {
3845 pub angles: Angles,
3846 #[serde(deserialize_with = "deserialize_bool")]
3847 #[serde(default)]
3848 pub automaterialize: bool,
3849 #[serde(deserialize_with = "deserialize_bool")]
3850 #[serde(default)]
3851 pub body: bool,
3852 #[serde(deserialize_with = "deserialize_bool")]
3853 #[serde(default)]
3854 pub disablereceiveshadows: bool,
3855 #[serde(deserialize_with = "deserialize_bool")]
3856 #[serde(default)]
3857 pub disableshadows: bool,
3858 #[serde(deserialize_with = "deserialize_bool")]
3859 #[serde(default)]
3860 pub effects: bool,
3861 #[serde(default)]
3862 pub fademaxdist: Option<u16>,
3863 #[serde(default)]
3864 pub fademindist: Option<i32>,
3865 #[serde(default)]
3866 pub fadescale: Option<f32>,
3867 #[serde(default)]
3868 pub modelscale: Option<f32>,
3869 #[serde(default)]
3870 pub onplayertouch: Option<&'a str>,
3871 pub origin: Vector,
3872 #[serde(default)]
3873 pub powerup_model: Option<&'a str>,
3874 #[serde(default)]
3875 pub renderamt: Option<u8>,
3876 #[serde(default)]
3877 pub rendercolor: Option<Color>,
3878 #[serde(deserialize_with = "deserialize_bool")]
3879 #[serde(default)]
3880 pub renderfx: bool,
3881 #[serde(deserialize_with = "deserialize_bool")]
3882 #[serde(default)]
3883 pub rendermode: bool,
3884 #[serde(deserialize_with = "deserialize_bool")]
3885 #[serde(default)]
3886 pub screenspacefade: bool,
3887 #[serde(deserialize_with = "deserialize_bool")]
3888 #[serde(default)]
3889 pub setbodygroup: bool,
3890 #[serde(deserialize_with = "deserialize_bool")]
3891 #[serde(default)]
3892 pub shadowcastdist: bool,
3893 #[serde(deserialize_with = "deserialize_bool")]
3894 #[serde(default)]
3895 pub skin: bool,
3896 #[serde(default)]
3897 pub solid: Option<u8>,
3898 #[serde(default)]
3899 pub spawnflags: Option<u32>,
3900 #[serde(deserialize_with = "deserialize_bool")]
3901 #[serde(default)]
3902 pub startdisabled: bool,
3903 #[serde(default)]
3904 pub targetname: Option<&'a str>,
3905 #[serde(default)]
3906 pub teamnum: Option<u8>,
3907 #[serde(deserialize_with = "deserialize_bool")]
3908 #[serde(default)]
3909 pub texframeindex: bool,
3910}
3911#[derive(Debug, Clone, Deserialize)]
3912pub struct ItemTeamflag<'a> {
3913 pub angles: Angles,
3914 #[serde(deserialize_with = "deserialize_bool")]
3915 #[serde(default)]
3916 pub disablebonefollowers: bool,
3917 #[serde(deserialize_with = "deserialize_bool")]
3918 #[serde(default)]
3919 pub effects: bool,
3920 #[serde(deserialize_with = "deserialize_bool")]
3921 #[serde(default)]
3922 pub explodedamage: bool,
3923 #[serde(deserialize_with = "deserialize_bool")]
3924 #[serde(default)]
3925 pub exploderadius: bool,
3926 #[serde(deserialize_with = "deserialize_bool")]
3927 #[serde(default)]
3928 pub fademaxdist: bool,
3929 #[serde(default)]
3930 pub fademindist: Option<i32>,
3931 #[serde(default)]
3932 pub fadescale: Option<f32>,
3933 #[serde(default)]
3934 pub flag_icon: Option<&'a str>,
3935 #[serde(default)]
3936 pub flag_model: Option<&'a str>,
3937 #[serde(default)]
3938 pub flag_paper: Option<&'a str>,
3939 #[serde(default)]
3940 pub flag_trail: Option<&'a str>,
3941 #[serde(default)]
3942 pub gametype: Option<u8>,
3943 #[serde(deserialize_with = "deserialize_bool")]
3944 #[serde(default)]
3945 pub health: bool,
3946 #[serde(default)]
3947 pub maxanimtime: Option<u8>,
3948 #[serde(default)]
3949 pub minanimtime: Option<u8>,
3950 #[serde(deserialize_with = "deserialize_bool")]
3951 #[serde(default)]
3952 pub minhealthdmg: bool,
3953 #[serde(default)]
3954 pub model: Option<&'a str>,
3955 #[serde(default)]
3956 pub modelscale: Option<f32>,
3957 #[serde(deserialize_with = "deserialize_bool")]
3958 #[serde(default)]
3959 pub neutraltype: bool,
3960 #[serde(default)]
3961 pub oncapteam1: Option<&'a str>,
3962 #[serde(default)]
3963 pub oncapteam2: Option<&'a str>,
3964 pub oncapture: &'a str,
3965 #[serde(default)]
3966 pub oncapture1: Option<&'a str>,
3967 #[serde(default)]
3968 pub ondrop: Option<&'a str>,
3969 #[serde(default)]
3970 pub ondrop1: Option<&'a str>,
3971 #[serde(default)]
3972 pub onpickup: Option<&'a str>,
3973 #[serde(default)]
3974 pub onpickup1: Option<&'a str>,
3975 #[serde(default)]
3976 pub onpickupteam1: Option<&'a str>,
3977 #[serde(default)]
3978 pub onpickupteam2: Option<&'a str>,
3979 #[serde(default)]
3980 pub onreturn: Option<&'a str>,
3981 pub origin: Vector,
3982 #[serde(default)]
3983 pub parentname: Option<&'a str>,
3984 #[serde(deserialize_with = "deserialize_bool")]
3985 #[serde(default)]
3986 pub performancemode: bool,
3987 #[serde(default)]
3988 pub physdamagescale: Option<f32>,
3989 #[serde(default)]
3990 pub pointvalue: Option<u8>,
3991 #[serde(deserialize_with = "deserialize_bool")]
3992 #[serde(default)]
3993 pub pressuredelay: bool,
3994 #[serde(deserialize_with = "deserialize_bool")]
3995 #[serde(default)]
3996 pub randomanimation: bool,
3997 #[serde(default)]
3998 pub renderamt: Option<u8>,
3999 #[serde(default)]
4000 pub rendercolor: Option<Color>,
4001 #[serde(deserialize_with = "deserialize_bool")]
4002 #[serde(default)]
4003 pub renderfx: bool,
4004 #[serde(deserialize_with = "deserialize_bool")]
4005 #[serde(default)]
4006 pub rendermode: bool,
4007 #[serde(deserialize_with = "deserialize_bool")]
4008 #[serde(default)]
4009 pub returnbetweenwaves: bool,
4010 pub returntime: u16,
4011 #[serde(deserialize_with = "deserialize_bool")]
4012 #[serde(default)]
4013 pub scoringtype: bool,
4014 #[serde(deserialize_with = "deserialize_bool")]
4015 #[serde(default)]
4016 pub screenspacefade: bool,
4017 #[serde(deserialize_with = "deserialize_bool")]
4018 #[serde(default)]
4019 pub shotclockmode: bool,
4020 #[serde(deserialize_with = "deserialize_bool")]
4021 #[serde(default)]
4022 pub skin: bool,
4023 #[serde(default)]
4024 pub solid: Option<u8>,
4025 #[serde(default)]
4026 pub spawnflags: Option<u32>,
4027 #[serde(deserialize_with = "deserialize_bool")]
4028 #[serde(default)]
4029 pub startdisabled: bool,
4030 #[serde(default)]
4031 pub tags: Option<&'a str>,
4032 #[serde(default)]
4033 pub targetname: Option<&'a str>,
4034 #[serde(default)]
4035 pub teamnum: Option<u8>,
4036 #[serde(default)]
4037 pub trail_effect: Option<i32>,
4038 #[serde(deserialize_with = "deserialize_bool")]
4039 #[serde(default)]
4040 pub visiblewhendisabled: bool,
4041}
4042#[derive(Debug, Clone, Deserialize)]
4043pub struct KeyframeRope<'a> {
4044 #[serde(default)]
4045 pub angles: Option<Angles>,
4046 #[serde(deserialize_with = "deserialize_bool")]
4047 #[serde(default)]
4048 pub barbed: bool,
4049 #[serde(deserialize_with = "deserialize_bool")]
4050 #[serde(default)]
4051 pub breakable: bool,
4052 #[serde(deserialize_with = "deserialize_bool")]
4053 #[serde(default)]
4054 pub collide: bool,
4055 #[serde(deserialize_with = "deserialize_bool")]
4056 #[serde(default)]
4057 pub dangling: bool,
4058 #[serde(deserialize_with = "deserialize_bool")]
4059 #[serde(default)]
4060 pub maxdxlevel: bool,
4061 #[serde(default)]
4062 pub mindxlevel: Option<u8>,
4063 pub movespeed: u16,
4064 #[serde(default)]
4065 pub nextkey: Option<&'a str>,
4066 #[serde(deserialize_with = "deserialize_bool")]
4067 #[serde(default)]
4068 pub nowind: bool,
4069 pub origin: Vector,
4070 #[serde(default)]
4071 pub positioninterpolator: Option<u8>,
4072 #[serde(default)]
4073 pub r#type: Option<u8>,
4074 pub ropematerial: &'a str,
4075 pub slack: u16,
4076 #[serde(deserialize_with = "deserialize_bool")]
4077 #[serde(default)]
4078 pub solid: bool,
4079 #[serde(default)]
4080 pub spawnflags: Option<u32>,
4081 pub subdiv: f32,
4082 #[serde(default)]
4083 pub targetname: Option<&'a str>,
4084 pub texturescale: f32,
4085 #[serde(deserialize_with = "deserialize_bool")]
4086 #[serde(default)]
4087 pub usewind: bool,
4088 pub width: f32,
4089}
4090#[derive(Debug, Clone, Deserialize)]
4091pub struct Light<'a> {
4092 #[serde(default)]
4093 pub _constant_attn: Option<f32>,
4094 #[serde(default)]
4095 pub _distance: Option<u16>,
4096 #[serde(default)]
4097 pub _fifty_percent_distance: Option<i32>,
4098 #[serde(default)]
4099 pub _hardfalloff: Option<u16>,
4100 pub _light: LightColor,
4101 pub _lighthdr: &'a str,
4102 pub _lightscalehdr: f32,
4103 #[serde(default)]
4104 pub _linear_attn: Option<f32>,
4105 pub _quadratic_attn: f32,
4106 #[serde(default)]
4107 pub _zero_percent_distance: Option<i32>,
4108 #[serde(default)]
4109 pub angles: Option<Angles>,
4110 #[serde(default)]
4111 pub basisnormal: Option<Vector>,
4112 #[serde(default)]
4113 pub basisorigin: Option<Vector>,
4114 #[serde(default)]
4115 pub basisu: Option<Vector>,
4116 #[serde(default)]
4117 pub basisv: Option<Vector>,
4118 #[serde(default)]
4119 pub defaultstyle: Option<i32>,
4120 #[serde(default)]
4121 pub linedivider1: Option<&'a str>,
4122 pub origin: Vector,
4123 #[serde(default)]
4124 pub pattern: Option<&'a str>,
4125 #[serde(default)]
4126 pub spawnflags: Option<u32>,
4127 #[serde(default)]
4128 pub style: Option<i32>,
4129 #[serde(default)]
4130 pub targetname: Option<&'a str>,
4131 #[serde(default)]
4132 pub uv0: Option<Vector>,
4133 #[serde(default)]
4134 pub uv1: Option<Vector>,
4135 #[serde(default)]
4136 pub uv2: Option<Vector>,
4137 #[serde(default)]
4138 pub uv3: Option<Vector>,
4139}
4140#[derive(Debug, Clone, Deserialize)]
4141pub struct LightEnvironment<'a> {
4142 pub _ambient: LightColor,
4143 pub _ambienthdr: &'a str,
4144 pub _ambientscalehdr: u8,
4145 pub _light: LightColor,
4146 pub _lighthdr: &'a str,
4147 pub _lightscalehdr: f32,
4148 pub angles: Angles,
4149 #[serde(default)]
4150 pub defaultstyle: Option<i32>,
4151 pub origin: Vector,
4152 pub pitch: Angles,
4153 #[serde(default)]
4154 pub spawnflags: Option<u32>,
4155 #[serde(default)]
4156 pub style: Option<i32>,
4157 #[serde(default)]
4158 pub sunspreadangle: Option<f32>,
4159}
4160#[derive(Debug, Clone, Deserialize)]
4161pub struct LightSpot<'a> {
4162 pub _cone: u8,
4163 #[serde(default)]
4164 pub _cone2: Option<u8>,
4165 #[serde(default)]
4166 pub _constant_attn: Option<f32>,
4167 #[serde(default)]
4168 pub _distance: Option<u16>,
4169 pub _exponent: f32,
4170 #[serde(default)]
4171 pub _fifty_percent_distance: Option<u16>,
4172 #[serde(default)]
4173 pub _hardfalloff: Option<u16>,
4174 pub _inner_cone: u8,
4175 pub _light: LightColor,
4176 pub _lighthdr: &'a str,
4177 pub _lightscalehdr: f32,
4178 #[serde(default)]
4179 pub _linear_attn: Option<u8>,
4180 pub _quadratic_attn: u16,
4181 #[serde(default)]
4182 pub _zero_percent_distance: Option<u16>,
4183 pub angles: Angles,
4184 #[serde(default)]
4185 pub comment: Option<&'a str>,
4186 #[serde(default)]
4187 pub defaultstyle: Option<i32>,
4188 #[serde(deserialize_with = "deserialize_bool")]
4189 #[serde(default)]
4190 pub fademaxdist: bool,
4191 #[serde(default)]
4192 pub fademindist: Option<i32>,
4193 #[serde(default)]
4194 pub linedivider1: Option<&'a str>,
4195 pub origin: Vector,
4196 #[serde(default)]
4197 pub pattern: Option<&'a str>,
4198 #[serde(default)]
4199 pub pitch: Option<Angles>,
4200 #[serde(default)]
4201 pub spawnflags: Option<u32>,
4202 #[serde(default)]
4203 pub style: Option<i32>,
4204 #[serde(default)]
4205 pub targetname: Option<&'a str>,
4206}
4207#[derive(Debug, Clone, Deserialize)]
4208pub struct LogicAuto<'a> {
4209 #[serde(default)]
4210 pub angles: Option<Angles>,
4211 #[serde(default)]
4212 pub globalstate: Option<&'a str>,
4213 #[serde(default)]
4214 pub linedivider1: Option<&'a str>,
4215 #[serde(default)]
4216 pub onloadgame: Option<&'a str>,
4217 pub onmapspawn: &'a str,
4218 #[serde(default)]
4219 pub onmultinewmap: Option<&'a str>,
4220 pub onmultinewround: &'a str,
4221 #[serde(default)]
4222 pub onnewgame: Option<&'a str>,
4223 pub origin: Vector,
4224 pub spawnflags: u32,
4225}
4226#[derive(Debug, Clone, Deserialize)]
4227pub struct LogicBranch<'a> {
4228 #[serde(default)]
4229 pub angles: Option<Angles>,
4230 #[serde(deserialize_with = "deserialize_bool")]
4231 #[serde(default)]
4232 pub initialvalue: bool,
4233 pub onfalse: &'a str,
4234 pub ontrue: &'a str,
4235 pub origin: Vector,
4236 pub targetname: &'a str,
4237}
4238#[derive(Debug, Clone, Deserialize)]
4239pub struct LogicBranchListener<'a> {
4240 pub branch01: &'a str,
4241 #[serde(default)]
4242 pub branch02: Option<&'a str>,
4243 #[serde(default)]
4244 pub branch03: Option<&'a str>,
4245 pub onallfalse: &'a str,
4246 pub onalltrue: &'a str,
4247 pub onmixed: &'a str,
4248 pub origin: Vector,
4249 pub targetname: &'a str,
4250}
4251#[derive(Debug, Clone, Deserialize)]
4252pub struct LogicCase<'a> {
4253 #[serde(default)]
4254 pub angles: Option<Angles>,
4255 #[serde(default)]
4256 pub case01: Option<&'a str>,
4257 #[serde(default)]
4258 pub case02: Option<&'a str>,
4259 #[serde(default)]
4260 pub case03: Option<&'a str>,
4261 #[serde(default)]
4262 pub case04: Option<&'a str>,
4263 #[serde(default)]
4264 pub case05: Option<&'a str>,
4265 #[serde(default)]
4266 pub case06: Option<&'a str>,
4267 #[serde(default)]
4268 pub case07: Option<&'a str>,
4269 #[serde(default)]
4270 pub case08: Option<&'a str>,
4271 #[serde(default)]
4272 pub case09: Option<&'a str>,
4273 #[serde(default)]
4274 pub case10: Option<u8>,
4275 #[serde(default)]
4276 pub case11: Option<u8>,
4277 #[serde(default)]
4278 pub case12: Option<u8>,
4279 #[serde(default)]
4280 pub case13: Option<u8>,
4281 #[serde(default)]
4282 pub case14: Option<u8>,
4283 #[serde(default)]
4284 pub case15: Option<u8>,
4285 #[serde(default)]
4286 pub case16: Option<u8>,
4287 pub oncase01: &'a str,
4288 pub oncase02: &'a str,
4289 pub oncase03: &'a str,
4290 #[serde(default)]
4291 pub oncase04: Option<&'a str>,
4292 #[serde(default)]
4293 pub oncase05: Option<&'a str>,
4294 #[serde(default)]
4295 pub oncase06: Option<&'a str>,
4296 #[serde(default)]
4297 pub oncase07: Option<&'a str>,
4298 #[serde(default)]
4299 pub oncase08: Option<&'a str>,
4300 #[serde(default)]
4301 pub oncase09: Option<&'a str>,
4302 #[serde(default)]
4303 pub oncase10: Option<&'a str>,
4304 #[serde(default)]
4305 pub oncase11: Option<&'a str>,
4306 #[serde(default)]
4307 pub oncase12: Option<&'a str>,
4308 #[serde(default)]
4309 pub oncase13: Option<&'a str>,
4310 #[serde(default)]
4311 pub oncase14: Option<&'a str>,
4312 #[serde(default)]
4313 pub oncase15: Option<&'a str>,
4314 #[serde(default)]
4315 pub oncase16: Option<&'a str>,
4316 #[serde(default)]
4317 pub ondefault: Option<&'a str>,
4318 pub origin: Vector,
4319 #[serde(default)]
4320 pub spawnflags: Option<u32>,
4321 pub targetname: &'a str,
4322}
4323#[derive(Debug, Clone, Deserialize)]
4324pub struct LogicCollisionPair<'a> {
4325 pub attach1: &'a str,
4326 pub attach2: &'a str,
4327 pub origin: Vector,
4328 #[serde(deserialize_with = "deserialize_bool")]
4329 pub startdisabled: bool,
4330}
4331#[derive(Debug, Clone, Deserialize)]
4332pub struct LogicCompare<'a> {
4333 #[serde(default)]
4334 pub comparevalue: Option<f32>,
4335 #[serde(default)]
4336 pub initialvalue: Option<f32>,
4337 #[serde(default)]
4338 pub onequalto: Option<&'a str>,
4339 pub ongreaterthan: &'a str,
4340 #[serde(default)]
4341 pub onlessthan: Option<&'a str>,
4342 pub origin: Vector,
4343 pub targetname: &'a str,
4344}
4345#[derive(Debug, Clone, Deserialize)]
4346pub struct LogicMeasureMovement<'a> {
4347 pub measurereference: &'a str,
4348 pub measuretarget: &'a str,
4349 #[serde(deserialize_with = "deserialize_bool")]
4350 #[serde(default)]
4351 pub measuretype: bool,
4352 pub origin: Vector,
4353 #[serde(default)]
4354 pub spawnflags: Option<u32>,
4355 pub target: &'a str,
4356 pub targetname: &'a str,
4357 pub targetreference: &'a str,
4358 #[serde(deserialize_with = "deserialize_bool")]
4359 pub targetscale: bool,
4360}
4361#[derive(Debug, Clone, Deserialize)]
4362pub struct LogicRelay<'a> {
4363 #[serde(default)]
4364 pub angles: Option<Angles>,
4365 #[serde(deserialize_with = "deserialize_bool")]
4366 #[serde(default)]
4367 pub effects: bool,
4368 #[serde(default)]
4369 pub onspawn: Option<&'a str>,
4370 pub ontrigger: &'a str,
4371 #[serde(default)]
4372 pub onuser1: Option<&'a str>,
4373 #[serde(default)]
4374 pub onuser2: Option<&'a str>,
4375 #[serde(default)]
4376 pub onuser4: Option<&'a str>,
4377 pub origin: Vector,
4378 #[serde(default)]
4379 pub spawnflags: Option<u32>,
4380 #[serde(deserialize_with = "deserialize_bool")]
4381 #[serde(default)]
4382 pub startdisabled: bool,
4383 #[serde(default)]
4384 pub targetname: Option<&'a str>,
4385}
4386#[derive(Debug, Clone, Deserialize)]
4387pub struct LogicScript<'a> {
4388 pub origin: Vector,
4389 #[serde(default)]
4390 pub targetname: Option<&'a str>,
4391 #[serde(default)]
4392 pub thinkfunction: Option<&'a str>,
4393 pub vscripts: &'a str,
4394}
4395#[derive(Debug, Clone, Deserialize)]
4396pub struct LogicTimer<'a> {
4397 #[serde(default)]
4398 pub angles: Option<Angles>,
4399 #[serde(default)]
4400 pub lowerrandombound: Option<f32>,
4401 pub ontimer: &'a str,
4402 #[serde(default)]
4403 pub ontimerhigh: Option<&'a str>,
4404 #[serde(default)]
4405 pub ontimerlow: Option<&'a str>,
4406 pub origin: Vector,
4407 #[serde(default)]
4408 pub refiretime: Option<f32>,
4409 #[serde(default)]
4410 pub spawnflags: Option<u32>,
4411 #[serde(deserialize_with = "deserialize_bool")]
4412 #[serde(default)]
4413 pub startdisabled: bool,
4414 #[serde(default)]
4415 pub targetname: Option<&'a str>,
4416 #[serde(default)]
4417 pub upperrandombound: Option<f32>,
4418 #[serde(deserialize_with = "deserialize_bool")]
4419 #[serde(default)]
4420 pub userandomtime: bool,
4421}
4422#[derive(Debug, Clone, Deserialize)]
4423pub struct MapobjCartDispenser<'a> {
4424 #[serde(default)]
4425 pub angles: Option<Angles>,
4426 #[serde(default)]
4427 pub defaultupgrade: Option<u8>,
4428 #[serde(deserialize_with = "deserialize_bool")]
4429 #[serde(default)]
4430 pub disablereceiveshadows: bool,
4431 #[serde(deserialize_with = "deserialize_bool")]
4432 #[serde(default)]
4433 pub disableshadows: bool,
4434 #[serde(default)]
4435 pub helper_trigger_maxs: Option<Vector>,
4436 #[serde(default)]
4437 pub helper_trigger_mins: Option<Vector>,
4438 pub origin: Vector,
4439 #[serde(default)]
4440 pub parentname: Option<&'a str>,
4441 #[serde(default)]
4442 pub renderamt: Option<u8>,
4443 #[serde(default)]
4444 pub rendercolor: Option<Color>,
4445 #[serde(deserialize_with = "deserialize_bool")]
4446 #[serde(default)]
4447 pub solid: bool,
4448 #[serde(deserialize_with = "deserialize_bool")]
4449 #[serde(default)]
4450 pub solidtoplayer: bool,
4451 pub spawnflags: u32,
4452 #[serde(default)]
4453 pub targetname: Option<&'a str>,
4454 pub teamnum: u8,
4455 pub touch_trigger: &'a str,
4456}
4457#[derive(Debug, Clone, Deserialize)]
4458pub struct MaterialModifyControl {
4459 pub origin: Vector,
4460}
4461#[derive(Debug, Clone, Deserialize)]
4462pub struct MathCounter<'a> {
4463 #[serde(default)]
4464 pub max: Option<f32>,
4465 #[serde(default)]
4466 pub min: Option<f32>,
4467 #[serde(default)]
4468 pub ongetvalue: Option<&'a str>,
4469 pub onhitmax: &'a str,
4470 #[serde(default)]
4471 pub onhitmin: Option<&'a str>,
4472 #[serde(default)]
4473 pub onuser1: Option<&'a str>,
4474 pub origin: Vector,
4475 #[serde(default)]
4476 pub outvalue: Option<&'a str>,
4477 #[serde(deserialize_with = "deserialize_bool")]
4478 #[serde(default)]
4479 pub startdisabled: bool,
4480 #[serde(default)]
4481 pub startvalue: Option<u8>,
4482 pub targetname: &'a str,
4483}
4484#[derive(Debug, Clone, Deserialize)]
4485pub struct MathRemap<'a> {
4486 #[serde(default)]
4487 pub angles: Option<Angles>,
4488 pub in1: f32,
4489 pub in2: f32,
4490 pub origin: Vector,
4491 pub out1: f32,
4492 pub out2: f32,
4493 pub outvalue: &'a str,
4494 pub spawnflags: u32,
4495 #[serde(deserialize_with = "deserialize_bool")]
4496 #[serde(default)]
4497 pub startdisabled: bool,
4498 pub targetname: &'a str,
4499}
4500#[derive(Debug, Clone, Deserialize)]
4501pub struct Merasmus<'a> {
4502 #[serde(default)]
4503 pub angles: Option<Angles>,
4504 pub origin: Vector,
4505 pub targetname: &'a str,
4506}
4507#[derive(Debug, Clone, Deserialize)]
4508pub struct MomentaryRotButton<'a> {
4509 pub angles: Angles,
4510 #[serde(deserialize_with = "deserialize_bool")]
4511 pub disablereceiveshadows: bool,
4512 pub distance: f32,
4513 pub model: &'a str,
4514 #[serde(default)]
4515 pub onfullyclosed: Option<&'a str>,
4516 #[serde(default)]
4517 pub onfullyopen: Option<&'a str>,
4518 pub origin: Vector,
4519 #[serde(default)]
4520 pub parentname: Option<&'a str>,
4521 pub renderamt: u8,
4522 pub rendercolor: Color,
4523 #[serde(deserialize_with = "deserialize_bool")]
4524 pub renderfx: bool,
4525 pub rendermode: u8,
4526 pub returnspeed: f32,
4527 #[serde(deserialize_with = "deserialize_bool")]
4528 pub solidbsp: bool,
4529 #[serde(deserialize_with = "deserialize_bool")]
4530 pub sounds: bool,
4531 pub spawnflags: u32,
4532 pub speed: f32,
4533 pub startdirection: &'a str,
4534 pub startposition: f32,
4535 pub targetname: &'a str,
4536}
4537#[derive(Debug, Clone, Deserialize)]
4538pub struct MoveRope<'a> {
4539 #[serde(default)]
4540 pub angles: Option<Angles>,
4541 #[serde(deserialize_with = "deserialize_bool")]
4542 #[serde(default)]
4543 pub barbed: bool,
4544 #[serde(deserialize_with = "deserialize_bool")]
4545 #[serde(default)]
4546 pub breakable: bool,
4547 #[serde(deserialize_with = "deserialize_bool")]
4548 #[serde(default)]
4549 pub collide: bool,
4550 #[serde(deserialize_with = "deserialize_bool")]
4551 #[serde(default)]
4552 pub dangling: bool,
4553 #[serde(deserialize_with = "deserialize_bool")]
4554 #[serde(default)]
4555 pub maxdxlevel: bool,
4556 #[serde(default)]
4557 pub mindxlevel: Option<u8>,
4558 pub movespeed: u16,
4559 #[serde(default)]
4560 pub nextkey: Option<&'a str>,
4561 #[serde(deserialize_with = "deserialize_bool")]
4562 #[serde(default)]
4563 pub nowind: bool,
4564 pub origin: Vector,
4565 pub positioninterpolator: u8,
4566 #[serde(default)]
4567 pub r#type: Option<u8>,
4568 pub ropematerial: &'a str,
4569 pub slack: u16,
4570 #[serde(deserialize_with = "deserialize_bool")]
4571 #[serde(default)]
4572 pub solid: bool,
4573 #[serde(default)]
4574 pub spawnflags: Option<u32>,
4575 pub subdiv: f32,
4576 #[serde(default)]
4577 pub targetname: Option<&'a str>,
4578 pub texturescale: f32,
4579 pub width: f32,
4580}
4581#[derive(Debug, Clone, Deserialize)]
4582pub struct ObjDispenser<'a> {
4583 pub angles: Angles,
4584 pub defaultupgrade: i32,
4585 pub origin: Vector,
4586 pub spawnflags: u32,
4587 pub targetname: &'a str,
4588 pub teamnum: u8,
4589}
4590#[derive(Debug, Clone, Deserialize)]
4591pub struct ObjSentrygun<'a> {
4592 pub angles: Angles,
4593 pub defaultupgrade: i32,
4594 pub ondestroyed: &'a str,
4595 pub origin: Vector,
4596 pub spawnflags: u32,
4597 pub targetname: &'a str,
4598 pub teamnum: u8,
4599}
4600#[derive(Debug, Clone, Deserialize)]
4601pub struct ObjTeleporter<'a> {
4602 pub angles: Angles,
4603 pub defaultupgrade: i32,
4604 pub matchingteleporter: &'a str,
4605 pub origin: Vector,
4606 pub spawnflags: u32,
4607 pub targetname: &'a str,
4608 pub teamnum: u8,
4609 pub teleportertype: u8,
4610}
4611#[derive(Debug, Clone, Deserialize)]
4612pub struct PasstimeLogic<'a> {
4613 pub ball_spawn_countdown: i32,
4614 #[serde(default)]
4615 pub max_pass_range: Option<f32>,
4616 pub num_sections: i32,
4617 pub onballfree: &'a str,
4618 pub onballgetblu: &'a str,
4619 pub onballgetred: &'a str,
4620 pub onballpowerdown: &'a str,
4621 pub onballpowerup: &'a str,
4622 pub origin: Vector,
4623 pub targetname: &'a str,
4624}
4625#[derive(Debug, Clone, Deserialize)]
4626pub struct PathCorner<'a> {
4627 #[serde(default)]
4628 pub angles: Option<Angles>,
4629 pub origin: Vector,
4630 #[serde(default)]
4631 pub parentname: Option<&'a str>,
4632 #[serde(default)]
4633 pub spawnflags: Option<u32>,
4634 #[serde(deserialize_with = "deserialize_bool")]
4635 #[serde(default)]
4636 pub speed: bool,
4637 pub targetname: &'a str,
4638 #[serde(default)]
4639 pub wait: Option<f32>,
4640 #[serde(deserialize_with = "deserialize_bool")]
4641 #[serde(default)]
4642 pub yaw_speed: bool,
4643}
4644#[derive(Debug, Clone, Deserialize)]
4645pub struct PathTrack<'a> {
4646 #[serde(default)]
4647 pub altpath: Option<&'a str>,
4648 pub angles: Angles,
4649 #[serde(default)]
4650 pub comment: Option<&'a str>,
4651 #[serde(default)]
4652 pub model: Option<&'a str>,
4653 #[serde(default)]
4654 pub onpass: Option<&'a str>,
4655 #[serde(default)]
4656 pub onteleport: Option<&'a str>,
4657 pub orientationtype: i32,
4658 pub origin: Vector,
4659 #[serde(default)]
4660 pub parentname: Option<&'a str>,
4661 #[serde(default)]
4662 pub radius: Option<f32>,
4663 #[serde(default)]
4664 pub sides: Option<&'a str>,
4665 #[serde(default)]
4666 pub spawnflags: Option<u32>,
4667 #[serde(default)]
4668 pub speed: Option<u16>,
4669 #[serde(default)]
4670 pub target: Option<&'a str>,
4671 pub targetname: &'a str,
4672}
4673#[derive(Debug, Clone, Deserialize)]
4674pub struct PhysConstraint<'a> {
4675 #[serde(default)]
4676 pub angles: Option<Angles>,
4677 pub attach1: &'a str,
4678 pub attach2: &'a str,
4679 #[serde(default)]
4680 pub forcelimit: Option<f32>,
4681 pub origin: Vector,
4682 pub spawnflags: u32,
4683 pub targetname: &'a str,
4684 #[serde(default)]
4685 pub teleportfollowdistance: Option<f32>,
4686 #[serde(default)]
4687 pub torquelimit: Option<f32>,
4688}
4689#[derive(Debug, Clone, Deserialize)]
4690pub struct PhysHinge<'a> {
4691 pub attach1: &'a str,
4692 pub forcelimit: f32,
4693 pub hingeaxis: Vector,
4694 pub hingefriction: f32,
4695 pub maxsoundthreshold: u8,
4696 pub minsoundthreshold: u8,
4697 pub origin: Vector,
4698 #[serde(deserialize_with = "deserialize_bool")]
4699 pub reversalsoundthresholdlarge: bool,
4700 #[serde(deserialize_with = "deserialize_bool")]
4701 pub reversalsoundthresholdmedium: bool,
4702 #[serde(deserialize_with = "deserialize_bool")]
4703 pub reversalsoundthresholdsmall: bool,
4704 pub spawnflags: u32,
4705 pub systemloadscale: f32,
4706 pub targetname: &'a str,
4707 pub teleportfollowdistance: f32,
4708 pub torquelimit: f32,
4709}
4710#[derive(Debug, Clone, Deserialize)]
4711pub struct PhysRagdollmagnet<'a> {
4712 pub angles: Angles,
4713 pub axis: Vector,
4714 pub force: f32,
4715 pub origin: Vector,
4716 pub radius: f32,
4717 #[serde(default)]
4718 pub spawnflags: Option<u32>,
4719 #[serde(deserialize_with = "deserialize_bool")]
4720 #[serde(default)]
4721 pub startdisabled: bool,
4722 pub targetname: &'a str,
4723}
4724#[derive(Debug, Clone, Deserialize)]
4725pub struct PhysThruster<'a> {
4726 pub angles: Angles,
4727 pub attach1: &'a str,
4728 pub force: f32,
4729 pub forcetime: f32,
4730 pub origin: Vector,
4731 pub spawnflags: u32,
4732 pub targetname: &'a str,
4733}
4734#[derive(Debug, Clone, Deserialize)]
4735pub struct PointCamera<'a> {
4736 pub angles: Angles,
4737 pub fogcolor: Color,
4738 #[serde(deserialize_with = "deserialize_bool")]
4739 pub fogenable: bool,
4740 pub fogend: u16,
4741 #[serde(deserialize_with = "deserialize_bool")]
4742 pub fogmaxdensity: bool,
4743 pub fogstart: i32,
4744 pub fov: u8,
4745 pub origin: Vector,
4746 pub parentname: &'a str,
4747 pub spawnflags: u32,
4748 pub targetname: &'a str,
4749 #[serde(deserialize_with = "deserialize_bool")]
4750 pub usescreenaspectratio: bool,
4751}
4752#[derive(Debug, Clone, Deserialize)]
4753pub struct PointClientcommand<'a> {
4754 pub origin: Vector,
4755 pub targetname: &'a str,
4756}
4757#[derive(Debug, Clone, Deserialize)]
4758pub struct PointDevshotCamera<'a> {
4759 pub angles: Angles,
4760 #[serde(default)]
4761 pub cameraname: Option<&'a str>,
4762 pub fov: u8,
4763 pub origin: Vector,
4764}
4765#[derive(Debug, Clone, Deserialize)]
4766pub struct PointHurt<'a> {
4767 pub damage: u32,
4768 #[serde(deserialize_with = "deserialize_bool")]
4769 pub damagedelay: bool,
4770 pub damageradius: u16,
4771 pub damagetarget: &'a str,
4772 pub damagetype: u8,
4773 pub origin: Vector,
4774 pub spawnflags: u32,
4775 pub targetname: &'a str,
4776}
4777#[derive(Debug, Clone, Deserialize)]
4778pub struct PointPopulatorInterface<'a> {
4779 pub origin: Vector,
4780 pub targetname: &'a str,
4781}
4782#[derive(Debug, Clone, Deserialize)]
4783pub struct PointPush<'a> {
4784 pub angles: Angles,
4785 #[serde(deserialize_with = "deserialize_bool")]
4786 pub enabled: bool,
4787 #[serde(default)]
4788 pub influence_cone: Option<u8>,
4789 #[serde(default)]
4790 pub inner_radius: Option<f32>,
4791 pub magnitude: f32,
4792 pub origin: Vector,
4793 #[serde(default)]
4794 pub parentname: Option<&'a str>,
4795 pub radius: f32,
4796 pub spawnflags: u32,
4797 #[serde(default)]
4798 pub targetname: Option<&'a str>,
4799}
4800#[derive(Debug, Clone, Deserialize)]
4801pub struct PointServercommand<'a> {
4802 pub origin: Vector,
4803 pub targetname: &'a str,
4804}
4805#[derive(Debug, Clone, Deserialize)]
4806pub struct PointSpotlight<'a> {
4807 #[serde(default)]
4808 pub _light: Option<LightColor>,
4809 pub angles: Angles,
4810 #[serde(deserialize_with = "deserialize_bool")]
4811 #[serde(default)]
4812 pub disablereceiveshadows: bool,
4813 #[serde(deserialize_with = "deserialize_bool")]
4814 #[serde(default)]
4815 pub effects: bool,
4816 #[serde(deserialize_with = "deserialize_bool")]
4817 #[serde(default)]
4818 pub fademaxdist: bool,
4819 #[serde(default)]
4820 pub fademindist: Option<i32>,
4821 pub hdrcolorscale: f32,
4822 #[serde(deserialize_with = "deserialize_bool")]
4823 #[serde(default)]
4824 pub ignoresolid: bool,
4825 #[serde(deserialize_with = "deserialize_bool")]
4826 #[serde(default)]
4827 pub maxdxlevel: bool,
4828 #[serde(default)]
4829 pub mindxlevel: Option<i32>,
4830 pub origin: Vector,
4831 #[serde(default)]
4832 pub parentname: Option<&'a str>,
4833 #[serde(default)]
4834 pub pitch: Option<f32>,
4835 pub renderamt: u8,
4836 pub rendercolor: Vector,
4837 #[serde(default)]
4838 pub renderfx: Option<u8>,
4839 #[serde(default)]
4840 pub rendermode: Option<u8>,
4841 pub spawnflags: u32,
4842 pub spotlightlength: f32,
4843 pub spotlightwidth: f32,
4844 #[serde(default)]
4845 pub targetname: Option<&'a str>,
4846}
4847#[derive(Debug, Clone, Deserialize)]
4848pub struct PointTeleport<'a> {
4849 pub angles: Angles,
4850 pub origin: Vector,
4851 pub spawnflags: u32,
4852 #[serde(default)]
4853 pub target: Option<&'a str>,
4854 pub targetname: &'a str,
4855}
4856#[derive(Debug, Clone, Deserialize)]
4857pub struct PointTemplate<'a> {
4858 #[serde(default)]
4859 pub angles: Option<Angles>,
4860 #[serde(default)]
4861 pub onentityspawned: Option<&'a str>,
4862 pub origin: Vector,
4863 pub spawnflags: u32,
4864 pub targetname: &'a str,
4865 #[serde(default)]
4866 pub template01: Option<&'a str>,
4867 #[serde(default)]
4868 pub template02: Option<&'a str>,
4869 #[serde(default)]
4870 pub template03: Option<&'a str>,
4871 #[serde(default)]
4872 pub template04: Option<&'a str>,
4873 #[serde(default)]
4874 pub template05: Option<&'a str>,
4875 #[serde(default)]
4876 pub template06: Option<&'a str>,
4877 #[serde(default)]
4878 pub template07: Option<&'a str>,
4879 #[serde(default)]
4880 pub template08: Option<&'a str>,
4881 #[serde(default)]
4882 pub template09: Option<&'a str>,
4883 #[serde(default)]
4884 pub template10: Option<&'a str>,
4885 #[serde(default)]
4886 pub template11: Option<&'a str>,
4887 #[serde(default)]
4888 pub template12: Option<&'a str>,
4889 #[serde(default)]
4890 pub template13: Option<&'a str>,
4891 #[serde(default)]
4892 pub template14: Option<&'a str>,
4893 #[serde(default)]
4894 pub template15: Option<&'a str>,
4895 #[serde(default)]
4896 pub template16: Option<&'a str>,
4897}
4898#[derive(Debug, Clone, Deserialize)]
4899pub struct PointTesla<'a> {
4900 pub beamcount_max: i32,
4901 pub beamcount_min: i32,
4902 pub interval_max: f32,
4903 pub interval_min: f32,
4904 pub lifetime_max: f32,
4905 pub lifetime_min: f32,
4906 pub m_color: Color,
4907 pub m_flradius: u16,
4908 pub m_soundname: &'a str,
4909 pub origin: Vector,
4910 pub targetname: &'a str,
4911 pub texture: &'a str,
4912 pub thick_max: f32,
4913 pub thick_min: f32,
4914}
4915#[derive(Debug, Clone, Deserialize)]
4916pub struct PointViewcontrol<'a> {
4917 #[serde(default)]
4918 pub _frustum_far: Option<u16>,
4919 pub acceleration: u16,
4920 pub angles: Angles,
4921 pub deceleration: u16,
4922 pub origin: Vector,
4923 pub spawnflags: u32,
4924 #[serde(default)]
4925 pub speed: Option<u8>,
4926 #[serde(default)]
4927 pub targetname: Option<&'a str>,
4928 pub wait: u8,
4929}
4930#[derive(Debug, Clone, Deserialize)]
4931pub struct PropDoorRotating<'a> {
4932 pub ajarangles: Vector,
4933 pub angles: Angles,
4934 pub axis: Vector,
4935 #[serde(deserialize_with = "deserialize_bool")]
4936 pub disableshadows: bool,
4937 pub distance: f32,
4938 pub dmg: f32,
4939 #[serde(deserialize_with = "deserialize_bool")]
4940 pub forceclosed: bool,
4941 pub hardware: i32,
4942 #[serde(deserialize_with = "deserialize_bool")]
4943 pub health: bool,
4944 pub model: &'a str,
4945 pub modelscale: f32,
4946 pub opendir: i32,
4947 pub origin: Vector,
4948 pub returndelay: f32,
4949 #[serde(deserialize_with = "deserialize_bool")]
4950 pub skin: bool,
4951 pub spawnflags: u32,
4952 pub spawnpos: i32,
4953 pub speed: u8,
4954 pub targetname: &'a str,
4955}
4956#[derive(Debug, Clone, Deserialize)]
4957pub struct PropDynamic<'a> {
4958 pub angles: Angles,
4959 #[serde(default)]
4960 pub area_time_to_cap: Option<u8>,
4961 #[serde(deserialize_with = "deserialize_bool")]
4962 #[serde(default)]
4963 pub body: bool,
4964 #[serde(default)]
4965 pub breakmodelmessage: Option<&'a str>,
4966 #[serde(default)]
4967 pub damagefilter: Option<&'a str>,
4968 #[serde(default)]
4969 pub defaultanim: Option<&'a str>,
4970 #[serde(deserialize_with = "deserialize_bool")]
4971 #[serde(default)]
4972 pub disablebonefollowers: bool,
4973 #[serde(deserialize_with = "deserialize_bool")]
4974 #[serde(default)]
4975 pub disablereceiveshadows: bool,
4976 #[serde(deserialize_with = "deserialize_bool")]
4977 #[serde(default)]
4978 pub disableselfshadowing: bool,
4979 #[serde(deserialize_with = "deserialize_bool")]
4980 #[serde(default)]
4981 pub disableshadows: bool,
4982 #[serde(deserialize_with = "deserialize_bool")]
4983 #[serde(default)]
4984 pub disablevertexlighting: bool,
4985 #[serde(deserialize_with = "deserialize_bool")]
4986 #[serde(default)]
4987 pub effects: bool,
4988 #[serde(default)]
4989 pub explodedamage: Option<u8>,
4990 #[serde(deserialize_with = "deserialize_bool")]
4991 #[serde(default)]
4992 pub explodemagnitude: bool,
4993 #[serde(default)]
4994 pub exploderadius: Option<u8>,
4995 #[serde(default)]
4996 pub fademaxdist: Option<f32>,
4997 pub fademindist: f32,
4998 pub fadescale: f32,
4999 #[serde(deserialize_with = "deserialize_bool")]
5000 #[serde(default)]
5001 pub generatelightmaps: bool,
5002 #[serde(default)]
5003 pub health: Option<u8>,
5004 #[serde(deserialize_with = "deserialize_bool")]
5005 #[serde(default)]
5006 pub ignorenormals: bool,
5007 #[serde(default)]
5008 pub lightingorigin: Option<&'a str>,
5009 #[serde(default)]
5010 pub lightmapresolutionx: Option<u8>,
5011 #[serde(default)]
5012 pub lightmapresolutiony: Option<u8>,
5013 #[serde(default)]
5014 pub linedivider1: Option<&'a str>,
5015 #[serde(default)]
5016 pub linedivider10: Option<&'a str>,
5017 #[serde(default)]
5018 pub linedivider3: Option<&'a str>,
5019 #[serde(default)]
5020 pub linedivider4: Option<&'a str>,
5021 #[serde(default)]
5022 pub linedivider8: Option<&'a str>,
5023 pub maxanimtime: u8,
5024 #[serde(deserialize_with = "deserialize_bool")]
5025 #[serde(default)]
5026 pub maxdxlevel: bool,
5027 pub minanimtime: u8,
5028 #[serde(default)]
5029 pub mindxlevel: Option<u8>,
5030 #[serde(default)]
5031 pub minhealthdmg: Option<i32>,
5032 #[serde(default)]
5033 pub model: Option<&'a str>,
5034 #[serde(default)]
5035 pub modelscale: Option<f32>,
5036 #[serde(default)]
5037 pub onanimationbegun: Option<&'a str>,
5038 #[serde(default)]
5039 pub onanimationdone: Option<&'a str>,
5040 #[serde(default)]
5041 pub ontakedamage: Option<&'a str>,
5042 pub origin: Vector,
5043 #[serde(default)]
5044 pub parentname: Option<&'a str>,
5045 #[serde(deserialize_with = "deserialize_bool")]
5046 #[serde(default)]
5047 pub performancemode: bool,
5048 #[serde(default)]
5049 pub physdamagescale: Option<f32>,
5050 #[serde(deserialize_with = "deserialize_bool")]
5051 #[serde(default)]
5052 pub pressuredelay: bool,
5053 #[serde(deserialize_with = "deserialize_bool")]
5054 #[serde(default)]
5055 pub randomanimation: bool,
5056 pub renderamt: u8,
5057 pub rendercolor: Color,
5058 #[serde(deserialize_with = "deserialize_bool")]
5059 #[serde(default)]
5060 pub renderfx: bool,
5061 #[serde(default)]
5062 pub rendermode: Option<u8>,
5063 #[serde(deserialize_with = "deserialize_bool")]
5064 #[serde(default)]
5065 pub screenspacefade: bool,
5066 #[serde(deserialize_with = "deserialize_bool")]
5067 #[serde(default)]
5068 pub setbodygroup: bool,
5069 #[serde(deserialize_with = "deserialize_bool")]
5070 #[serde(default)]
5071 pub shadowcastdist: bool,
5072 #[serde(default)]
5073 pub skin: Option<u8>,
5074 pub solid: u8,
5075 #[serde(default)]
5076 pub spawnflags: Option<u32>,
5077 #[serde(deserialize_with = "deserialize_bool")]
5078 #[serde(default)]
5079 pub startdisabled: bool,
5080 #[serde(default)]
5081 pub targetname: Option<&'a str>,
5082 #[serde(deserialize_with = "deserialize_bool")]
5083 #[serde(default)]
5084 pub texframeindex: bool,
5085 #[serde(default)]
5086 pub thinkfunction: Option<&'a str>,
5087 #[serde(default)]
5088 pub vscripts: Option<&'a str>,
5089}
5090#[derive(Debug, Clone, Deserialize)]
5091pub struct PropDynamicOrnament<'a> {
5092 pub angles: Angles,
5093 #[serde(deserialize_with = "deserialize_bool")]
5094 pub disablebonefollowers: bool,
5095 #[serde(deserialize_with = "deserialize_bool")]
5096 pub disablereceiveshadows: bool,
5097 #[serde(deserialize_with = "deserialize_bool")]
5098 pub explodedamage: bool,
5099 #[serde(deserialize_with = "deserialize_bool")]
5100 pub exploderadius: bool,
5101 pub fademindist: i32,
5102 #[serde(deserialize_with = "deserialize_bool")]
5103 pub fadescale: bool,
5104 pub initialowner: &'a str,
5105 pub maxanimtime: u8,
5106 pub minanimtime: u8,
5107 pub model: &'a str,
5108 pub modelscale: f32,
5109 pub origin: Vector,
5110 #[serde(deserialize_with = "deserialize_bool")]
5111 pub performancemode: bool,
5112 #[serde(deserialize_with = "deserialize_bool")]
5113 pub pressuredelay: bool,
5114 #[serde(deserialize_with = "deserialize_bool")]
5115 pub randomanimation: bool,
5116 pub renderamt: u8,
5117 pub rendercolor: Color,
5118 #[serde(deserialize_with = "deserialize_bool")]
5119 pub renderfx: bool,
5120 #[serde(deserialize_with = "deserialize_bool")]
5121 pub rendermode: bool,
5122 #[serde(deserialize_with = "deserialize_bool")]
5123 pub setbodygroup: bool,
5124 #[serde(deserialize_with = "deserialize_bool")]
5125 pub skin: bool,
5126 #[serde(deserialize_with = "deserialize_bool")]
5127 pub solid: bool,
5128 pub spawnflags: u32,
5129}
5130#[derive(Debug, Clone, Deserialize)]
5131pub struct PropDynamicOverride<'a> {
5132 pub angles: Angles,
5133 #[serde(deserialize_with = "deserialize_bool")]
5134 #[serde(default)]
5135 pub body: bool,
5136 #[serde(default)]
5137 pub defaultanim: Option<&'a str>,
5138 #[serde(deserialize_with = "deserialize_bool")]
5139 #[serde(default)]
5140 pub disablebonefollowers: bool,
5141 #[serde(deserialize_with = "deserialize_bool")]
5142 #[serde(default)]
5143 pub disablereceiveshadows: bool,
5144 #[serde(deserialize_with = "deserialize_bool")]
5145 #[serde(default)]
5146 pub disableshadows: bool,
5147 #[serde(deserialize_with = "deserialize_bool")]
5148 #[serde(default)]
5149 pub effects: bool,
5150 #[serde(deserialize_with = "deserialize_bool")]
5151 #[serde(default)]
5152 pub explodedamage: bool,
5153 #[serde(deserialize_with = "deserialize_bool")]
5154 #[serde(default)]
5155 pub exploderadius: bool,
5156 #[serde(default)]
5157 pub fademaxdist: Option<f32>,
5158 pub fademindist: f32,
5159 pub fadescale: f32,
5160 #[serde(default)]
5161 pub health: Option<u8>,
5162 #[serde(default)]
5163 pub lightingorigin: Option<&'a str>,
5164 pub maxanimtime: u8,
5165 #[serde(deserialize_with = "deserialize_bool")]
5166 #[serde(default)]
5167 pub maxdxlevel: bool,
5168 pub minanimtime: u8,
5169 #[serde(default)]
5170 pub mindxlevel: Option<u8>,
5171 #[serde(default)]
5172 pub minhealthdmg: Option<i32>,
5173 pub model: &'a str,
5174 #[serde(default)]
5175 pub modelscale: Option<f32>,
5176 #[serde(default)]
5177 pub ontakedamage: Option<&'a str>,
5178 #[serde(default)]
5179 pub onuser1: Option<&'a str>,
5180 pub origin: Vector,
5181 #[serde(default)]
5182 pub parentname: Option<&'a str>,
5183 #[serde(deserialize_with = "deserialize_bool")]
5184 #[serde(default)]
5185 pub performancemode: bool,
5186 #[serde(default)]
5187 pub physdamagescale: Option<f32>,
5188 #[serde(deserialize_with = "deserialize_bool")]
5189 #[serde(default)]
5190 pub pressuredelay: bool,
5191 #[serde(deserialize_with = "deserialize_bool")]
5192 #[serde(default)]
5193 pub randomanimation: bool,
5194 pub renderamt: u8,
5195 pub rendercolor: Color,
5196 #[serde(deserialize_with = "deserialize_bool")]
5197 #[serde(default)]
5198 pub renderfx: bool,
5199 #[serde(deserialize_with = "deserialize_bool")]
5200 #[serde(default)]
5201 pub rendermode: bool,
5202 #[serde(deserialize_with = "deserialize_bool")]
5203 #[serde(default)]
5204 pub screenspacefade: bool,
5205 #[serde(deserialize_with = "deserialize_bool")]
5206 #[serde(default)]
5207 pub setbodygroup: bool,
5208 #[serde(deserialize_with = "deserialize_bool")]
5209 #[serde(default)]
5210 pub shadowcastdist: bool,
5211 #[serde(default)]
5212 pub skin: Option<u8>,
5213 pub solid: u8,
5214 #[serde(default)]
5215 pub spawnflags: Option<u32>,
5216 #[serde(deserialize_with = "deserialize_bool")]
5217 #[serde(default)]
5218 pub startdisabled: bool,
5219 #[serde(default)]
5220 pub targetname: Option<&'a str>,
5221 #[serde(deserialize_with = "deserialize_bool")]
5222 #[serde(default)]
5223 pub texframeindex: bool,
5224}
5225#[derive(Debug, Clone, Deserialize)]
5226pub struct PropPhysics<'a> {
5227 pub angles: Angles,
5228 pub damagetoenablemotion: i32,
5229 #[serde(deserialize_with = "deserialize_bool")]
5230 pub damagetype: bool,
5231 #[serde(deserialize_with = "deserialize_bool")]
5232 pub disablereceiveshadows: bool,
5233 #[serde(deserialize_with = "deserialize_bool")]
5234 #[serde(default)]
5235 pub disableshadows: bool,
5236 #[serde(deserialize_with = "deserialize_bool")]
5237 pub explodedamage: bool,
5238 #[serde(deserialize_with = "deserialize_bool")]
5239 pub exploderadius: bool,
5240 #[serde(default)]
5241 pub fademaxdist: Option<u16>,
5242 pub fademindist: i32,
5243 #[serde(deserialize_with = "deserialize_bool")]
5244 pub fadescale: bool,
5245 pub forcetoenablemotion: f32,
5246 pub inertiascale: f32,
5247 pub massscale: f32,
5248 #[serde(deserialize_with = "deserialize_bool")]
5249 #[serde(default)]
5250 pub maxdxlevel: bool,
5251 #[serde(default)]
5252 pub mindxlevel: Option<u8>,
5253 pub minhealthdmg: i32,
5254 pub model: &'a str,
5255 pub modelscale: f32,
5256 #[serde(deserialize_with = "deserialize_bool")]
5257 pub nodamageforces: bool,
5258 pub origin: Vector,
5259 #[serde(deserialize_with = "deserialize_bool")]
5260 pub performancemode: bool,
5261 pub physdamagescale: f32,
5262 #[serde(deserialize_with = "deserialize_bool")]
5263 pub pressuredelay: bool,
5264 pub renderamt: u8,
5265 pub rendercolor: Color,
5266 #[serde(deserialize_with = "deserialize_bool")]
5267 pub renderfx: bool,
5268 #[serde(deserialize_with = "deserialize_bool")]
5269 pub rendermode: bool,
5270 #[serde(deserialize_with = "deserialize_bool")]
5271 pub shadowcastdist: bool,
5272 #[serde(deserialize_with = "deserialize_bool")]
5273 #[serde(default)]
5274 pub skin: bool,
5275 pub spawnflags: u32,
5276}
5277#[derive(Debug, Clone, Deserialize)]
5278pub struct PropPhysicsMultiplayer<'a> {
5279 pub angles: Angles,
5280 #[serde(deserialize_with = "deserialize_bool")]
5281 #[serde(default)]
5282 pub body: bool,
5283 #[serde(default)]
5284 pub damagefilter: Option<&'a str>,
5285 #[serde(default)]
5286 pub damagetoenablemotion: Option<i32>,
5287 #[serde(deserialize_with = "deserialize_bool")]
5288 #[serde(default)]
5289 pub damagetype: bool,
5290 #[serde(deserialize_with = "deserialize_bool")]
5291 #[serde(default)]
5292 pub disablereceiveshadows: bool,
5293 #[serde(deserialize_with = "deserialize_bool")]
5294 #[serde(default)]
5295 pub disableshadows: bool,
5296 #[serde(deserialize_with = "deserialize_bool")]
5297 #[serde(default)]
5298 pub effects: bool,
5299 #[serde(deserialize_with = "deserialize_bool")]
5300 #[serde(default)]
5301 pub explodedamage: bool,
5302 #[serde(deserialize_with = "deserialize_bool")]
5303 #[serde(default)]
5304 pub explodemagnitude: bool,
5305 #[serde(deserialize_with = "deserialize_bool")]
5306 #[serde(default)]
5307 pub exploderadius: bool,
5308 #[serde(default)]
5309 pub fademaxdist: Option<f32>,
5310 pub fademindist: f32,
5311 pub fadescale: f32,
5312 #[serde(default)]
5313 pub forcetoenablemotion: Option<f32>,
5314 #[serde(deserialize_with = "deserialize_bool")]
5315 #[serde(default)]
5316 pub health: bool,
5317 pub inertiascale: f32,
5318 #[serde(default)]
5319 pub massscale: Option<f32>,
5320 #[serde(deserialize_with = "deserialize_bool")]
5321 #[serde(default)]
5322 pub maxdxlevel: bool,
5323 #[serde(default)]
5324 pub mindxlevel: Option<u8>,
5325 #[serde(default)]
5326 pub minhealthdmg: Option<u16>,
5327 pub model: &'a str,
5328 #[serde(default)]
5329 pub modelscale: Option<f32>,
5330 #[serde(deserialize_with = "deserialize_bool")]
5331 #[serde(default)]
5332 pub nodamageforces: bool,
5333 #[serde(default)]
5334 pub onawakened: Option<&'a str>,
5335 #[serde(default)]
5336 pub ontakedamage: Option<&'a str>,
5337 pub origin: Vector,
5338 #[serde(deserialize_with = "deserialize_bool")]
5339 #[serde(default)]
5340 pub performancemode: bool,
5341 pub physdamagescale: f32,
5342 #[serde(default)]
5343 pub physicsmode: Option<i32>,
5344 #[serde(deserialize_with = "deserialize_bool")]
5345 #[serde(default)]
5346 pub pressuredelay: bool,
5347 pub renderamt: u8,
5348 pub rendercolor: Color,
5349 #[serde(deserialize_with = "deserialize_bool")]
5350 #[serde(default)]
5351 pub renderfx: bool,
5352 #[serde(deserialize_with = "deserialize_bool")]
5353 #[serde(default)]
5354 pub rendermode: bool,
5355 #[serde(deserialize_with = "deserialize_bool")]
5356 #[serde(default)]
5357 pub screenspacefade: bool,
5358 #[serde(default)]
5359 pub shadowcastdist: Option<u8>,
5360 #[serde(default)]
5361 pub skin: Option<u8>,
5362 #[serde(default)]
5363 pub solid: Option<u8>,
5364 pub spawnflags: u32,
5365 #[serde(default)]
5366 pub targetname: Option<&'a str>,
5367 #[serde(deserialize_with = "deserialize_bool")]
5368 #[serde(default)]
5369 pub texframeindex: bool,
5370}
5371#[derive(Debug, Clone, Deserialize)]
5372pub struct PropPhysicsOverride<'a> {
5373 pub angles: Angles,
5374 #[serde(default)]
5375 pub damagetoenablemotion: Option<i32>,
5376 #[serde(deserialize_with = "deserialize_bool")]
5377 #[serde(default)]
5378 pub damagetype: bool,
5379 #[serde(deserialize_with = "deserialize_bool")]
5380 #[serde(default)]
5381 pub disableshadows: bool,
5382 #[serde(deserialize_with = "deserialize_bool")]
5383 #[serde(default)]
5384 pub explodedamage: bool,
5385 #[serde(deserialize_with = "deserialize_bool")]
5386 #[serde(default)]
5387 pub exploderadius: bool,
5388 #[serde(default)]
5389 pub fademaxdist: Option<f32>,
5390 pub fademindist: f32,
5391 pub fadescale: f32,
5392 #[serde(default)]
5393 pub forcetoenablemotion: Option<f32>,
5394 #[serde(deserialize_with = "deserialize_bool")]
5395 #[serde(default)]
5396 pub health: bool,
5397 pub inertiascale: f32,
5398 pub massscale: f32,
5399 #[serde(deserialize_with = "deserialize_bool")]
5400 #[serde(default)]
5401 pub maxdxlevel: bool,
5402 #[serde(default)]
5403 pub mindxlevel: Option<u8>,
5404 #[serde(default)]
5405 pub minhealthdmg: Option<i32>,
5406 pub model: &'a str,
5407 #[serde(default)]
5408 pub modelscale: Option<f32>,
5409 #[serde(deserialize_with = "deserialize_bool")]
5410 #[serde(default)]
5411 pub nodamageforces: bool,
5412 pub origin: Vector,
5413 #[serde(deserialize_with = "deserialize_bool")]
5414 #[serde(default)]
5415 pub performancemode: bool,
5416 pub physdamagescale: f32,
5417 #[serde(deserialize_with = "deserialize_bool")]
5418 #[serde(default)]
5419 pub pressuredelay: bool,
5420 #[serde(default)]
5421 pub renderamt: Option<u8>,
5422 #[serde(default)]
5423 pub rendercolor: Option<Color>,
5424 #[serde(deserialize_with = "deserialize_bool")]
5425 #[serde(default)]
5426 pub renderfx: bool,
5427 #[serde(deserialize_with = "deserialize_bool")]
5428 #[serde(default)]
5429 pub rendermode: bool,
5430 #[serde(deserialize_with = "deserialize_bool")]
5431 #[serde(default)]
5432 pub shadowcastdist: bool,
5433 pub skin: u8,
5434 #[serde(default)]
5435 pub solid: Option<u8>,
5436 pub spawnflags: u32,
5437 #[serde(default)]
5438 pub targetname: Option<&'a str>,
5439}
5440#[derive(Debug, Clone, Deserialize)]
5441pub struct PropRagdoll<'a> {
5442 pub angles: Angles,
5443 pub fademindist: i32,
5444 pub fadescale: f32,
5445 pub model: &'a str,
5446 pub modelscale: f32,
5447 pub origin: Vector,
5448 #[serde(deserialize_with = "deserialize_bool")]
5449 pub skin: bool,
5450 pub spawnflags: u32,
5451 #[serde(deserialize_with = "deserialize_bool")]
5452 pub startdisabled: bool,
5453}
5454#[derive(Debug, Clone, Deserialize)]
5455pub struct PropSoccerBall<'a> {
5456 pub model: &'a str,
5457 pub modelscale: f32,
5458 pub origin: Vector,
5459 #[serde(deserialize_with = "deserialize_bool")]
5460 pub skin: bool,
5461 pub targetname: &'a str,
5462 #[serde(default)]
5463 pub trigger_name: Option<&'a str>,
5464}
5465#[derive(Debug, Clone, Deserialize)]
5466pub struct ShadowControl<'a> {
5467 pub angles: Angles,
5468 pub color: Color,
5469 #[serde(deserialize_with = "deserialize_bool")]
5470 #[serde(default)]
5471 pub disableallshadows: bool,
5472 pub distance: f32,
5473 pub origin: Vector,
5474 #[serde(default)]
5475 pub targetname: Option<&'a str>,
5476}
5477#[derive(Debug, Clone, Deserialize)]
5478pub struct SkyCamera<'a> {
5479 pub angles: Angles,
5480 #[serde(deserialize_with = "deserialize_bool")]
5481 #[serde(default)]
5482 pub fogblend: bool,
5483 pub fogcolor: Color,
5484 pub fogcolor2: Color,
5485 pub fogdir: Vector,
5486 #[serde(deserialize_with = "deserialize_bool")]
5487 #[serde(default)]
5488 pub fogenable: bool,
5489 pub fogend: f32,
5490 #[serde(default)]
5491 pub fogmaxdensity: Option<f32>,
5492 pub fogstart: f32,
5493 pub origin: Vector,
5494 pub scale: i32,
5495 #[serde(deserialize_with = "deserialize_bool")]
5496 #[serde(default)]
5497 pub skin: bool,
5498 #[serde(default)]
5499 pub targetname: Option<&'a str>,
5500 #[serde(deserialize_with = "deserialize_bool")]
5501 #[serde(default)]
5502 pub use_angles: bool,
5503 #[serde(deserialize_with = "deserialize_bool")]
5504 #[serde(default)]
5505 pub use_angles_for_sky: bool,
5506}
5507#[derive(Debug, Clone, Deserialize)]
5508pub struct TeamControlPoint<'a> {
5509 pub angles: Angles,
5510 #[serde(default)]
5511 pub area_time_to_cap: Option<u8>,
5512 #[serde(deserialize_with = "deserialize_bool")]
5513 #[serde(default)]
5514 pub disableshadows: bool,
5515 #[serde(deserialize_with = "deserialize_bool")]
5516 #[serde(default)]
5517 pub effects: bool,
5518 #[serde(deserialize_with = "deserialize_bool")]
5519 #[serde(default)]
5520 pub fademaxdist: bool,
5521 #[serde(default)]
5522 pub fademindist: Option<i32>,
5523 #[serde(default)]
5524 pub fadescale: Option<f32>,
5525 #[serde(default)]
5526 pub linedivider1: Option<&'a str>,
5527 #[serde(default)]
5528 pub model: Option<&'a str>,
5529 #[serde(default)]
5530 pub modelscale: Option<f32>,
5531 #[serde(default)]
5532 pub oncapreset: Option<&'a str>,
5533 #[serde(default)]
5534 pub oncapteam1: Option<&'a str>,
5535 pub oncapteam2: &'a str,
5536 #[serde(default)]
5537 pub onownerchangedtoteam2: Option<&'a str>,
5538 #[serde(default)]
5539 pub onroundstartownedbyteam1: Option<&'a str>,
5540 #[serde(default)]
5541 pub onroundstartownedbyteam2: Option<&'a str>,
5542 #[serde(default)]
5543 pub onunlocked: Option<&'a str>,
5544 pub origin: Vector,
5545 #[serde(default)]
5546 pub parentname: Option<&'a str>,
5547 #[serde(default)]
5548 pub point_default_owner: Option<i32>,
5549 #[serde(default)]
5550 pub point_group: Option<i32>,
5551 #[serde(default)]
5552 pub point_index: Option<i32>,
5553 pub point_printname: &'a str,
5554 #[serde(deserialize_with = "deserialize_bool")]
5555 #[serde(default)]
5556 pub point_start_locked: bool,
5557 #[serde(default)]
5558 pub point_warn_on_cap: Option<i32>,
5559 pub point_warn_sound: &'a str,
5560 #[serde(deserialize_with = "deserialize_bool")]
5561 #[serde(default)]
5562 pub random_owner_on_restart: bool,
5563 #[serde(default)]
5564 pub renderamt: Option<u8>,
5565 #[serde(default)]
5566 pub rendercolor: Option<Color>,
5567 #[serde(deserialize_with = "deserialize_bool")]
5568 #[serde(default)]
5569 pub renderfx: bool,
5570 #[serde(default)]
5571 pub rendermode: Option<u8>,
5572 #[serde(deserialize_with = "deserialize_bool")]
5573 #[serde(default)]
5574 pub screenspacefade: bool,
5575 #[serde(deserialize_with = "deserialize_bool")]
5576 #[serde(default)]
5577 pub shadowcastdist: bool,
5578 #[serde(deserialize_with = "deserialize_bool")]
5579 #[serde(default)]
5580 pub skin: bool,
5581 #[serde(default)]
5582 pub solid: Option<u8>,
5583 pub spawnflags: u32,
5584 #[serde(deserialize_with = "deserialize_bool")]
5585 #[serde(default)]
5586 pub startdisabled: bool,
5587 pub targetname: &'a str,
5588 pub team_bodygroup_0: u8,
5589 #[serde(deserialize_with = "deserialize_bool")]
5590 pub team_bodygroup_2: bool,
5591 #[serde(deserialize_with = "deserialize_bool")]
5592 pub team_bodygroup_3: bool,
5593 #[serde(default)]
5594 pub team_capsound_0: Option<&'a str>,
5595 #[serde(default)]
5596 pub team_capsound_2: Option<&'a str>,
5597 #[serde(default)]
5598 pub team_capsound_3: Option<&'a str>,
5599 pub team_icon_0: &'a str,
5600 pub team_icon_2: &'a str,
5601 pub team_icon_3: &'a str,
5602 pub team_model_0: &'a str,
5603 pub team_model_2: &'a str,
5604 pub team_model_3: &'a str,
5605 #[serde(default)]
5606 pub team_overlay_0: Option<&'a str>,
5607 #[serde(default)]
5608 pub team_overlay_2: Option<&'a str>,
5609 #[serde(default)]
5610 pub team_overlay_3: Option<&'a str>,
5611 #[serde(default)]
5612 pub team_previouspoint_2_0: Option<&'a str>,
5613 #[serde(default)]
5614 pub team_previouspoint_2_1: Option<&'a str>,
5615 #[serde(default)]
5616 pub team_previouspoint_2_2: Option<&'a str>,
5617 #[serde(default)]
5618 pub team_previouspoint_3_0: Option<&'a str>,
5619 #[serde(default)]
5620 pub team_previouspoint_3_1: Option<&'a str>,
5621 #[serde(default)]
5622 pub team_previouspoint_3_2: Option<&'a str>,
5623 #[serde(default)]
5624 pub team_timedpoints_2: Option<f32>,
5625 #[serde(default)]
5626 pub team_timedpoints_3: Option<f32>,
5627}
5628#[derive(Debug, Clone, Deserialize)]
5629pub struct TeamControlPointMaster<'a> {
5630 #[serde(default)]
5631 pub angles: Option<Angles>,
5632 #[serde(default)]
5633 pub caplayout: Option<&'a str>,
5634 #[serde(default)]
5635 pub cpm_restrict_team_cap_win: Option<i32>,
5636 #[serde(default)]
5637 pub custom_position_x: Option<f32>,
5638 #[serde(default)]
5639 pub custom_position_y: Option<f32>,
5640 #[serde(default)]
5641 pub linedivider1: Option<&'a str>,
5642 #[serde(default)]
5643 pub onwonbyteam1: Option<&'a str>,
5644 #[serde(default)]
5645 pub onwonbyteam2: Option<&'a str>,
5646 pub origin: Vector,
5647 #[serde(default)]
5648 pub partial_cap_points_rate: Option<f32>,
5649 #[serde(deserialize_with = "deserialize_bool")]
5650 #[serde(default)]
5651 pub play_all_rounds: bool,
5652 #[serde(deserialize_with = "deserialize_bool")]
5653 #[serde(default)]
5654 pub score_style: bool,
5655 #[serde(deserialize_with = "deserialize_bool")]
5656 #[serde(default)]
5657 pub startdisabled: bool,
5658 #[serde(deserialize_with = "deserialize_bool")]
5659 #[serde(default)]
5660 pub switch_teams: bool,
5661 #[serde(default)]
5662 pub targetname: Option<&'a str>,
5663 pub team_base_icon_2: &'a str,
5664 pub team_base_icon_3: &'a str,
5665}
5666#[derive(Debug, Clone, Deserialize)]
5667pub struct TeamControlPointRound<'a> {
5668 #[serde(default)]
5669 pub angles: Option<Angles>,
5670 pub cpr_cp_names: &'a str,
5671 #[serde(default)]
5672 pub cpr_priority: Option<i32>,
5673 #[serde(default)]
5674 pub cpr_restrict_team_cap_win: Option<i32>,
5675 #[serde(default)]
5676 pub onend: Option<&'a str>,
5677 pub onstart: &'a str,
5678 #[serde(default)]
5679 pub onwonbyteam1: Option<&'a str>,
5680 #[serde(default)]
5681 pub onwonbyteam2: Option<&'a str>,
5682 pub origin: Vector,
5683 #[serde(deserialize_with = "deserialize_bool")]
5684 #[serde(default)]
5685 pub startdisabled: bool,
5686 pub targetname: &'a str,
5687}
5688#[derive(Debug, Clone, Deserialize)]
5689pub struct TeamRoundTimer<'a> {
5690 #[serde(default)]
5691 pub angles: Option<Angles>,
5692 #[serde(deserialize_with = "deserialize_bool")]
5693 #[serde(default)]
5694 pub auto_countdown: bool,
5695 #[serde(default)]
5696 pub max_length: Option<i32>,
5697 #[serde(default)]
5698 pub on10secremain: Option<&'a str>,
5699 #[serde(default)]
5700 pub on1minremain: Option<&'a str>,
5701 #[serde(default)]
5702 pub on1secremain: Option<&'a str>,
5703 #[serde(default)]
5704 pub on2minremain: Option<&'a str>,
5705 #[serde(default)]
5706 pub on2secremain: Option<&'a str>,
5707 #[serde(default)]
5708 pub on30secremain: Option<&'a str>,
5709 #[serde(default)]
5710 pub on3secremain: Option<&'a str>,
5711 #[serde(default)]
5712 pub on4secremain: Option<&'a str>,
5713 #[serde(default)]
5714 pub on5minremain: Option<&'a str>,
5715 #[serde(default)]
5716 pub on5secremain: Option<&'a str>,
5717 pub onfinished: &'a str,
5718 #[serde(default)]
5719 pub onroundstart: Option<&'a str>,
5720 pub onsetupfinished: &'a str,
5721 #[serde(default)]
5722 pub onsetupstart: Option<&'a str>,
5723 pub origin: Vector,
5724 #[serde(deserialize_with = "deserialize_bool")]
5725 #[serde(default)]
5726 pub reset_time: bool,
5727 #[serde(default)]
5728 pub setup_length: Option<i32>,
5729 #[serde(deserialize_with = "deserialize_bool")]
5730 pub show_in_hud: bool,
5731 #[serde(deserialize_with = "deserialize_bool")]
5732 #[serde(default)]
5733 pub show_time_remaining: bool,
5734 #[serde(deserialize_with = "deserialize_bool")]
5735 #[serde(default)]
5736 pub start_paused: bool,
5737 #[serde(deserialize_with = "deserialize_bool")]
5738 #[serde(default)]
5739 pub startdisabled: bool,
5740 #[serde(default)]
5741 pub targetname: Option<&'a str>,
5742 #[serde(default)]
5743 pub teamnum: Option<u8>,
5744 #[serde(default)]
5745 pub thinkfunction: Option<&'a str>,
5746 pub timer_length: i32,
5747}
5748#[derive(Debug, Clone, Deserialize)]
5749pub struct TeamTrainWatcher<'a> {
5750 #[serde(default)]
5751 pub angles: Option<Angles>,
5752 #[serde(default)]
5753 pub env_spark_name: Option<&'a str>,
5754 #[serde(default)]
5755 pub goal_node: Option<&'a str>,
5756 #[serde(deserialize_with = "deserialize_bool")]
5757 #[serde(default)]
5758 pub handle_train_movement: bool,
5759 pub hud_min_speed_level_1: f32,
5760 pub hud_min_speed_level_2: f32,
5761 pub hud_min_speed_level_3: f32,
5762 #[serde(default)]
5763 pub linked_cp_1: Option<&'a str>,
5764 #[serde(default)]
5765 pub linked_cp_2: Option<&'a str>,
5766 #[serde(default)]
5767 pub linked_cp_3: Option<&'a str>,
5768 #[serde(default)]
5769 pub linked_cp_4: Option<&'a str>,
5770 #[serde(default)]
5771 pub linked_cp_5: Option<&'a str>,
5772 #[serde(default)]
5773 pub linked_pathtrack_1: Option<&'a str>,
5774 #[serde(default)]
5775 pub linked_pathtrack_2: Option<&'a str>,
5776 #[serde(default)]
5777 pub linked_pathtrack_3: Option<&'a str>,
5778 #[serde(default)]
5779 pub linked_pathtrack_4: Option<&'a str>,
5780 #[serde(default)]
5781 pub linked_pathtrack_5: Option<&'a str>,
5782 #[serde(default)]
5783 pub ontrainstartrecede: Option<&'a str>,
5784 pub origin: Vector,
5785 pub speed_forward_modifier: f32,
5786 #[serde(default)]
5787 pub start_node: Option<&'a str>,
5788 #[serde(deserialize_with = "deserialize_bool")]
5789 #[serde(default)]
5790 pub startdisabled: bool,
5791 pub targetname: &'a str,
5792 #[serde(default)]
5793 pub teamnum: Option<u8>,
5794 pub train: &'a str,
5795 #[serde(deserialize_with = "deserialize_bool")]
5796 pub train_can_recede: bool,
5797 #[serde(default)]
5798 pub train_recede_time: Option<i32>,
5799 #[serde(deserialize_with = "deserialize_bool")]
5800 #[serde(default)]
5801 pub uphill_speed_modifier: bool,
5802}
5803#[derive(Debug, Clone, Deserialize)]
5804pub struct TfBaseMinigame {
5805 #[serde(deserialize_with = "deserialize_bool")]
5806 pub inrandompool: bool,
5807 pub maxscore: u8,
5808 pub origin: Vector,
5809 #[serde(deserialize_with = "deserialize_bool")]
5810 pub scoretype: bool,
5811 pub suddendeathtime: i32,
5812}
5813#[derive(Debug, Clone, Deserialize)]
5814pub struct TfGamerules<'a> {
5815 #[serde(default)]
5816 pub angles: Option<Angles>,
5817 #[serde(deserialize_with = "deserialize_bool")]
5818 pub ctf_overtime: bool,
5819 #[serde(default)]
5820 pub hud_type: Option<i32>,
5821 #[serde(default)]
5822 pub linedivider1: Option<&'a str>,
5823 #[serde(default)]
5824 pub onbluescorechanged: Option<&'a str>,
5825 #[serde(default)]
5826 pub onpowerupimbalancemeasuresover: Option<&'a str>,
5827 #[serde(default)]
5828 pub onpowerupimbalanceteam1: Option<&'a str>,
5829 #[serde(default)]
5830 pub onpowerupimbalanceteam2: Option<&'a str>,
5831 #[serde(default)]
5832 pub ontruceend: Option<&'a str>,
5833 #[serde(default)]
5834 pub ontrucestart: Option<&'a str>,
5835 #[serde(default)]
5836 pub onwonbyteam1: Option<&'a str>,
5837 #[serde(default)]
5838 pub onwonbyteam2: Option<&'a str>,
5839 pub origin: Vector,
5840 #[serde(deserialize_with = "deserialize_bool")]
5841 #[serde(default)]
5842 pub ropes_holiday_lights_allowed: bool,
5843 pub targetname: &'a str,
5844 #[serde(default)]
5845 pub vscripts: Option<&'a str>,
5846}
5847#[derive(Debug, Clone, Deserialize)]
5848pub struct TfGenericBomb<'a> {
5849 pub angles: Angles,
5850 pub damage: f32,
5851 #[serde(deserialize_with = "deserialize_bool")]
5852 #[serde(default)]
5853 pub disableshadows: bool,
5854 pub explode_particle: &'a str,
5855 #[serde(default)]
5856 pub fademindist: Option<i32>,
5857 #[serde(default)]
5858 pub fadescale: Option<f32>,
5859 #[serde(default)]
5860 pub friendlyfire: Option<i32>,
5861 pub health: i32,
5862 pub model: &'a str,
5863 pub modelscale: f32,
5864 pub ondetonate: &'a str,
5865 pub origin: Vector,
5866 #[serde(deserialize_with = "deserialize_bool")]
5867 #[serde(default)]
5868 pub passactivator: bool,
5869 pub radius: f32,
5870 #[serde(default)]
5871 pub renderamt: Option<u8>,
5872 #[serde(default)]
5873 pub rendercolor: Option<Color>,
5874 #[serde(deserialize_with = "deserialize_bool")]
5875 pub skin: bool,
5876 #[serde(default)]
5877 pub sound: Option<&'a str>,
5878 #[serde(default)]
5879 pub targetname: Option<&'a str>,
5880}
5881#[derive(Debug, Clone, Deserialize)]
5882pub struct TfGlow<'a> {
5883 #[serde(default)]
5884 pub angles: Option<Angles>,
5885 pub glowcolor: LightColor,
5886 #[serde(deserialize_with = "deserialize_bool")]
5887 #[serde(default)]
5888 pub mode: bool,
5889 pub origin: Vector,
5890 #[serde(deserialize_with = "deserialize_bool")]
5891 #[serde(default)]
5892 pub startdisabled: bool,
5893 pub target: &'a str,
5894 #[serde(default)]
5895 pub targetname: Option<&'a str>,
5896}
5897#[derive(Debug, Clone, Deserialize)]
5898pub struct TfHalloweenGiftSpawnLocation<'a> {
5899 pub angles: Angles,
5900 pub origin: Vector,
5901 #[serde(default)]
5902 pub targetname: Option<&'a str>,
5903}
5904#[derive(Debug, Clone, Deserialize)]
5905pub struct TfHalloweenMinigame<'a> {
5906 pub bluespawn: &'a str,
5907 #[serde(default)]
5908 pub enemy_team_score_sound: Option<&'a str>,
5909 pub hud_res_file: &'a str,
5910 #[serde(deserialize_with = "deserialize_bool")]
5911 pub inrandompool: bool,
5912 pub maxscore: u8,
5913 pub minigametype: u8,
5914 pub onallbluedead: &'a str,
5915 pub onallreddead: &'a str,
5916 pub onbluehitmaxscore: &'a str,
5917 pub onredhitmaxscore: &'a str,
5918 #[serde(default)]
5919 pub onsuddendeathstart: Option<&'a str>,
5920 pub onteleporttominigame: &'a str,
5921 pub origin: Vector,
5922 pub redspawn: &'a str,
5923 #[serde(deserialize_with = "deserialize_bool")]
5924 #[serde(default)]
5925 pub scoretype: bool,
5926 pub suddendeathtime: i32,
5927 pub targetname: &'a str,
5928 #[serde(default)]
5929 pub your_team_score_sound: Option<&'a str>,
5930}
5931#[derive(Debug, Clone, Deserialize)]
5932pub struct TfHalloweenMinigameFallingPlatforms<'a> {
5933 pub bluespawn: &'a str,
5934 pub hud_res_file: &'a str,
5935 #[serde(deserialize_with = "deserialize_bool")]
5936 pub inrandompool: bool,
5937 pub maxscore: u8,
5938 pub minigametype: u8,
5939 pub onallbluedead: &'a str,
5940 pub onallreddead: &'a str,
5941 pub onteleporttominigame: &'a str,
5942 pub origin: Vector,
5943 pub outputremoveplatform: &'a str,
5944 pub outputsafeplatform: &'a str,
5945 pub redspawn: &'a str,
5946 #[serde(deserialize_with = "deserialize_bool")]
5947 pub scoretype: bool,
5948 pub suddendeathtime: i32,
5949 pub targetname: &'a str,
5950}
5951#[derive(Debug, Clone, Deserialize)]
5952pub struct TfHalloweenPickup<'a> {
5953 pub angles: Angles,
5954 #[serde(deserialize_with = "deserialize_bool")]
5955 pub automaterialize: bool,
5956 pub fademindist: i32,
5957 pub origin: Vector,
5958 pub pickup_particle: &'a str,
5959 pub pickup_sound: &'a str,
5960 pub powerup_model: &'a str,
5961 #[serde(deserialize_with = "deserialize_bool")]
5962 pub startdisabled: bool,
5963 pub targetname: &'a str,
5964 #[serde(deserialize_with = "deserialize_bool")]
5965 pub teamnum: bool,
5966}
5967#[derive(Debug, Clone, Deserialize)]
5968pub struct TfLogicArena<'a> {
5969 pub capenabledelay: u8,
5970 pub onarenaroundstart: &'a str,
5971 pub oncapenabled: &'a str,
5972 pub origin: Vector,
5973 #[serde(default)]
5974 pub targetname: Option<&'a str>,
5975}
5976#[derive(Debug, Clone, Deserialize)]
5977pub struct TfLogicCompetitive<'a> {
5978 pub onspawnroomdoorsshouldlock: &'a str,
5979 pub onspawnroomdoorsshouldunlock: &'a str,
5980 pub origin: Vector,
5981 #[serde(deserialize_with = "deserialize_bool")]
5982 #[serde(default)]
5983 pub startdisabled: bool,
5984}
5985#[derive(Debug, Clone, Deserialize)]
5986pub struct TfLogicCpTimer<'a> {
5987 pub controlpoint: &'a str,
5988 pub oncountdownend: &'a str,
5989 pub oncountdownstart: &'a str,
5990 pub origin: Vector,
5991 pub targetname: &'a str,
5992 pub timer_length: i32,
5993}
5994#[derive(Debug, Clone, Deserialize)]
5995pub struct TfLogicHoliday<'a> {
5996 #[serde(deserialize_with = "deserialize_bool")]
5997 #[serde(default)]
5998 pub allowhaunting: bool,
5999 #[serde(default)]
6000 pub angles: Option<Angles>,
6001 pub holiday_type: i32,
6002 pub origin: Vector,
6003 #[serde(default)]
6004 pub spawnflags: Option<u32>,
6005 #[serde(default)]
6006 pub targetname: Option<&'a str>,
6007 #[serde(deserialize_with = "deserialize_bool")]
6008 #[serde(default)]
6009 pub tauntinhell: bool,
6010}
6011#[derive(Debug, Clone, Deserialize)]
6012pub struct TfLogicHybridCtfCp {
6013 pub origin: Vector,
6014}
6015#[derive(Debug, Clone, Deserialize)]
6016pub struct TfLogicKoth<'a> {
6017 #[serde(default)]
6018 pub angles: Option<Angles>,
6019 #[serde(default)]
6020 pub linedivider1: Option<&'a str>,
6021 pub origin: Vector,
6022 #[serde(default)]
6023 pub targetname: Option<&'a str>,
6024 pub timer_length: i32,
6025 pub unlock_point: i32,
6026}
6027#[derive(Debug, Clone, Deserialize)]
6028pub struct TfLogicMannVsMachine<'a> {
6029 pub origin: Vector,
6030 #[serde(default)]
6031 pub targetname: Option<&'a str>,
6032}
6033#[derive(Debug, Clone, Deserialize)]
6034pub struct TfLogicMannpower {
6035 pub origin: Vector,
6036 #[serde(deserialize_with = "deserialize_bool")]
6037 pub startdisabled: bool,
6038}
6039#[derive(Debug, Clone, Deserialize)]
6040pub struct TfLogicMedieval<'a> {
6041 pub origin: Vector,
6042 pub targetname: &'a str,
6043}
6044#[derive(Debug, Clone, Deserialize)]
6045pub struct TfLogicMinigames<'a> {
6046 pub origin: Vector,
6047 pub targetname: &'a str,
6048}
6049#[derive(Debug, Clone, Deserialize)]
6050pub struct TfLogicMultipleEscort {
6051 pub origin: Vector,
6052}
6053#[derive(Debug, Clone, Deserialize)]
6054pub struct TfLogicOnHoliday<'a> {
6055 #[serde(default)]
6056 pub isaprilfools: Option<&'a str>,
6057 #[serde(default)]
6058 pub ishalloween: Option<&'a str>,
6059 #[serde(default)]
6060 pub isnothing: Option<&'a str>,
6061 #[serde(default)]
6062 pub issmissmas: Option<&'a str>,
6063 #[serde(default)]
6064 pub istfbirthday: Option<&'a str>,
6065 #[serde(default)]
6066 pub isvalentines: Option<&'a str>,
6067 pub origin: Vector,
6068 pub targetname: &'a str,
6069}
6070#[derive(Debug, Clone, Deserialize)]
6071pub struct TfLogicPlayerDestruction<'a> {
6072 #[serde(default)]
6073 pub angles: Option<Angles>,
6074 pub blue_respawn_time: u8,
6075 pub finale_length: f32,
6076 pub flag_reset_delay: i32,
6077 pub heal_distance: i32,
6078 #[serde(default)]
6079 pub max_points: Option<i32>,
6080 pub min_points: i32,
6081 pub onbluehitmaxpoints: &'a str,
6082 pub onbluescorechanged: &'a str,
6083 #[serde(default)]
6084 pub oncountdowntimerexpired: Option<&'a str>,
6085 pub onredhitmaxpoints: &'a str,
6086 pub onredscorechanged: &'a str,
6087 pub origin: Vector,
6088 pub points_per_player: i32,
6089 #[serde(default)]
6090 pub prop_drop_sound: Option<&'a str>,
6091 pub prop_model_name: &'a str,
6092 #[serde(default)]
6093 pub prop_pickup_sound: Option<&'a str>,
6094 pub red_respawn_time: u8,
6095 pub res_file: &'a str,
6096 #[serde(default)]
6097 pub score_interval: Option<f32>,
6098 #[serde(deserialize_with = "deserialize_bool")]
6099 #[serde(default)]
6100 pub skin: bool,
6101 pub targetname: &'a str,
6102}
6103#[derive(Debug, Clone, Deserialize)]
6104pub struct TfLogicRobotDestruction<'a> {
6105 pub blue_respawn_time: u8,
6106 pub finale_length: f32,
6107 pub loser_respawn_bonus_per_bot: f32,
6108 pub max_points: i32,
6109 pub onbluefirstflagstolen: &'a str,
6110 pub onblueflagstolen: &'a str,
6111 pub onbluehaspoints: &'a str,
6112 pub onbluehitmaxpoints: &'a str,
6113 pub onbluelastflagreturned: &'a str,
6114 pub onredfirstflagstolen: &'a str,
6115 pub onredflagstolen: &'a str,
6116 pub onredhaspoints: &'a str,
6117 pub onredhitmaxpoints: &'a str,
6118 pub onredlastflagreturned: &'a str,
6119 pub origin: Vector,
6120 pub red_respawn_time: u8,
6121 pub score_interval: f32,
6122 pub targetname: &'a str,
6123}
6124#[derive(Debug, Clone, Deserialize)]
6125pub struct TfLogicTrainingMode<'a> {
6126 pub onbotdied: &'a str,
6127 #[serde(default)]
6128 pub onbuildoutsidearea: Option<&'a str>,
6129 #[serde(default)]
6130 pub onplayerdetonatebuilding: Option<&'a str>,
6131 pub onplayerdied: &'a str,
6132 #[serde(default)]
6133 pub onplayerspawnasdemoman: Option<&'a str>,
6134 #[serde(default)]
6135 pub onplayerspawnasengineer: Option<&'a str>,
6136 pub onplayerspawnassoldier: &'a str,
6137 pub onplayerspawnasspy: &'a str,
6138 #[serde(default)]
6139 pub onplayerswappedtobuilding: Option<&'a str>,
6140 #[serde(default)]
6141 pub onplayerswappedtomelee: Option<&'a str>,
6142 #[serde(default)]
6143 pub onplayerswappedtopda: Option<&'a str>,
6144 #[serde(default)]
6145 pub onplayerswappedtoprimary: Option<&'a str>,
6146 #[serde(default)]
6147 pub onplayerswappedtosecondary: Option<&'a str>,
6148 pub origin: Vector,
6149 pub targetname: &'a str,
6150}
6151#[derive(Debug, Clone, Deserialize)]
6152pub struct TfPointNavInterface<'a> {
6153 pub origin: Vector,
6154 pub targetname: &'a str,
6155}
6156#[derive(Debug, Clone, Deserialize)]
6157pub struct TfPointWeaponMimic<'a> {
6158 pub angles: Angles,
6159 #[serde(deserialize_with = "deserialize_bool")]
6160 pub crits: bool,
6161 pub damage: u8,
6162 pub modelscale: f32,
6163 pub origin: Vector,
6164 pub parentname: &'a str,
6165 pub speedmax: u16,
6166 pub speedmin: u16,
6167 pub splashradius: u8,
6168 pub spreadangle: u8,
6169 pub targetname: &'a str,
6170 #[serde(deserialize_with = "deserialize_bool")]
6171 pub weapontype: bool,
6172}
6173#[derive(Debug, Clone, Deserialize)]
6174pub struct TfPumpkinBomb {
6175 pub angles: Angles,
6176 #[serde(deserialize_with = "deserialize_bool")]
6177 pub automaterialize: bool,
6178 #[serde(deserialize_with = "deserialize_bool")]
6179 pub fademaxdist: bool,
6180 pub fademindist: i32,
6181 pub origin: Vector,
6182}
6183#[derive(Debug, Clone, Deserialize)]
6184pub struct TfRobotDestructionRobotSpawn<'a> {
6185 pub angles: Angles,
6186 pub gibs: i32,
6187 pub health: i32,
6188 pub origin: Vector,
6189 pub r#type: i32,
6190 pub spawngroup: &'a str,
6191 pub startpath: &'a str,
6192 pub targetname: &'a str,
6193}
6194#[derive(Debug, Clone, Deserialize)]
6195pub struct TfRobotDestructionSpawnGroup<'a> {
6196 #[serde(default)]
6197 pub angles: Option<Angles>,
6198 pub group_number: i32,
6199 pub hud_icon: &'a str,
6200 pub origin: Vector,
6201 pub respawn_reduction_scale: f32,
6202 #[serde(default)]
6203 pub respawn_time: Option<f32>,
6204 pub targetname: &'a str,
6205 pub team_number: i32,
6206}
6207#[derive(Debug, Clone, Deserialize)]
6208pub struct TfSpellPickup<'a> {
6209 pub angles: Angles,
6210 #[serde(deserialize_with = "deserialize_bool")]
6211 pub automaterialize: bool,
6212 #[serde(deserialize_with = "deserialize_bool")]
6213 #[serde(default)]
6214 pub disableshadows: bool,
6215 #[serde(default)]
6216 pub fademaxdist: Option<u16>,
6217 pub fademindist: i32,
6218 #[serde(default)]
6219 pub fadescale: Option<f32>,
6220 #[serde(default)]
6221 pub modelscale: Option<f32>,
6222 #[serde(default)]
6223 pub onplayertouch: Option<&'a str>,
6224 pub origin: Vector,
6225 #[serde(default)]
6226 pub powerup_model: Option<&'a str>,
6227 #[serde(default)]
6228 pub renderamt: Option<u8>,
6229 #[serde(default)]
6230 pub rendercolor: Option<Color>,
6231 #[serde(deserialize_with = "deserialize_bool")]
6232 #[serde(default)]
6233 pub renderfx: bool,
6234 #[serde(default)]
6235 pub rendermode: Option<u8>,
6236 #[serde(deserialize_with = "deserialize_bool")]
6237 #[serde(default)]
6238 pub startdisabled: bool,
6239 #[serde(default)]
6240 pub targetname: Option<&'a str>,
6241 #[serde(default)]
6242 pub teamnum: Option<u8>,
6243 #[serde(default)]
6244 pub tier: Option<i32>,
6245}
6246#[derive(Debug, Clone, Deserialize)]
6247pub struct TfTeleportLocation<'a> {
6248 pub angles: Angles,
6249 pub origin: Vector,
6250 pub targetname: &'a str,
6251}
6252#[derive(Debug, Clone, Deserialize)]
6253pub struct TfZombie<'a> {
6254 pub angles: Angles,
6255 #[serde(deserialize_with = "deserialize_bool")]
6256 #[serde(default)]
6257 pub disableshadows: bool,
6258 #[serde(deserialize_with = "deserialize_bool")]
6259 pub effects: bool,
6260 #[serde(deserialize_with = "deserialize_bool")]
6261 #[serde(default)]
6262 pub fademaxdist: bool,
6263 #[serde(default)]
6264 pub fademindist: Option<i32>,
6265 #[serde(default)]
6266 pub fadescale: Option<f32>,
6267 #[serde(default)]
6268 pub health: Option<u16>,
6269 #[serde(default)]
6270 pub max_health: Option<u16>,
6271 #[serde(default)]
6272 pub modelscale: Option<f32>,
6273 pub ondeath: &'a str,
6274 pub onuser1: &'a str,
6275 pub origin: Vector,
6276 pub renderamt: u8,
6277 pub rendercolor: Color,
6278 #[serde(deserialize_with = "deserialize_bool")]
6279 #[serde(default)]
6280 pub renderfx: bool,
6281 #[serde(deserialize_with = "deserialize_bool")]
6282 #[serde(default)]
6283 pub rendermode: bool,
6284 #[serde(deserialize_with = "deserialize_bool")]
6285 #[serde(default)]
6286 pub screenspacefade: bool,
6287 #[serde(deserialize_with = "deserialize_bool")]
6288 #[serde(default)]
6289 pub shadowcastdist: bool,
6290 #[serde(deserialize_with = "deserialize_bool")]
6291 #[serde(default)]
6292 pub skin: bool,
6293 #[serde(default)]
6294 pub spawnflags: Option<u32>,
6295 pub targetname: &'a str,
6296 pub teamnum: u8,
6297}
6298#[derive(Debug, Clone, Deserialize)]
6299pub struct TfZombieSpawner<'a> {
6300 #[serde(default)]
6301 pub angles: Option<Angles>,
6302 #[serde(deserialize_with = "deserialize_bool")]
6303 #[serde(default)]
6304 pub infinite_zombies: bool,
6305 pub max_zombies: i32,
6306 pub origin: Vector,
6307 pub targetname: &'a str,
6308 #[serde(default)]
6309 pub teamnum: Option<u8>,
6310 #[serde(default)]
6311 pub zombie_lifetime: Option<f32>,
6312 #[serde(deserialize_with = "deserialize_bool")]
6313 #[serde(default)]
6314 pub zombie_scale: bool,
6315 #[serde(default)]
6316 pub zombie_type: Option<i32>,
6317}
6318#[derive(Debug, Clone, Deserialize)]
6319pub struct TrainingAnnotation<'a> {
6320 #[serde(default)]
6321 pub angles: Option<Angles>,
6322 pub display_text: &'a str,
6323 pub lifetime: f32,
6324 #[serde(default)]
6325 pub offset: Option<f32>,
6326 pub origin: Vector,
6327 pub targetname: &'a str,
6328 #[serde(default)]
6329 pub team_filter: Option<i32>,
6330}
6331#[derive(Debug, Clone, Deserialize)]
6332pub struct TrainingPropDynamic<'a> {
6333 pub angles: Angles,
6334 pub damagefilter: &'a str,
6335 #[serde(deserialize_with = "deserialize_bool")]
6336 pub disablereceiveshadows: bool,
6337 #[serde(deserialize_with = "deserialize_bool")]
6338 pub disableshadows: bool,
6339 #[serde(deserialize_with = "deserialize_bool")]
6340 pub explodedamage: bool,
6341 #[serde(deserialize_with = "deserialize_bool")]
6342 pub exploderadius: bool,
6343 pub fademindist: i32,
6344 #[serde(deserialize_with = "deserialize_bool")]
6345 pub fadescale: bool,
6346 pub maxanimtime: u8,
6347 pub minanimtime: u8,
6348 pub model: &'a str,
6349 pub ontakedamage: &'a str,
6350 pub origin: Vector,
6351 pub parentname: &'a str,
6352 #[serde(deserialize_with = "deserialize_bool")]
6353 pub performancemode: bool,
6354 #[serde(deserialize_with = "deserialize_bool")]
6355 pub pressuredelay: bool,
6356 #[serde(deserialize_with = "deserialize_bool")]
6357 pub randomanimation: bool,
6358 pub renderamt: u8,
6359 pub rendercolor: Color,
6360 #[serde(deserialize_with = "deserialize_bool")]
6361 pub renderfx: bool,
6362 #[serde(deserialize_with = "deserialize_bool")]
6363 pub rendermode: bool,
6364 #[serde(deserialize_with = "deserialize_bool")]
6365 pub setbodygroup: bool,
6366 #[serde(deserialize_with = "deserialize_bool")]
6367 pub skin: bool,
6368 pub solid: u8,
6369 pub spawnflags: u32,
6370 #[serde(deserialize_with = "deserialize_bool")]
6371 pub startdisabled: bool,
6372 pub targetname: &'a str,
6373}
6374#[derive(Debug, Clone, Deserialize)]
6375pub struct TriggerAddOrRemoveTfPlayerAttributes<'a> {
6376 #[serde(deserialize_with = "deserialize_bool")]
6377 pub add_or_remove: bool,
6378 #[serde(default)]
6379 pub angles: Option<Angles>,
6380 pub attribute_name: &'a str,
6381 pub duration: f32,
6382 #[serde(default)]
6383 pub filtername: Option<&'a str>,
6384 pub model: &'a str,
6385 #[serde(default)]
6386 pub onstarttouch: Option<&'a str>,
6387 pub origin: Vector,
6388 pub spawnflags: u32,
6389 #[serde(deserialize_with = "deserialize_bool")]
6390 pub startdisabled: bool,
6391 #[serde(default)]
6392 pub targetname: Option<&'a str>,
6393 pub value: f32,
6394}
6395#[derive(Debug, Clone, Deserialize)]
6396pub struct TriggerAddTfPlayerCondition<'a> {
6397 #[serde(default)]
6398 pub angles: Option<Angles>,
6399 pub condition: i32,
6400 pub duration: f32,
6401 #[serde(deserialize_with = "deserialize_bool")]
6402 #[serde(default)]
6403 pub effects: bool,
6404 #[serde(default)]
6405 pub filtername: Option<&'a str>,
6406 pub model: &'a str,
6407 #[serde(default)]
6408 pub oncatapulted: Option<&'a str>,
6409 #[serde(default)]
6410 pub onendtouch: Option<&'a str>,
6411 #[serde(default)]
6412 pub onendtouchall: Option<&'a str>,
6413 #[serde(default)]
6414 pub onstarttouch: Option<&'a str>,
6415 #[serde(default)]
6416 pub onstarttouchall: Option<&'a str>,
6417 pub origin: Vector,
6418 #[serde(default)]
6419 pub parentname: Option<&'a str>,
6420 #[serde(deserialize_with = "deserialize_bool")]
6421 #[serde(default)]
6422 pub solid: bool,
6423 pub spawnflags: u32,
6424 #[serde(deserialize_with = "deserialize_bool")]
6425 pub startdisabled: bool,
6426 #[serde(default)]
6427 pub targetname: Option<&'a str>,
6428}
6429#[derive(Debug, Clone, Deserialize)]
6430pub struct TriggerApplyImpulse<'a> {
6431 #[serde(default)]
6432 pub filtername: Option<&'a str>,
6433 pub force: f32,
6434 pub impulse_dir: Vector,
6435 pub model: &'a str,
6436 pub origin: Vector,
6437 pub spawnflags: u32,
6438 #[serde(deserialize_with = "deserialize_bool")]
6439 pub startdisabled: bool,
6440 pub targetname: &'a str,
6441}
6442#[derive(Debug, Clone, Deserialize)]
6443pub struct TriggerBrush<'a> {
6444 pub angles: Angles,
6445 pub model: &'a str,
6446 pub onuse: &'a str,
6447 pub origin: Vector,
6448 pub spawnflags: u32,
6449 pub targetname: &'a str,
6450}
6451#[derive(Debug, Clone, Deserialize)]
6452pub struct TriggerCaptureArea<'a> {
6453 #[serde(default)]
6454 pub angles: Option<Angles>,
6455 pub area_cap_point: &'a str,
6456 pub area_time_to_cap: f32,
6457 #[serde(default)]
6458 pub filtername: Option<&'a str>,
6459 #[serde(default)]
6460 pub linedivider1: Option<&'a str>,
6461 #[serde(default)]
6462 pub linedivider2: Option<&'a str>,
6463 pub model: &'a str,
6464 #[serde(default)]
6465 pub onbreakcap: Option<&'a str>,
6466 #[serde(default)]
6467 pub onbreakteam1: Option<&'a str>,
6468 #[serde(default)]
6469 pub onbreakteam2: Option<&'a str>,
6470 #[serde(default)]
6471 pub oncapteam1: Option<&'a str>,
6472 pub oncapteam2: &'a str,
6473 #[serde(default)]
6474 pub onendcap: Option<&'a str>,
6475 #[serde(default)]
6476 pub onendtouchall: Option<&'a str>,
6477 #[serde(default)]
6478 pub onnumcapperschanged: Option<&'a str>,
6479 #[serde(default)]
6480 pub onnumcapperschanged2: Option<&'a str>,
6481 #[serde(default)]
6482 pub onstartcap: Option<&'a str>,
6483 #[serde(default)]
6484 pub onstartteam1: Option<&'a str>,
6485 #[serde(default)]
6486 pub onstartteam2: Option<&'a str>,
6487 #[serde(default)]
6488 pub onstarttouchall: Option<&'a str>,
6489 #[serde(default)]
6490 pub onuser1: Option<&'a str>,
6491 #[serde(default)]
6492 pub origin: Option<Vector>,
6493 #[serde(default)]
6494 pub parentname: Option<&'a str>,
6495 #[serde(deserialize_with = "deserialize_bool")]
6496 #[serde(default)]
6497 pub solid: bool,
6498 #[serde(default)]
6499 pub spawnflags: Option<u32>,
6500 #[serde(deserialize_with = "deserialize_bool")]
6501 #[serde(default)]
6502 pub startdisabled: bool,
6503 #[serde(default)]
6504 pub targetname: Option<&'a str>,
6505 #[serde(deserialize_with = "deserialize_bool")]
6506 pub team_cancap_2: bool,
6507 #[serde(deserialize_with = "deserialize_bool")]
6508 pub team_cancap_3: bool,
6509 pub team_numcap_2: u8,
6510 pub team_numcap_3: u8,
6511 #[serde(default)]
6512 pub team_spawn_2: Option<i32>,
6513 #[serde(default)]
6514 pub team_spawn_3: Option<i32>,
6515 #[serde(deserialize_with = "deserialize_bool")]
6516 #[serde(default)]
6517 pub team_startcap_2: bool,
6518 #[serde(deserialize_with = "deserialize_bool")]
6519 #[serde(default)]
6520 pub team_startcap_3: bool,
6521}
6522#[derive(Debug, Clone, Deserialize)]
6523pub struct TriggerCatapult<'a> {
6524 pub airctrlsupressiontime: f32,
6525 #[serde(default)]
6526 pub angles: Option<Angles>,
6527 #[serde(deserialize_with = "deserialize_bool")]
6528 pub applyangularimpulse: bool,
6529 pub entryangletolerance: f32,
6530 #[serde(deserialize_with = "deserialize_bool")]
6531 pub exactvelocitychoicetype: bool,
6532 #[serde(default)]
6533 pub filtername: Option<&'a str>,
6534 pub launchdirection: Vector,
6535 #[serde(default)]
6536 pub launchtarget: Option<&'a str>,
6537 pub lowerthreshold: f32,
6538 pub model: &'a str,
6539 #[serde(default)]
6540 pub oncapteam1_pd: Option<&'a str>,
6541 #[serde(default)]
6542 pub oncapteam2_pd: Option<&'a str>,
6543 pub oncatapulted: &'a str,
6544 #[serde(deserialize_with = "deserialize_bool")]
6545 pub onlyvelocitycheck: bool,
6546 #[serde(default)]
6547 pub onstarttouch: Option<&'a str>,
6548 pub origin: Vector,
6549 #[serde(default)]
6550 pub parentname: Option<&'a str>,
6551 pub physicsspeed: i32,
6552 pub playerspeed: i32,
6553 pub spawnflags: u32,
6554 #[serde(deserialize_with = "deserialize_bool")]
6555 pub startdisabled: bool,
6556 #[serde(default)]
6557 pub targetname: Option<&'a str>,
6558 pub upperthreshold: f32,
6559 #[serde(deserialize_with = "deserialize_bool")]
6560 pub useexactvelocity: bool,
6561 #[serde(deserialize_with = "deserialize_bool")]
6562 pub usethresholdcheck: bool,
6563}
6564#[derive(Debug, Clone, Deserialize)]
6565pub struct TriggerGravity<'a> {
6566 pub gravity: f32,
6567 pub model: &'a str,
6568 pub origin: Vector,
6569 pub spawnflags: u32,
6570 #[serde(deserialize_with = "deserialize_bool")]
6571 pub startdisabled: bool,
6572 pub targetname: &'a str,
6573}
6574#[derive(Debug, Clone, Deserialize)]
6575pub struct TriggerHurt<'a> {
6576 #[serde(default)]
6577 pub angles: Option<Angles>,
6578 pub damage: f32,
6579 pub damagecap: f32,
6580 #[serde(default)]
6581 pub damagemodel: Option<i32>,
6582 pub damagetype: i32,
6583 #[serde(deserialize_with = "deserialize_bool")]
6584 #[serde(default)]
6585 pub effects: bool,
6586 #[serde(default)]
6587 pub filtername: Option<&'a str>,
6588 #[serde(default)]
6589 pub globalname: Option<&'a str>,
6590 #[serde(default)]
6591 pub model: Option<&'a str>,
6592 #[serde(deserialize_with = "deserialize_bool")]
6593 #[serde(default)]
6594 pub nodmgforce: bool,
6595 #[serde(default)]
6596 pub onendtouch: Option<&'a str>,
6597 #[serde(default)]
6598 pub onendtouchall: Option<&'a str>,
6599 #[serde(default)]
6600 pub onhurtplayer: Option<&'a str>,
6601 #[serde(default)]
6602 pub onstarttouch: Option<&'a str>,
6603 #[serde(default)]
6604 pub onstarttouchall: Option<&'a str>,
6605 pub origin: Vector,
6606 #[serde(default)]
6607 pub parentname: Option<&'a str>,
6608 pub spawnflags: u32,
6609 #[serde(deserialize_with = "deserialize_bool")]
6610 #[serde(default)]
6611 pub startdisabled: bool,
6612 #[serde(default)]
6613 pub targetname: Option<&'a str>,
6614 #[serde(deserialize_with = "deserialize_bool")]
6615 #[serde(default)]
6616 pub teamnum: bool,
6617 #[serde(default)]
6618 pub thinkfunction: Option<&'a str>,
6619 #[serde(default)]
6620 pub vscripts: Option<&'a str>,
6621}
6622#[derive(Debug, Clone, Deserialize)]
6623pub struct TriggerIgnite<'a> {
6624 #[serde(default)]
6625 pub angles: Option<Angles>,
6626 pub burn_duration: f32,
6627 pub damage_percent_per_second: f32,
6628 #[serde(default)]
6629 pub filtername: Option<&'a str>,
6630 pub model: &'a str,
6631 #[serde(default)]
6632 pub onstarttouch: Option<&'a str>,
6633 #[serde(default)]
6634 pub onstarttouchall: Option<&'a str>,
6635 pub origin: Vector,
6636 #[serde(default)]
6637 pub parentname: Option<&'a str>,
6638 pub spawnflags: u32,
6639 #[serde(deserialize_with = "deserialize_bool")]
6640 pub startdisabled: bool,
6641 #[serde(default)]
6642 pub targetname: Option<&'a str>,
6643}
6644#[derive(Debug, Clone, Deserialize)]
6645pub struct TriggerIgniteArrows<'a> {
6646 #[serde(default)]
6647 pub angles: Option<Angles>,
6648 pub model: &'a str,
6649 pub origin: Vector,
6650 pub spawnflags: u32,
6651 #[serde(deserialize_with = "deserialize_bool")]
6652 pub startdisabled: bool,
6653}
6654#[derive(Debug, Clone, Deserialize)]
6655pub struct TriggerLook<'a> {
6656 pub fieldofview: f32,
6657 pub looktime: f32,
6658 pub model: &'a str,
6659 pub ontrigger: &'a str,
6660 pub origin: Vector,
6661 pub spawnflags: u32,
6662 #[serde(deserialize_with = "deserialize_bool")]
6663 pub startdisabled: bool,
6664 pub target: &'a str,
6665 pub targetname: &'a str,
6666 pub timeout: f32,
6667}
6668#[derive(Debug, Clone, Deserialize)]
6669pub struct TriggerMultiple<'a> {
6670 #[serde(default)]
6671 pub angles: Option<Angles>,
6672 #[serde(default)]
6673 pub duration: Option<u8>,
6674 #[serde(default)]
6675 pub filtername: Option<&'a str>,
6676 pub model: &'a str,
6677 #[serde(default)]
6678 pub onendtouch: Option<&'a str>,
6679 #[serde(default)]
6680 pub onendtouchall: Option<&'a str>,
6681 #[serde(default)]
6682 pub onnottouching: Option<&'a str>,
6683 #[serde(default)]
6684 pub onstarttouch: Option<&'a str>,
6685 #[serde(default)]
6686 pub onstarttouchall: Option<&'a str>,
6687 #[serde(default)]
6688 pub ontouching: Option<&'a str>,
6689 #[serde(default)]
6690 pub ontrigger: Option<&'a str>,
6691 #[serde(default)]
6692 pub onuser1: Option<&'a str>,
6693 pub origin: Vector,
6694 #[serde(default)]
6695 pub parentname: Option<&'a str>,
6696 #[serde(deserialize_with = "deserialize_bool")]
6697 #[serde(default)]
6698 pub solid: bool,
6699 pub spawnflags: u32,
6700 #[serde(deserialize_with = "deserialize_bool")]
6701 #[serde(default)]
6702 pub startdisabled: bool,
6703 #[serde(default)]
6704 pub targetname: Option<&'a str>,
6705 pub wait: f32,
6706}
6707#[derive(Debug, Clone, Deserialize)]
6708pub struct TriggerOnce<'a> {
6709 #[serde(default)]
6710 pub angles: Option<Angles>,
6711 #[serde(default)]
6712 pub filtername: Option<&'a str>,
6713 pub model: &'a str,
6714 pub onstarttouch: &'a str,
6715 pub ontrigger: &'a str,
6716 pub origin: Vector,
6717 #[serde(default)]
6718 pub parentname: Option<&'a str>,
6719 pub spawnflags: u32,
6720 #[serde(deserialize_with = "deserialize_bool")]
6721 pub startdisabled: bool,
6722 #[serde(default)]
6723 pub targetname: Option<&'a str>,
6724}
6725#[derive(Debug, Clone, Deserialize)]
6726pub struct TriggerPasstimeBall<'a> {
6727 pub model: &'a str,
6728 pub onballenter: &'a str,
6729 pub onballexit: &'a str,
6730 #[serde(default)]
6731 pub targetname: Option<&'a str>,
6732}
6733#[derive(Debug, Clone, Deserialize)]
6734pub struct TriggerPlayerRespawnOverride<'a> {
6735 #[serde(default)]
6736 pub angles: Option<Angles>,
6737 #[serde(default)]
6738 pub filtername: Option<&'a str>,
6739 pub model: &'a str,
6740 pub origin: Vector,
6741 pub respawntime: u8,
6742 pub spawnflags: u32,
6743 #[serde(deserialize_with = "deserialize_bool")]
6744 pub startdisabled: bool,
6745 #[serde(default)]
6746 pub targetname: Option<&'a str>,
6747 #[serde(deserialize_with = "deserialize_bool")]
6748 #[serde(default)]
6749 pub wait: bool,
6750}
6751#[derive(Debug, Clone, Deserialize)]
6752pub struct TriggerPush<'a> {
6753 pub alternateticksfix: f32,
6754 #[serde(default)]
6755 pub angles: Option<Angles>,
6756 #[serde(default)]
6757 pub filtername: Option<&'a str>,
6758 #[serde(default)]
6759 pub model: Option<&'a str>,
6760 #[serde(default)]
6761 pub onendtouch: Option<&'a str>,
6762 #[serde(default)]
6763 pub onstarttouch: Option<&'a str>,
6764 #[serde(default)]
6765 pub onstarttouchall: Option<&'a str>,
6766 #[serde(default)]
6767 pub onuser1: Option<&'a str>,
6768 pub origin: Vector,
6769 #[serde(default)]
6770 pub parentname: Option<&'a str>,
6771 pub pushdir: Vector,
6772 pub spawnflags: u32,
6773 pub speed: u16,
6774 #[serde(deserialize_with = "deserialize_bool")]
6775 pub startdisabled: bool,
6776 #[serde(default)]
6777 pub targetname: Option<&'a str>,
6778 #[serde(deserialize_with = "deserialize_bool")]
6779 #[serde(default)]
6780 pub teamnum: bool,
6781}
6782#[derive(Debug, Clone, Deserialize)]
6783pub struct TriggerRdVaultTrigger<'a> {
6784 #[serde(default)]
6785 pub angles: Option<Angles>,
6786 pub model: &'a str,
6787 #[serde(default)]
6788 pub onpointsendstealing: Option<&'a str>,
6789 #[serde(default)]
6790 pub onpointsstartstealing: Option<&'a str>,
6791 pub origin: Vector,
6792 pub spawnflags: u32,
6793 #[serde(deserialize_with = "deserialize_bool")]
6794 pub startdisabled: bool,
6795 pub teamnum: u8,
6796}
6797#[derive(Debug, Clone, Deserialize)]
6798pub struct TriggerRemoveTfPlayerCondition<'a> {
6799 #[serde(default)]
6800 pub angles: Option<Angles>,
6801 pub condition: i32,
6802 pub model: &'a str,
6803 #[serde(default)]
6804 pub onstarttouch: Option<&'a str>,
6805 pub origin: Vector,
6806 pub spawnflags: u32,
6807 #[serde(deserialize_with = "deserialize_bool")]
6808 pub startdisabled: bool,
6809 #[serde(default)]
6810 pub targetname: Option<&'a str>,
6811}
6812#[derive(Debug, Clone, Deserialize)]
6813pub struct TriggerSoundscape<'a> {
6814 #[serde(default)]
6815 pub angles: Option<Angles>,
6816 pub model: &'a str,
6817 #[serde(default)]
6818 pub onendtouch: Option<&'a str>,
6819 #[serde(default)]
6820 pub onstarttouch: Option<&'a str>,
6821 pub origin: Vector,
6822 #[serde(default)]
6823 pub soundscape: Option<&'a str>,
6824 pub spawnflags: u32,
6825 #[serde(deserialize_with = "deserialize_bool")]
6826 pub startdisabled: bool,
6827 #[serde(default)]
6828 pub targetname: Option<&'a str>,
6829}
6830#[derive(Debug, Clone, Deserialize)]
6831pub struct TriggerStun<'a> {
6832 #[serde(default)]
6833 pub angles: Option<Angles>,
6834 #[serde(default)]
6835 pub filtername: Option<&'a str>,
6836 pub model: &'a str,
6837 pub move_speed_reduction: f32,
6838 #[serde(default)]
6839 pub onfullyclosed: Option<&'a str>,
6840 #[serde(default)]
6841 pub onstarttouch: Option<&'a str>,
6842 #[serde(default)]
6843 pub onstarttouchall: Option<&'a str>,
6844 #[serde(default)]
6845 pub onstunplayer: Option<&'a str>,
6846 pub origin: Vector,
6847 #[serde(default)]
6848 pub parentname: Option<&'a str>,
6849 pub spawnflags: u32,
6850 #[serde(deserialize_with = "deserialize_bool")]
6851 pub startdisabled: bool,
6852 pub stun_duration: f32,
6853 pub stun_effects: i32,
6854 pub stun_type: i32,
6855 #[serde(default)]
6856 pub targetname: Option<&'a str>,
6857 pub trigger_delay: f32,
6858}
6859#[derive(Debug, Clone, Deserialize)]
6860pub struct TriggerTeleport<'a> {
6861 #[serde(default)]
6862 pub angles: Option<Angles>,
6863 #[serde(default)]
6864 pub filtername: Option<&'a str>,
6865 #[serde(default)]
6866 pub landmark: Option<&'a str>,
6867 pub model: &'a str,
6868 #[serde(default)]
6869 pub oncapteam1_pd: Option<&'a str>,
6870 #[serde(default)]
6871 pub oncapteam2_pd: Option<&'a str>,
6872 #[serde(default)]
6873 pub onendtouch: Option<&'a str>,
6874 pub onstarttouch: &'a str,
6875 #[serde(default)]
6876 pub onstarttouchall: Option<&'a str>,
6877 #[serde(default)]
6878 pub ontouching: Option<&'a str>,
6879 pub origin: Vector,
6880 #[serde(default)]
6881 pub parentname: Option<&'a str>,
6882 pub spawnflags: u32,
6883 #[serde(deserialize_with = "deserialize_bool")]
6884 pub startdisabled: bool,
6885 #[serde(default)]
6886 pub target: Option<&'a str>,
6887 #[serde(default)]
6888 pub targetname: Option<&'a str>,
6889}
6890#[derive(Debug, Clone, Deserialize)]
6891pub struct TriggerTeleportRelative<'a> {
6892 #[serde(default)]
6893 pub angles: Option<Angles>,
6894 pub model: &'a str,
6895 pub origin: Vector,
6896 pub spawnflags: u32,
6897 #[serde(deserialize_with = "deserialize_bool")]
6898 pub startdisabled: bool,
6899 pub targetname: &'a str,
6900 pub teleportoffset: Vector,
6901}
6902#[derive(Debug, Clone, Deserialize)]
6903pub struct TriggerTimerDoor<'a> {
6904 pub area_cap_point: &'a str,
6905 pub area_time_to_cap: f32,
6906 pub door_name: &'a str,
6907 pub filtername: &'a str,
6908 pub model: &'a str,
6909 #[serde(default)]
6910 pub onbreakteam2: Option<&'a str>,
6911 pub oncapteam2: &'a str,
6912 pub onendtouchall: &'a str,
6913 pub onstarttouchall: &'a str,
6914 pub origin: Vector,
6915 pub spawnflags: u32,
6916 #[serde(deserialize_with = "deserialize_bool")]
6917 pub startdisabled: bool,
6918 pub targetname: &'a str,
6919 #[serde(deserialize_with = "deserialize_bool")]
6920 pub team_cancap_2: bool,
6921 #[serde(deserialize_with = "deserialize_bool")]
6922 pub team_cancap_3: bool,
6923 #[serde(deserialize_with = "deserialize_bool")]
6924 pub team_numcap_2: bool,
6925 #[serde(deserialize_with = "deserialize_bool")]
6926 pub team_numcap_3: bool,
6927 #[serde(deserialize_with = "deserialize_bool")]
6928 pub team_startcap_2: bool,
6929 #[serde(deserialize_with = "deserialize_bool")]
6930 pub team_startcap_3: bool,
6931}
6932#[derive(Debug, Clone, Deserialize)]
6933pub struct TriggerVphysicsMotion<'a> {
6934 pub filtername: &'a str,
6935 pub model: &'a str,
6936 pub origin: Vector,
6937 pub parentname: &'a str,
6938 pub particletrailendsize: u8,
6939 pub particletraillifetime: u8,
6940 pub particletrailstartsize: u8,
6941 pub setadditionalairdensity: u16,
6942 pub setangvelocitylimit: f32,
6943 pub setangvelocityscale: f32,
6944 pub setgravityscale: f32,
6945 pub setlinearforce: f32,
6946 pub setlinearforceangles: Angles,
6947 pub setvelocitylimit: f32,
6948 pub setvelocitylimitdelta: u32,
6949 pub setvelocityscale: f32,
6950 pub spawnflags: u32,
6951 #[serde(deserialize_with = "deserialize_bool")]
6952 pub startdisabled: bool,
6953 pub targetname: &'a str,
6954}
6955#[derive(Debug, Clone, Deserialize)]
6956pub struct WaterLodControl<'a> {
6957 #[serde(default)]
6958 pub angles: Option<Angles>,
6959 pub cheapwaterenddistance: f32,
6960 pub cheapwaterstartdistance: f32,
6961 #[serde(default)]
6962 pub origin: Option<Vector>,
6963 #[serde(default)]
6964 pub targetname: Option<&'a str>,
6965}
6966#[derive(Debug, Clone, Deserialize)]
6967pub struct WheelOfDoom<'a> {
6968 pub angles: Angles,
6969 pub effect_duration: f32,
6970 #[serde(deserialize_with = "deserialize_bool")]
6971 pub has_spiral: bool,
6972 pub oneffectapplied: &'a str,
6973 pub oneffectexpired: &'a str,
6974 pub origin: Vector,
6975 pub targetname: &'a str,
6976}
6977#[derive(Debug, Clone, Deserialize)]
6978pub struct Worldspawn<'a> {
6979 #[serde(default)]
6980 pub _minlight: Option<f32>,
6981 #[serde(default)]
6982 pub author: Option<&'a str>,
6983 #[serde(default)]
6984 pub chaptertitle: Option<&'a str>,
6985 #[serde(deserialize_with = "deserialize_bool")]
6986 #[serde(default)]
6987 pub coldworld: bool,
6988 #[serde(default)]
6989 pub comment: Option<&'a str>,
6990 pub detailmaterial: &'a str,
6991 pub detailvbsp: &'a str,
6992 #[serde(default)]
6993 pub fogcolor: Option<Color>,
6994 #[serde(default)]
6995 pub fogcolor2: Option<Color>,
6996 #[serde(default)]
6997 pub fogdir: Option<Angles>,
6998 #[serde(default)]
6999 pub fogend: Option<f32>,
7000 #[serde(default)]
7001 pub fogstart: Option<f32>,
7002 pub mapversion: u16,
7003 #[serde(default)]
7004 pub maxoccludeearea: Option<f32>,
7005 pub maxpropscreenwidth: f32,
7006 #[serde(default)]
7007 pub maxrange: Option<u16>,
7008 #[serde(default)]
7009 pub message: Option<&'a str>,
7010 #[serde(default)]
7011 pub minoccluderarea: Option<f32>,
7012 #[serde(default)]
7013 pub minoccluderarea_x360: Option<f32>,
7014 #[serde(default)]
7015 pub minpropscreenwidth: Option<f32>,
7016 #[serde(deserialize_with = "deserialize_bool")]
7017 #[serde(default)]
7018 pub newunit: bool,
7019 pub skyname: &'a str,
7020 #[serde(deserialize_with = "deserialize_bool")]
7021 #[serde(default)]
7022 pub sounds: bool,
7023 #[serde(default)]
7024 pub spawnflags: Option<u32>,
7025 #[serde(default)]
7026 pub targetname: Option<&'a str>,
7027 pub world_maxs: Vector,
7028 pub world_mins: Vector,
7029}