https://springrts-wiki.p2004a.com/mediawiki/api.php?action=feedcontributions&feedformat=atom&user=Evil4zergginSpring - User contributions [en]2026-11-08T22:53:30ZUser contributionsMediaWiki 1.43.11https://springrts-wiki.p2004a.com/mediawiki/index.php?title=Animation-CobConstants&diff=1927Animation-CobConstants2009-02-16T19:55:36Z<p>Evil4zerggin: </p>
<hr />
<div>==Source==<br />
<br />
This has a list of all COB SET/GET constants: https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Units/COB/CobInstance.cpp<br />
<br />
You'll want to include a file with these constants in your script.<br />
<br />
==SET/GET==<br />
<br />
===Use===<br />
Use GET [tag] to get a value. Some GETs refer to functions; in this case, use GET [tag](arg1, arg2, arg3, arg4).<br />
Use SET [tag] to [value] to change a value.<br />
<br />
===Tags===<br />
There's a lot of GET/SET tags; I'll cover some of the more useful but less intuitive ones.<br />
<br />
*ACTIVATION: Whether the unit is on (true) or off (false).<br />
*ARMORED: When true, any damage dealt to the unit will be multiplied by its damageModifier.<br />
*PRINT: You can use GET PRINT to send up to 4 arguments to chat. Useful for debugging.<br />
*VETERAN_LEVEL: The unit's experience times 100. Note that you can SET this via script, although the unit won't gain any extra health from doing so.<br />
<br />
=== Custom Variables ===<br />
Higher GET/SET numbers are reserved for custom variables. These are very useful for Lua integration. Setting these variables is much (perhaps 100x) faster than calling functions across Lua and COB; the disadvantages are the limited number of variables and the fact that the other side is not immediately notified of a change in the variable.<br />
<br />
*Unit variables: The 8 numbers starting at 1024 correspond to per-unit variables. To get at these from Lua, use Spring.[Get|Set]COBUnitVar.<br />
*Team variables: The 64 numbers starting at 2048 correspond to per-team variables. To get at these from Lua, use Spring.[Get|Set]COBTeamVar.<br />
*Ally variables: The 64 numbers starting at 3072 correspond to per-team variables. To get at these from Lua, use Spring.[Get|Set]COBAllyTeamVar.<br />
*Global variables: The 4096 numbers starting at 4096 correspond to global variables. To get at these from Lua, use Spring.[Get|Set]COBGlobalVar.<br />
<br />
==emit-sfx==<br />
<br />
emit-sfx [sfxtype] from [piece];<br />
<br />
The least significant byte of sfxtype is treated as an unsigned integer; the remaining bits are a bitmask. The bitmask indicates what ''type'' of sfx to emit, while the number indicates ''which'' sfx of that type to emit. The bits are as follows:<br />
<br />
*256: Point-based fx. Used for white smoke (1), black smoke (2), and bubbles (3).<br />
*1024: Unit sfx. Use with the unit's sfxtypes.explosionGenerators. The first one is 0, the second one is 1, etc.<br />
*2048: Fire weapon. Fires a weapon from the piece (no aiming involved). Again, the first weapon is 0, the second weapon is 1, etc.<br />
*4096: Explode weapon. Detonates a weapon at the piece. Again, the first weapon is 0, the second weapon is 1, etc.<br />
<br />
==explode==<br />
<br />
Causes the piece to explode and possibly go flying. This actually gives the appearance of making a copy of the piece (henceforth referred to as "debris") so if you're using it outside of Killed() you may want to hide the piece in question.<br />
<br />
explode [piece] type [exptype];<br />
<br />
exptype is a bitmask. The bits are as follows:<br />
<br />
*SHATTER: Explodes the debris into tiny triangles. Looks like confetti.<br />
*EXPLODE_ON_HIT: Debris will explode on impact, causing about 40 damage.<br />
*FALL: Debris is affected by gravity.<br />
*SMOKE<br />
*FIRE<br />
*BITMAPONLY: No debris, just an explosion graphic.<br />
*NOCEGTRAIL<br />
*BITMAP[1...5]: Doesn't actually appear to do anything.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=Lua:Main&diff=10855Lua:Main2009-02-16T19:50:55Z<p>Evil4zerggin: </p>
<hr />
<div>'''Lua FAQ'''<br> <br />
[[Lua_Beginners_FAQ]]<br><br />
[[:Category:Lua]] (shows which interfaces are loaded by LuaUI,LuaRules,etc.)<br><br />
[http://spring.clan-sy.com/phpbb/viewtopic.php?f=23&t=15596 Forum topic with some basic information about gadgets]<br><br />
[http://spring.clan-sy.com/phpbb/viewtopic.php?f=23&t=16223 Forum topic with a manual on Spring lua scripting]<br><br />
<br />
'''Interfaces''' <font color=#55ee99>(last update: 76b1)</font><br> <br />
{{LuaInterfaces}}<br />
<br><br />
'''Other useful information'''<br><br />
[[LuaCallinReturn]]<br><br />
[http://spring.clan-sy.com/wiki/COB_Constants#Custom_Variables COB Custom Variables] <br />
<br />
'''Official Lua documentation'''<br><br />
[http://www.lua.org/pil/ 'Programming in Lua' book online]<br><br />
[http://www.lua.org/manual/5.1/ Lua 5.1 Reference manual]<br><br />
[http://lua-users.org/wiki/TutorialDirectory Lua tutorials]<br />
<br />
<br />
'''old Wikis''' <font color=red>(outdated)<br><br />
[[Lua_SyncedInterface]]<br><br />
[[Units:LuaCOB]]<br><br />
[[Lua_Startscripts]]</font></div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=Lua:Main&diff=10854Lua:Main2009-02-16T19:49:52Z<p>Evil4zerggin: </p>
<hr />
<div>'''Lua FAQ'''<br> <br />
[[Lua_Beginners_FAQ]]<br><br />
[[:Category:Lua]] (shows which interfaces are loaded by LuaUI,LuaRules,etc.)<br><br />
[http://spring.clan-sy.com/phpbb/viewtopic.php?f=23&t=15596 Forum topic with some basic information about gadgets]<br><br />
[http://spring.clan-sy.com/phpbb/viewtopic.php?f=23&t=16223 Forum topic with a manual on Spring lua scripting]<br><br />
<br />
'''Interfaces''' <font color=#55ee99>(last update: 76b1)</font><br> <br />
{{LuaInterfaces}}<br />
<br><br />
'''Other useful tables'''<br><br />
[[LuaCallinReturn]]<br><br />
<br />
'''Official Lua documentation'''<br><br />
[http://www.lua.org/pil/ 'Programming in Lua' book online]<br><br />
[http://www.lua.org/manual/5.1/ Lua 5.1 Reference manual]<br><br />
[http://lua-users.org/wiki/TutorialDirectory Lua tutorials]<br />
<br />
<br />
'''old Wikis''' <font color=red>(outdated)<br><br />
[[Lua_SyncedInterface]]<br><br />
[[Units:LuaCOB]]<br><br />
[[Lua_Startscripts]]</font></div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=Animation-CobConstants&diff=1926Animation-CobConstants2009-02-16T19:48:49Z<p>Evil4zerggin: </p>
<hr />
<div>==Source==<br />
<br />
This has a list of all COB SET/GET constants: https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Units/COB/CobInstance.cpp<br />
<br />
You'll want to include a file with these constants in your script.<br />
<br />
==SET/GET==<br />
<br />
===Use===<br />
Use GET [tag] to get a value. Some GETs refer to functions; in this case, use GET [tag](arg1, arg2, arg3, arg4).<br />
Use SET [tag] to [value] to change a value.<br />
<br />
===Tags===<br />
There's a lot of GET/SET tags; I'll cover some of the more useful but less intuitive ones.<br />
<br />
*ACTIVATION: Whether the unit is on (true) or off (false).<br />
*ARMORED: When true, any damage dealt to the unit will be multiplied by its damageModifier.<br />
*PRINT: You can use GET PRINT to send up to 4 arguments to chat. Useful for debugging.<br />
*VETERAN_LEVEL: The unit's experience times 100. Note that you can SET this via script, although the unit won't gain any extra health from doing so.<br />
<br />
=== Custom Variables ===<br />
Higher GET/SET numbers are reserved for custom variables. These are very useful for Lua integration. Setting these variables is much (perhaps 100x) faster than calling functions across Lua and COB; the disadvantages are the limited number of variables and the fact that the other side is not immediately notified of a change in the variable.<br />
<br />
*Unit variables: The 8 numbers starting at 1024 correspond to per-unit variables. To get at these from Lua, use Spring.[Get|Set]GetCOBUnitVar.<br />
*Team variables: The 64 numbers starting at 2048 correspond to per-team variables. To get at these from Lua, use Spring.[Get|Set]GetCOBTeamVar.<br />
*Ally variables: The 64 numbers starting at 3072 correspond to per-team variables. To get at these from Lua, use Spring.[Get|Set]GetCOBAllyTeamVar.<br />
*Global variables: The 4096 numbers starting at 4096 correspond to global variables. To get at these from Lua, use Spring.[Get|Set]GetCOBGlobalVar.<br />
<br />
==emit-sfx==<br />
<br />
emit-sfx [sfxtype] from [piece];<br />
<br />
The least significant byte of sfxtype is treated as an unsigned integer; the remaining bits are a bitmask. The bitmask indicates what ''type'' of sfx to emit, while the number indicates ''which'' sfx of that type to emit. The bits are as follows:<br />
<br />
*256: Point-based fx. Used for white smoke (1), black smoke (2), and bubbles (3).<br />
*1024: Unit sfx. Use with the unit's sfxtypes.explosionGenerators. The first one is 0, the second one is 1, etc.<br />
*2048: Fire weapon. Fires a weapon from the piece (no aiming involved). Again, the first weapon is 0, the second weapon is 1, etc.<br />
*4096: Explode weapon. Detonates a weapon at the piece. Again, the first weapon is 0, the second weapon is 1, etc.<br />
<br />
==explode==<br />
<br />
Causes the piece to explode and possibly go flying. This actually gives the appearance of making a copy of the piece (henceforth referred to as "debris") so if you're using it outside of Killed() you may want to hide the piece in question.<br />
<br />
explode [piece] type [exptype];<br />
<br />
exptype is a bitmask. The bits are as follows:<br />
<br />
*SHATTER: Explodes the debris into tiny triangles. Looks like confetti.<br />
*EXPLODE_ON_HIT: Debris will explode on impact, causing about 40 damage.<br />
*FALL: Debris is affected by gravity.<br />
*SMOKE<br />
*FIRE<br />
*BITMAPONLY: No debris, just an explosion graphic.<br />
*NOCEGTRAIL<br />
*BITMAP[1...5]: Doesn't actually appear to do anything.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=Animation-CobConstants&diff=1925Animation-CobConstants2009-02-16T19:46:31Z<p>Evil4zerggin: </p>
<hr />
<div>==Source==<br />
<br />
This has a list of all COB SET/GET constants: https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Units/COB/CobInstance.cpp<br />
<br />
You'll want to include a file with these constants in your script.<br />
<br />
==SET/GET==<br />
<br />
===Use===<br />
Use GET [tag] to get a value. Some GETs refer to functions; in this case, use GET [tag](arg1, arg2, arg3, arg4).<br />
Use SET [tag] to [value] to change a value.<br />
<br />
===Tags===<br />
There's a lot of GET/SET tags; I'll cover some of the more useful but less intuitive ones.<br />
<br />
*ACTIVATION: Whether the unit is on (true) or off (false).<br />
*ARMORED: When true, any damage dealt to the unit will be multiplied by its damageModifier.<br />
*PRINT: You can use GET PRINT to send up to 4 arguments to chat. Useful for debugging.<br />
*VETERAN_LEVEL: The unit's experience times 100. Note that you can SET this via script, although the unit won't gain any extra health from doing so.<br />
<br />
=== Custom Variables ===<br />
Higher GET/SET numbers are reserved for custom variables. These are very useful for Lua integration. Setting these variables is much (perhaps 100x) faster than calling functions across Lua and COB; the disadvantages are the limited number of variables and the fact that the other side is not immediately notified of a change in the variable.<br />
<br />
*Unit variables: The 8 numbers starting at 1024 correspond to per-unit variables.<br />
*Team variables: The 64 numbers starting at 2048 correspond to per-team variables. This is "team" in the old terminology; now we call them players.<br />
*Ally variables: The 64 numbers starting at 3072 correspond to per-team variables. This is "ally" in the old terminology; now we call them teams.<br />
*Global variables: The 4096 numbers starting at 4096 correspond to global variables.<br />
<br />
==emit-sfx==<br />
<br />
emit-sfx [sfxtype] from [piece];<br />
<br />
The least significant byte of sfxtype is treated as an unsigned integer; the remaining bits are a bitmask. The bitmask indicates what ''type'' of sfx to emit, while the number indicates ''which'' sfx of that type to emit. The bits are as follows:<br />
<br />
*256: Point-based fx. Used for white smoke (1), black smoke (2), and bubbles (3).<br />
*1024: Unit sfx. Use with the unit's sfxtypes.explosionGenerators. The first one is 0, the second one is 1, etc.<br />
*2048: Fire weapon. Fires a weapon from the piece (no aiming involved). Again, the first weapon is 0, the second weapon is 1, etc.<br />
*4096: Explode weapon. Detonates a weapon at the piece. Again, the first weapon is 0, the second weapon is 1, etc.<br />
<br />
==explode==<br />
<br />
Causes the piece to explode and possibly go flying. This actually gives the appearance of making a copy of the piece (henceforth referred to as "debris") so if you're using it outside of Killed() you may want to hide the piece in question.<br />
<br />
explode [piece] type [exptype];<br />
<br />
exptype is a bitmask. The bits are as follows:<br />
<br />
*SHATTER: Explodes the debris into tiny triangles. Looks like confetti.<br />
*EXPLODE_ON_HIT: Debris will explode on impact, causing about 40 damage.<br />
*FALL: Debris is affected by gravity.<br />
*SMOKE<br />
*FIRE<br />
*BITMAPONLY: No debris, just an explosion graphic.<br />
*NOCEGTRAIL<br />
*BITMAP[1...5]: Doesn't actually appear to do anything.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=Lua_UnitDefs&diff=12117Lua UnitDefs2009-01-12T19:36:02Z<p>Evil4zerggin: </p>
<hr />
<div><font style="font-size:125%" color="#55ee99">The UnitDefs[] table holds all information about the units used in the mod.<br />
Note: Its entries are metatables, so you can't use the pairs() iterator on them, use this instead:</font><br />
<font style="font-size:110%" color="lightblue"><br />
for id,unitDef in pairs(UnitDefs) do<br />
for name,param in unitDef:pairs() do<br />
Spring.Echo(name,param)<br />
end<br />
end<br />
</font><br />
<font style="font-size:125%" color="#55ee99">Very usefull is UnitDefs[i]["customParams"], since you can access any custom fbi param with it and use it in your lua scripts.</font><br />
<br />
<font style="font-size:125%" color="#55ee99">So because the UnitDefs tables are very large, I simple print here an example of it (BA5.8 core commander):</font><br />
<br />
'''UnitDefs['''216''']["customParams"]''' = {<br />
} <font color="#55ee99">Variable names written must be lowercase and variables can only be strings.</font><br />
'''UnitDefs['''216''']["TEDClass"]''' = "COMMANDER",<br />
'''UnitDefs['''216''']["activateWhenBuilt"]''' = true,<br />
'''UnitDefs['''216''']["aihint"]''' = 216,<br />
'''UnitDefs['''216''']["cobID"]''' = -1,<br />
'''UnitDefs['''216''']["airLosRadius"]''' = 21.09375,<br />
'''UnitDefs['''216''']["airStrafe"]''' = true,<br />
'''UnitDefs['''216''']["armorType"]''' = 8,<br />
'''UnitDefs['''216''']["armoredMultiple"]''' = 1,<br />
'''UnitDefs['''216''']["autoHeal"]''' = 2.6666667461395,<br />
'''UnitDefs['''216''']["bankingAllowed"]''' = false,<br />
'''UnitDefs['''216''']["buildDistance"]''' = 128,<br />
'''UnitDefs['''216''']["buildOptions"]''' = {<br />
'''[1]''' = unitDefID1,<br />
'''[2]''' = unitDefID2,<br />
...<br />
}<br />
'''UnitDefs['''216''']["buildRange3D"] = true,<br />
'''UnitDefs['''216''']["buildSpeed"]''' = 300,<br />
'''UnitDefs['''216''']["buildTime"]''' = 75000,<br />
'''UnitDefs['''216''']["buildangle"]''' = 0,<br />
'''UnitDefs['''216''']["builder"]''' = true,<br />
'''UnitDefs['''216''']["buildingDecalDecaySpeed"]''' = 0.10000000149012,<br />
'''UnitDefs['''216''']["buildingDecalSizeX"]''' = 4,<br />
'''UnitDefs['''216''']["buildingDecalSizeY"]''' = 4,<br />
'''UnitDefs['''216''']["buildingDecalType"]''' = 0,<br />
'''UnitDefs['''216''']["buildpicname"]''' = "CORCOM.DDS",<br />
'''UnitDefs['''216''']["canAssist"]''' = true,<br />
'''UnitDefs['''216''']["canAttack"]''' = true,<br />
'''UnitDefs['''216''']["canBeAssisted"]''' = true,<br />
'''UnitDefs['''216''']["canBuild"]''' = true,<br />
'''UnitDefs['''216''']["canCapture"]''' = true,<br />
'''UnitDefs['''216''']["canCloak"]''' = true,<br />
'''UnitDefs['''216''']["canCrash"]''' = true,<br />
'''UnitDefs['''216''']["canDGun"]''' = true,<br />
'''UnitDefs['''216''']["canDropFlare"]''' = false,<br />
'''UnitDefs['''216''']["canFight"]''' = true,<br />
'''UnitDefs['''216''']["canFireControl"]''' = true,<br />
'''UnitDefs['''216''']["canFly"]''' = false,<br />
'''UnitDefs['''216''']["canGuard"]''' = true,<br />
'''UnitDefs['''216''']["canHover"]''' = false,<br />
'''UnitDefs['''216''']["canKamikaze"]''' = false,<br />
'''UnitDefs['''216''']["canLoopbackAttack"]''' = false,<br />
'''UnitDefs['''216''']["canMove"]''' = true,<br />
'''UnitDefs['''216''']["canPatrol"]''' = true,<br />
'''UnitDefs['''216''']["canReclaim"]''' = true,<br />
'''UnitDefs['''216''']["canRepair"]''' = true,<br />
'''UnitDefs['''216''']["canRepeat"]''' = true,<br />
'''UnitDefs['''216''']["canRestore"]''' = true,<br />
'''UnitDefs['''216''']["canResurrect"]''' = false,<br />
'''UnitDefs['''216''']["canSelfRepair"]''' = false,<br />
'''UnitDefs['''216''']["canSubmerge"]''' = false,<br />
'''UnitDefs['''216''']["capturable"]''' = false,<br />
'''UnitDefs['''216''']["captureSpeed"]''' = 300,<br />
'''UnitDefs['''216''']["cloakCost"]''' = 100,<br />
'''UnitDefs['''216''']["cloakCostMoving"]''' = 1000,<br />
'''UnitDefs['''216''']["collide"]''' = true,<br />
'''UnitDefs['''216''']["controlRadius"]''' = 32,<br />
'''UnitDefs['''216''']["crashDrag"]''' = 32,<br />
'''UnitDefs['''216''']["deathExplosion"]''' = "COMMANDER_BLAST",<br />
'''UnitDefs['''216''']["decloakDistance"]''' = 50,<br />
'''UnitDefs['''216''']["decloakOnFire"]''' = true,<br />
'''UnitDefs['''216''']["decloakSpherical"]''' = true,<br />
'''UnitDefs['''216''']["decoyDef"]''' = nil, <br />
'''UnitDefs['''216''']["dlHoverFactor"]''' = -1,<br />
'''UnitDefs['''216''']["drag"]''' = 0.13046109676361,<br />
'''UnitDefs['''216''']["energyCost"]''' = 2500,<br />
'''UnitDefs['''216''']["energyMake"]''' = 25,<br />
'''UnitDefs['''216''']["energyStorage"]''' = 0,<br />
'''UnitDefs['''216''']["energyUpkeep"]''' = 0,<br />
'''UnitDefs['''216''']["extractRange"]''' = 0,<br />
'''UnitDefs['''216''']["extractsMetal"]''' = 0,<br />
'''UnitDefs['''216''']["extractSquare"]''' = false,<br />
'''UnitDefs['''216''']["factoryHeadingTakeoff"] = false,<br />
'''UnitDefs['''216''']["fallSpeed"]''' = 1,<br />
'''UnitDefs['''216''']["filename"]''' = "units/corcom.fbi",<br />
'''UnitDefs['''216''']["fireState"]''' = 1,<br />
<br />
'''UnitDefs['''216''']["flankingBonusMode"]''' = 0,<br />
'''UnitDefs['''216''']["flankingBonusMax"]''' = 0,<br />
'''UnitDefs['''216''']["flankingBonusMin"]''' = 0,<br />
'''UnitDefs['''216''']["flankingBonusDirX"]''' = 0,<br />
'''UnitDefs['''216''']["flankingBonusDirY"]''' = 0,<br />
'''UnitDefs['''216''']["flankingBonusDirZ"]''' = 0,<br />
'''UnitDefs['''216''']["flankingBonusMobilityAdd"]''' = 0,<br />
<br />
'''UnitDefs['''216''']["flareDelay"]''' = 0.30000001192093,<br />
'''UnitDefs['''216''']["flareDropVectorX"]''' = 0,<br />
'''UnitDefs['''216''']["flareDropVectorY"]''' = 0,<br />
'''UnitDefs['''216''']["flareDropVectorZ"]''' = 0,<br />
'''UnitDefs['''216''']["flareEfficiency"]''' = 0.5,<br />
'''UnitDefs['''216''']["flareReloadTime"]''' = 5,<br />
'''UnitDefs['''216''']["flareSalvoDelay"]''' = 0,<br />
'''UnitDefs['''216''']["flareSalvoSize"]''' = 4,<br />
'''UnitDefs['''216''']["flareTime"]''' = 90,<br />
<br />
'''UnitDefs['''216''']["floater"]''' = false,<br />
'''UnitDefs['''216''']["frontToSpeed"]''' = 0.10000000149012,<br />
'''UnitDefs['''216''']["fullHealthFactory"]''' = false,<br />
'''UnitDefs['''216''']["gaia"]''' = "",<br />
'''UnitDefs['''216''']["health"]''' = 3000,<br />
'''UnitDefs['''216''']["height"]''' = 42.333557128906,<br />
'''UnitDefs['''216''']["hideDamage"]''' = true,<br />
'''UnitDefs['''216''']["highTrajectoryType"]''' = 0,<br />
'''UnitDefs['''216''']["holdSteady"]''' = true,<br />
'''UnitDefs['''216''']["hoverAttack"]''' = false,<br />
'''UnitDefs['''216''']["humanName"]''' = "Commander",<br />
'''UnitDefs['''216''']["iconType"]''' = "corcommander",<br />
'''UnitDefs['''216''']["id"]''' = 216,<br />
'''UnitDefs['''216''']["idleAutoHeal"]''' = 2.6666667461395,<br />
'''UnitDefs['''216''']["idleTime"]''' = 1800,<br />
'''UnitDefs['''216''']["isAirBase"]''' = false,<br />
'''UnitDefs['''216''']["isBomber"]''' = false,<br />
'''UnitDefs['''216''']["isBuilder"]''' = true,<br />
'''UnitDefs['''216''']["isBuilding"]''' = false,<br />
'''UnitDefs['''216''']["isCommander"]''' = true,<br />
'''UnitDefs['''216''']["isFactory"]''' = false,<br />
'''UnitDefs['''216''']["isFeature"]''' = false,<br />
'''UnitDefs['''216''']["isFighter"]''' = false,<br />
'''UnitDefs['''216''']["isFirePlatform"]''' = false,<br />
'''UnitDefs['''216''']["isGroundUnit"]''' = false,<br />
'''UnitDefs['''216''']["isMetalExtractor"]''' = false,<br />
'''UnitDefs['''216''']["isMetalMaker"]''' = false,<br />
'''UnitDefs['''216''']["isTransport"]''' = false,<br />
'''UnitDefs['''216''']["jammerRadius"]''' = 0,<br />
'''UnitDefs['''216''']["kamikazeDist"]''' = 0,<br />
'''UnitDefs['''216''']["leaveTracks"]''' = false,<br />
'''UnitDefs['''216''']["levelGround"]''' = true,<br />
'''UnitDefs['''216''']["loadingRadius"]''' = 220,<br />
'''UnitDefs['''216''']["losHeight"]''' = 20,<br />
'''UnitDefs['''216''']["losRadius"]''' = 28.125,<br />
'''UnitDefs['''216''']["makesMetal"]''' = 0,<br />
'''UnitDefs['''216''']["mass"]''' = 5000,<br />
'''UnitDefs['''216''']["maxAcc"]''' = 0.18000000715256,<br />
'''UnitDefs['''216''']["maxAileron"]''' = 0.014999999664724,<br />
'''UnitDefs['''216''']["maxBank"]''' = 0.80000001192093,<br />
'''UnitDefs['''216''']["maxCoverage"]''' = 1000.0,<br />
'''UnitDefs['''216''']["maxDec"]''' = 0.037500001490116,<br />
'''UnitDefs['''216''']["maxElevator"]''' = 0.0099999997764826,<br />
'''UnitDefs['''216''']["maxFuel"]''' = 0,<br />
'''UnitDefs['''216''']["maxHeightDif"]''' = 14.558809280396,<br />
'''UnitDefs['''216''']["maxPitch"]''' = 0.44999998807907,<br />
'''UnitDefs['''216''']["maxRepairSpeed"]''' = 300,<br />
'''UnitDefs['''216''']["maxRudder"]''' = 0.0040000001899898,<br />
'''UnitDefs['''216''']["maxSlope"]''' = 0.93969261646271,<br />
'''UnitDefs['''216''']["maxThisUnit"]''' = 5000,<br />
'''UnitDefs['''216''']["maxWaterDepth"]''' = 35,<br />
'''UnitDefs['''216''']["maxWeaponRange"]''' = 300,<br />
'''UnitDefs['''216''']["maxx"]''' = 17.456253051758,<br />
'''UnitDefs['''216''']["maxy"]''' = 42.333557128906,<br />
'''UnitDefs['''216''']["maxz"]''' = 22.837493896484,<br />
'''UnitDefs['''216''']["metalCost"]''' = 2500,<br />
'''UnitDefs['''216''']["metalMake"]''' = 1.5,<br />
'''UnitDefs['''216''']["metalStorage"]''' = 0,<br />
'''UnitDefs['''216''']["metalUpkeep"]''' = 0,<br />
'''UnitDefs['''216''']["midx"]''' = 0,<br />
'''UnitDefs['''216''']["midy"]''' = 19.558204650879,<br />
'''UnitDefs['''216''']["midz"]''' = 0,<br />
'''UnitDefs['''216''']["minAirBasePower"]''' = 0,<br />
'''UnitDefs['''216''']["minCollisionSpeed"]''' = 1,<br />
'''UnitDefs['''216''']["minWaterDepth"]''' = -10000000,<br />
'''UnitDefs['''216''']["minx"]''' = -17.456253051758,<br />
'''UnitDefs['''216''']["miny"]''' = -3.2171478271484,<br />
'''UnitDefs['''216''']["minz"]''' = -9.9750061035156,<br />
'''UnitDefs['''216''']["modCategories"]''' = {<br />
'''["notship"]''' = false,<br />
'''["notair"]''' = false,<br />
'''["core"]''' = false,<br />
'''["commander"]''' = false,<br />
'''["all"]''' = false,<br />
'''["level10"]''' = false,<br />
'''["ctrl_c"]''' = false,<br />
'''["notsub"]''' = false,<br />
'''["weapon"]''' = false,<br />
}<br />
'''UnitDefs['''216''']["model"]''' = {<br />
'''["textures"]''' = {<br />
}<br />
'''["type"]''' = "3do",<br />
'''["name"]''' = "CORCOM",<br />
'''["path"]''' = "objects3d/CORCOM",<br />
}<br />
'''UnitDefs['''216''']["moveData"]''' = {<br />
'''["name"]''' = "KBOT3",<br />
'''["type"]''' = "ground",<br />
'''["maxSlope"]''' = 0.41221475601196,<br />
'''["id"]''' = 2,<br />
'''["depthMod"]''' = 0.10000000149012,<br />
'''["crushStrength"]''' = 50,<br />
'''["family"]''' = "kbot",<br />
'''["depth"]''' = 5000,<br />
'''["slopeMod"]''' = 9.680196762085,<br />
'''["size"]''' = 4,<br />
}<br />
'''UnitDefs['''216''']["moveState"]''' = 1,<br />
'''UnitDefs['''216''']["moveType"]''' = 0,<br />
'''UnitDefs['''216''']["myGravity"]''' = 0.40000000596046,<br />
'''UnitDefs['''216''']["name"]''' = "corcom",<br />
'''UnitDefs['''216''']["nanoColorB"]''' = 0.20000000298023,<br />
'''UnitDefs['''216''']["nanoColorG"]''' = 0.69999998807907,<br />
'''UnitDefs['''216''']["nanoColorR"]''' = 0.20000000298023,<br />
'''UnitDefs['''216''']["needGeo"]''' = false,<br />
'''UnitDefs['''216''']["noChaseCategories"]''' = {<br />
'''["all"]''' = false,<br />
}<br />
'''UnitDefs['''216''']["onOffable"]''' = false,<br />
'''UnitDefs['''216''']["pieceTrailCEGTag"]''' = "",<br />
'''UnitDefs['''216''']["pieceTrailCEGRange"]''' = 0,<br />
'''UnitDefs['''216''']["power"]''' = 2541.6667480469,<br />
'''UnitDefs['''216''']["radarRadius"]''' = 700,<br />
'''UnitDefs['''216''']["radius"]''' = 24.740692138672,<br />
'''UnitDefs['''216''']["reclaimSpeed"]''' = 300,<br />
'''UnitDefs['''216''']["reclaimable"]''' = false,<br />
'''UnitDefs['''216''']["refuelTime"]''' = 5,<br />
'''UnitDefs['''216''']["releaseHeld"]''' = false,<br />
'''UnitDefs['''216''']["repairSpeed"]''' = 300,<br />
'''UnitDefs['''216''']["resurrectSpeed"]''' = 300,<br />
'''UnitDefs['''216''']["scriptName"]''' = "armcom.cob",<br />
'''UnitDefs['''216''']["scriptPath"]''' = "scripts/armcom.cob",<br />
'''UnitDefs['''216''']["seismicRadius"]''' = 0,<br />
'''UnitDefs['''216''']["seismicSignature"]''' = 0,<br />
'''UnitDefs['''216''']["selfDCountdown"]''' = 5,<br />
'''UnitDefs['''216''']["selfDExplosion"]''' = "COMMANDER_BLAST",<br />
'''UnitDefs['''216''']["shieldWeaponDef"]''' = nil, <br />
'''UnitDefs['''216''']["showNanoFrame"]''' = true,<br />
'''UnitDefs['''216''']["showNanoSpray"]''' = true,<br />
'''UnitDefs['''216''']["showPlayerName"]''' = true,<br />
'''UnitDefs['''216''']["slideTolerance"]''' = 0,<br />
'''UnitDefs['''216''']["smoothAnim"]''' = true,<br />
'''UnitDefs['''216''']["sonarJamRadius"]''' = 0,<br />
'''UnitDefs['''216''']["sonarRadius"]''' = 300,<br />
'''UnitDefs['''216''']["sonarStealth"]''' = false,<br />
'''UnitDefs['''216''']["sounds"]''' = {<br />
'''["repair"]''' = {<br />
}<br />
'''["arrived"]''' = {<br />
}<br />
'''["underattack"]''' = {<br />
'''[1]''' = {<br />
'''["id"]''' = 140,<br />
'''["name"]''' = "warning2",<br />
'''["volume"]''' = 5,<br />
}<br />
}<br />
'''["select"]''' = {<br />
'''[1]''' = {<br />
'''["id"]''' = 213,<br />
'''["name"]''' = "kccorsel",<br />
'''["volume"]''' = 5,<br />
}<br />
}<br />
'''["deactivate"]''' = {<br />
}<br />
'''["activate"]''' = {<br />
}<br />
'''["ok"]''' = {<br />
'''[1]''' = {<br />
'''["id"]''' = 212,<br />
'''["name"]''' = "kcormov",<br />
'''["volume"]''' = 5,<br />
}<br />
}<br />
'''["cant"]''' = {<br />
'''[1]''' = {<br />
'''["id"]''' = 92,<br />
'''["name"]''' = "cantdo4",<br />
'''["volume"]''' = 5,<br />
}<br />
}<br />
'''["working"]''' = {<br />
}<br />
'''["build"]''' = {<br />
'''[1]''' = {<br />
'''["id"]''' = 197,<br />
'''["name"]''' = "nanlath2",<br />
'''["volume"]''' = 5,<br />
}<br />
}<br />
}<br />
'''UnitDefs['''216''']["speed"]''' = 37.5,<br />
'''UnitDefs['''216''']["speedToFront"]''' = 0.070000000298023,<br />
'''UnitDefs['''216''']["springCategories"]''' = {<br />
'''["commander"]''' = false,<br />
'''["notship"]''' = false,<br />
'''["notair"]''' = false,<br />
'''["all"]''' = false,<br />
'''["notsub"]''' = false,<br />
'''["weapon"]''' = false,<br />
}<br />
'''UnitDefs['''216''']["startCloaked"]''' = false,<br />
'''UnitDefs['''216''']["stealth"]''' = false,<br />
'''UnitDefs['''216''']["stockpileWeaponDef"]''' = nil, <br />
'''UnitDefs['''216''']["strafeToAttack"]''' = false,<br />
'''UnitDefs['''216''']["targfac"]''' = false,<br />
'''UnitDefs['''216''']["techLevel"]''' = 0,<br />
'''UnitDefs['''216''']["terraformSpeed"]''' = 300,<br />
'''UnitDefs['''216''']["tidalGenerator"]''' = 0,<br />
'''UnitDefs['''216''']["tooltip"]''' = "Commander",<br />
'''UnitDefs['''216''']["totalEnergyOut"]''' = 25,<br />
'''UnitDefs['''216''']["trackOffset"]''' = 0,<br />
'''UnitDefs['''216''']["trackStrength"]''' = 0,<br />
'''UnitDefs['''216''']["trackStretch"]''' = 1,<br />
'''UnitDefs['''216''']["trackType"]''' = 0,<br />
'''UnitDefs['''216''']["trackWidth"]''' = 32,<br />
'''UnitDefs['''216''']["transportByEnemy"]''' = true,<br />
'''UnitDefs['''216''']["transportCapacity"]''' = 0,<br />
'''UnitDefs['''216''']["transportMass"]''' = 100000,<br />
'''UnitDefs['''216''']["transportSize"]''' = 0,<br />
'''UnitDefs['''216''']["transportUnloadMethod"]''' = 0,<br />
'''UnitDefs['''216''']["turnRadius"]''' = 500,<br />
'''UnitDefs['''216''']["turnRate"]''' = 1133,<br />
'''UnitDefs['''216''']["type"]''' = "Builder",<br />
'''UnitDefs['''216''']["unitFallSpeed"]''' = 1.0,<br />
'''UnitDefs['''216''']["upright"]''' = true,<br />
'''UnitDefs['''216''']["useBuildingGroundDecal"]''' = false,<br />
'''UnitDefs['''216''']["wantedHeight"]''' = 0,<br />
'''UnitDefs['''216''']["waterline"]''' = 0,<br />
'''UnitDefs['''216''']["weapons"]''' = {<br />
'''[1]''' = {<br />
'''["onlyTargets"]''' = {<br />
'''["antiflame"]''' = false,<br />
'''["vtol"]''' = false,<br />
'''["notland"]''' = false,<br />
'''["fort"]''' = false,<br />
'''["special"]''' = false,<br />
'''["notair"]''' = false,<br />
'''["kbot"]''' = false,<br />
'''["antiemg"]''' = false,<br />
'''["commander"]''' = false,<br />
'''["jam"]''' = false,<br />
'''["tport"]''' = false,<br />
'''["constr"]''' = false,<br />
'''["strategic"]''' = false,<br />
'''["kamikaze"]''' = false,<br />
'''["minelayer"]''' = false,<br />
'''["hover"]''' = false,<br />
'''["noweapon"]''' = false,<br />
'''["plant"]''' = false,<br />
'''["ship"]''' = false,<br />
'''["antilaser"]''' = false,<br />
'''["phib"]''' = false,<br />
'''["mine"]''' = false,<br />
'''["notstructure"]''' = false,<br />
'''["tank"]''' = false,<br />
'''["mobile"]''' = false,<br />
'''["underwater"]''' = false,<br />
'''["antigator"]''' = false,<br />
'''["notship"]''' = false,<br />
'''["all"]''' = false,<br />
'''["notsub"]''' = false,<br />
'''["weapon"]''' = false,<br />
}<br />
'''["weaponDef"]''' = 39,<br />
'''["slavedTo"]''' = 0,<br />
'''["badTargets"]''' = {<br />
'''["antilaser"]''' = false,<br />
}<br />
'''["fuelUsage"]''' = 0,<br />
'''["mainDirX"]''' = 0,<br />
'''["mainDirY"]''' = 0,<br />
'''["mainDirZ"]''' = 1,<br />
'''["maxAngleDif"]''' = -1,<br />
}<br />
'''[2]''' = {<br />
'''["onlyTargets"]''' = {<br />
}<br />
'''["weaponDef"]''' = 195,<br />
'''["slavedTo"]''' = 0,<br />
'''["badTargets"]''' = {<br />
}<br />
'''["fuelUsage"]''' = 0,<br />
'''["maxAngleDif"]''' = -1,<br />
}<br />
'''[3]''' = {<br />
'''["onlyTargets"]''' = {<br />
'''["antiflame"]''' = false,<br />
'''["vtol"]''' = false,<br />
'''["notland"]''' = false,<br />
'''["fort"]''' = false,<br />
'''["special"]''' = false,<br />
'''["notair"]''' = false,<br />
'''["kbot"]''' = false,<br />
'''["antiemg"]''' = false,<br />
'''["commander"]''' = false,<br />
'''["jam"]''' = false,<br />
'''["tport"]''' = false,<br />
'''["constr"]''' = false,<br />
'''["strategic"]''' = false,<br />
'''["kamikaze"]''' = false,<br />
'''["minelayer"]''' = false,<br />
'''["hover"]''' = false,<br />
'''["noweapon"]''' = false,<br />
'''["plant"]''' = false,<br />
'''["ship"]''' = false,<br />
'''["antilaser"]''' = false,<br />
'''["phib"]''' = false,<br />
'''["mine"]''' = false,<br />
'''["notstructure"]''' = false,<br />
'''["tank"]''' = false,<br />
'''["mobile"]''' = false,<br />
'''["underwater"]''' = false,<br />
'''["antigator"]''' = false,<br />
'''["notship"]''' = false,<br />
'''["all"]''' = false,<br />
'''["notsub"]''' = false,<br />
'''["weapon"]''' = false,<br />
}<br />
'''["weaponDef"]''' = 13,<br />
'''["slavedTo"]''' = 0,<br />
'''["badTargets"]''' = {<br />
}<br />
'''["fuelUsage"]''' = 0,<br />
'''["maxAngleDif"]''' = -1,<br />
}<br />
}<br />
'''UnitDefs['''216''']["windGenerator"]''' = 0,<br />
'''UnitDefs['''216''']["wingAngle"]''' = 0.079999998211861,<br />
'''UnitDefs['''216''']["wingDrag"]''' = 0.070000000298023,<br />
'''UnitDefs['''216''']["wreckName"]''' = "CORCOM_DEAD",<br />
'''UnitDefs['''216''']["verticalSpeed"]''' = 4,<br />
'''UnitDefs['''216''']["xsize"]''' = 4,<br />
'''UnitDefs['''216''']["ysize"]''' = 4,</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG:Miscellaneous&diff=3908CEG:Miscellaneous2009-01-09T03:37:39Z<p>Evil4zerggin: </p>
<hr />
<div>== Blending ==<br />
<br />
CEGs use the blending mode GL_ONE, GL_ONE_MINUS_SRC_ALPHA. This is in contrast to the default GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA. As far as I can tell, this means that the alpha determines how much of whatever is behind the particle will show through, but doesn't affect how the particle itself looks. If you want default blending, you'll have to scale the color components by the alpha by hand if the class you're using doesn't do it for you. (Most classes don't) Note that an alpha of zero will cause the CEG not to be displayed at all. <br />
<br />
=== Z-Fighting ===<br />
<br />
A related problem is Z-fighting. If you have several high-alpha particles moving through each other, you may get an undesirable flickering effect as one particle is drawn at first, then the other. To solve this, reduce the alpha.<br />
<br />
== Things To Consider When Making a CEG ==<br />
<br />
=== Realism ===<br />
<br />
While it's important to make sure a CEG doesn't look completely implausible, don't get too hung up on realism. In almost any RTS, concessions are made for gameplay at the cost of a bit of realism; likewise with CEGs, you'll need to make some concessions for looking cool.<br />
<br />
=== Gameplay ===<br />
<br />
As well as looking cool, CEGs are an important part of gameplay. They let players know when things are happening and where they are happening. CEGs should give clues as to what is happening in the mechanics of the game. A powerful weapon should have a powerful-looking CEG; a blast that affects a large area should have a large CEG. Use the alwaysVisisble and useAirLos tags where appropriate. Hopefully we will eventually have a radius operator so CEGs can automatically be scaled to the radius of the weapon.<br />
<br />
At the same time, you don't want to obstruct players' views of the game. A CEG should look cool for a moment, and then get out of the way.<br />
<br />
=== Performance ===<br />
<br />
Bascially, try not to use more particles than necessary, and try not to use them longer than necessary. Be aware of how often you expect your CEG to run; if it's a commander death or a nuclear missile, you can afford to spend some extra particles, but if it's a machine gun or a cegtag (which is called every frame), you'll want to keep it down.<br />
<br />
=== Randomness ===<br />
<br />
Always put a little randomness in your CEGs. CEGs are more interesting if they happen a little differently every time, especially if your CEG gets called more than once at the same time on the same screen.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG-Classes&diff=3775CEG-Classes2009-01-09T03:34:55Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/<br />
<br />
https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/Unsynced/<br />
<br />
== Common Properties ==<br />
All classes have the following properties, although not all of them use them:<br />
<br />
*pos (float3): The initial position of the spawner.<br />
*useAirLos (bool): Whether the spawner uses air LoS to determine if it is visible. This may allow the spawner to be seen from a further distance than normal.<br />
*alwaysVisible (bool): If true, the spawner is always visible, ignoring LoS.<br />
*speed (float3): The initial speed of the spawner.<br />
<br />
== CExpGenSpawner ==<br />
This is the closest thing CEG has to a function call. Instead of creating a graphical effect on its own, it creates another CEG.<br />
<br />
Properties:<br />
<br />
*delay (int): How long to wait before spawning the CEG.<br />
*dir (float3): The CEG will be called with this direction.<br />
*damage (float): The CEG will be called with this damage. The CEG doesn't actually deal any damage, but you can use this as a parameter and read it using the 'd' operator.<br />
*explosionGenerator (string): The name of the CEG you want to spawn.<br />
<br />
Suggested Use: <br />
*If you use a spawner a lot of times, you may want to make it a separate CEG to avoid having to copy-paste many times.<br />
*This is the only way to truly delay a graphical effect.<br />
*The spawned CEG still checks conditions, so if you want to, say, spawn an effect only if it is in water ''and'' doesn't hit a unit, you can give the CExpGenSpawner <code>nounit = 1;</code> and the spawned <code>CEG water = 1;</code>.<br />
*This allows you to give a set of spawners the same (and possibly random) direction.<br />
*You can animate an explosion flip-book style using delays and several bitmaps.<br />
<br />
== CBitmapMuzzleFlame ==<br />
This creates three rectangular textures at right angles to each other. The <code>frontTexture</code> has <code>dir</code> as its normal.<br />
<br />
Properties: <br />
*sideTexture (string)<br />
*frontTexture (string)<br />
*dir (float3)<br />
*colorMap (string)<br />
*size (float): The initial width of the muzzle flame.<br />
*length (float): The initial length of the muzzle flame.<br />
*sizeGrowth (float): By the end of its life, the muzzle flame grows to 1 + sizeGrowth times its initial size and length. The flame grows quickly at first and more slowly toward the end.<br />
*ttl (int): How long the muzzle flame lasts.<br />
*frontOffset (float): Where the frontTexture is along the length of the muzzle flame. 0 means it is in the back, 1 is in the front.<br />
<br />
Suggested Use:<br />
*Muzzle flames, obviously.<br />
*You can use an upward-pointing CBitmapMuzzleFlame as a simple splash of water or dirt.<br />
*Railgun trails.<br />
*This is the only class that both obeys perspective and allows for a custom texture.<br />
<br />
== CExploSpikeProjectile ==<br />
<br />
This creates a glowy spike. Note that the spike is two sided, i.e., symmetric about the position of the spawner.<br />
<br />
*length (float): The initial length of (half) of the spike (multiplied by dir).<br />
*width (float): Half the initial width of of the spike. This is an absolute value.<br />
*alpha (float): The starting alpha of the spike.<br />
*alphaDecay (float): How quickly the alpha of the spike decreases.<br />
*lengthGrowth (float): How much the spike grows in length every frame. The spike does not grow in width.<br />
*dir (float3): The direction of the spike. Not normalized.<br />
*color (float3): The color of the spike.<br />
<br />
Suggested Use:<br />
*Anything glowy.<br />
*For large, slow missiles, you can try using this as an extended engine flame. Set the width to something fairly large.<br />
*Long and thin spikes will look spiky; meanwhile, shorter and wider spikes look more blobby.<br />
*The colors of spikes add together, so if you have several spikes and all three color channels are non-zero, it will be white in the center.<br />
<br />
== CHeatCloudProjectile ==<br />
<br />
Creates an expanding sprite. Simple but effective.<br />
<br />
*heat (float)<br />
*maxheat (float)<br />
*heatFalloff (float)<br />
This is really confusing way of representing alpha and alphaDecay. Basically alpha = heat/maxheat, and alphaDecay = heatFalloff/maxHeat.<br />
*size (float): The initial radius of the heatcloud.<br />
*sizeGrowth (float): The heatcloud grows by this amount every frame.<br />
*sizemod (float): The size of the heatcloud is multiplied by 1 - sizemod.<br />
*sizemodmod (float): Each frame, sizemod is multiplied by sizemodmod.<br />
*texture (string): The texture used for the heatcloud.<br />
<br />
Suggested Use:<br />
*As the main background to an explosion.<br />
<br />
== CSimpleParticleSystem ==<br />
<br />
Creates a sprite that can undergo complex motion. Probably the most versatile class. Since there are a lot of properties, I'll group them:<br />
<br />
=== Initial Velocity Properties ===<br />
*emitVector (float3): The basic direction in which the particle is emitted.<br />
*emitRot (float): At what angle to emit the particle relative to emitVector. 0 means that the particle will be emitted in emitVector's direction; 180 will emit the particle in the opposite direction. 90 will emit the particle in a random direction perpendicular to emitVector, which is good for creating rings.<br />
*emitRotSpread (float): For each particle, a random number between 0 and emitRotSpread is added to the emitRot.<br />
*emitMul (float3): Scales the initial particle velocity; for this property, +y is considered to be in the direction of emitVector. Good if you want to create an egg-shaped explosion.<br />
*particleSpeed (float): The particle's initial speed.<br />
*particleSpeedSpread (float): For each particle, a random number between 0 and particleSpeedSpread is added to the particleSpeed .<br />
<br />
=== Movement Properties ===<br />
*gravity (float3): This will be added to the particle's velocity every frame.<br />
*airdrag (float): The particle's velocity is multiplied by this every frame.<br />
<br />
=== Size Properties ===<br />
*particleSize (float): The initial size of the particle.<br />
*particleSizeSpread (float): For each particle, a random number between 0 and particleSizeSpread is added to the particleSize.<br />
*sizeGrowth (float): How much the particle grows each frame.<br />
*sizeMod (float): The size of the particle is multiplied by this each frame.<br />
<br />
=== Visual Properties ===<br />
*directional (bool): If true, the particle will point in the direction it is moving.<br />
*texture (string): The texture to use for the particle.<br />
*colorMap (string): The colormap to use for the particle.<br />
<br />
=== Life Properties ===<br />
*numParticles (int): How many particles to create. This is not the same as <code>count</code>; if you spawn multiple particles using <code>count</code>, any [[CEG_Operators]] will be reevaluated for each particle, whereas if you use <code>numParticles</code> they will not be. However, the spread properties are evaluated separately for each particle regardless of which one you use.<br />
*particleLife (float): How long each particle lasts. <br />
*particleLifeSpread (float); For each particle, a random number between 0 and particleLifeSpread is added to the particleLife .<br />
<br />
Suggested Use:<br />
*This is probably the most versatile class.<br />
*Anything moving that is not doing so at constant velocity.<br />
*If you want something that expands (or shrinks) to some size then stops, set sizeMod to something less than 1, and sizeGrowth to something positive. The particle will grow to a size equal to sizeGrowth/ (1 - sizeMod) and stop. The smaller sizeMod is, the faster it will reach this size.<br />
<br />
== CSpherePartSpawner ==<br />
<br />
Draws an expanding sphere.<br />
<br />
Properties:<br />
*alpha (float): The alpha of the sphere.<br />
*ttl (int): How long the sphere lasts.<br />
*expansionSpeed (float): How quickly the sphere expands.<br />
*color (float3): The color of the sphere.<br />
<br />
Suggested Use:<br />
*Looks like a shockwave.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG:Miscellaneous&diff=3907CEG:Miscellaneous2009-01-08T22:45:03Z<p>Evil4zerggin: </p>
<hr />
<div>== Blending ==<br />
<br />
CEGs use the blending mode GL_ONE, GL_ONE_MINUS_SRC_ALPHA. This is in contrast to the default GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA. As far as I can tell, this means that the alpha determines how much of whatever is behind the particle will show through, but doesn't affect how the particle itself looks. If you want default blending, you'll have to scale the color components by the alpha by hand if the class you're using doesn't do it for you. (Most classes do, but CSimpleParticleSystem doesn't.) Note that an alpha of zero will cause the CEG not to be displayed at all. <br />
<br />
=== Z-Fighting ===<br />
<br />
A related problem is Z-fighting. If you have several high-alpha particles moving through each other, you may get an undesirable flickering effect as one particle is drawn at first, then the other. To solve this, reduce the alpha.<br />
<br />
== Things To Consider When Making a CEG ==<br />
<br />
=== Realism ===<br />
<br />
While it's important to make sure a CEG doesn't look completely implausible, don't get too hung up on realism. In almost any RTS, concessions are made for gameplay at the cost of a bit of realism; likewise with CEGs, you'll need to make some concessions for looking cool.<br />
<br />
=== Gameplay ===<br />
<br />
As well as looking cool, CEGs are an important part of gameplay. They let players know when things are happening and where they are happening. CEGs should give clues as to what is happening in the mechanics of the game. A powerful weapon should have a powerful-looking CEG; a blast that affects a large area should have a large CEG. Use the alwaysVisisble and useAirLos tags where appropriate. Hopefully we will eventually have a radius operator so CEGs can automatically be scaled to the radius of the weapon.<br />
<br />
At the same time, you don't want to obstruct players' views of the game. A CEG should look cool for a moment, and then get out of the way.<br />
<br />
=== Performance ===<br />
<br />
Bascially, try not to use more particles than necessary, and try not to use them longer than necessary. Be aware of how often you expect your CEG to run; if it's a commander death or a nuclear missile, you can afford to spend some extra particles, but if it's a machine gun or a cegtag (which is called every frame), you'll want to keep it down.<br />
<br />
=== Randomness ===<br />
<br />
Always put a little randomness in your CEGs. CEGs are more interesting if they happen a little differently every time, especially if your CEG gets called more than once at the same time on the same screen.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG:Miscellaneous&diff=3906CEG:Miscellaneous2009-01-08T22:44:30Z<p>Evil4zerggin: </p>
<hr />
<div>== Blending ==<br />
<br />
CEGs use the blending mode GL_ONE, GL_ONE_MINUS_SRC_ALPHA. This is in contrast to the default GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA. As far as I can tell, this means that the alpha determines how much of whatever is behind the particle will show through, but doesn't affect how the particle itself looks. If you want default blending, you'll have to scale the color components by the alpha by hand if the class you're using doesn't do it for you. (Most classes do, but CSimpleParticleSystem does.) Note that an alpha of zero will cause the CEG not to be displayed at all. <br />
<br />
=== Z-Fighting ===<br />
<br />
A related problem is Z-fighting. If you have several high-alpha particles moving through each other, you may get an undesirable flickering effect as one particle is drawn at first, then the other. To solve this, reduce the alpha.<br />
<br />
== Things To Consider When Making a CEG ==<br />
<br />
=== Realism ===<br />
<br />
While it's important to make sure a CEG doesn't look completely implausible, don't get too hung up on realism. In almost any RTS, concessions are made for gameplay at the cost of a bit of realism; likewise with CEGs, you'll need to make some concessions for looking cool.<br />
<br />
=== Gameplay ===<br />
<br />
As well as looking cool, CEGs are an important part of gameplay. They let players know when things are happening and where they are happening. CEGs should give clues as to what is happening in the mechanics of the game. A powerful weapon should have a powerful-looking CEG; a blast that affects a large area should have a large CEG. Use the alwaysVisisble and useAirLos tags where appropriate. Hopefully we will eventually have a radius operator so CEGs can automatically be scaled to the radius of the weapon.<br />
<br />
At the same time, you don't want to obstruct players' views of the game. A CEG should look cool for a moment, and then get out of the way.<br />
<br />
=== Performance ===<br />
<br />
Bascially, try not to use more particles than necessary, and try not to use them longer than necessary. Be aware of how often you expect your CEG to run; if it's a commander death or a nuclear missile, you can afford to spend some extra particles, but if it's a machine gun or a cegtag (which is called every frame), you'll want to keep it down.<br />
<br />
=== Randomness ===<br />
<br />
Always put a little randomness in your CEGs. CEGs are more interesting if they happen a little differently every time, especially if your CEG gets called more than once at the same time on the same screen.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG:Miscellaneous&diff=3905CEG:Miscellaneous2009-01-08T04:40:49Z<p>Evil4zerggin: New page: == Blending == CEGs use the blending mode GL_ONE, GL_ONE_MINUS_SRC_ALPHA. This is in contrast to the default GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA. As far as I can tell, this means that th...</p>
<hr />
<div>== Blending ==<br />
<br />
CEGs use the blending mode GL_ONE, GL_ONE_MINUS_SRC_ALPHA. This is in contrast to the default GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA. As far as I can tell, this means that the alpha determines how much of whatever is behind the particle will show through, but doesn't affect how the particle itself looks. If you want default blending, you'll have to scale the color components by the alpha by hand. Will test more later.<br />
<br />
=== Z-Fighting ===<br />
<br />
A related problem is Z-fighting. If you have several high-alpha particles moving through each other, you may get an undesirable flickering effect as one particle is drawn at first, then the other. To solve this, reduce the alpha.<br />
<br />
== Things To Consider When Making a CEG ==<br />
<br />
=== Realism ===<br />
<br />
While it's important to make sure a CEG doesn't look completely implausible, don't get too hung up on realism. In almost any RTS, concessions are made for gameplay at the cost of a bit of realism; likewise with CEGs, you'll need to make some concessions for looking cool.<br />
<br />
=== Gameplay ===<br />
<br />
As well as looking cool, CEGs are an important part of gameplay. They let players know when things are happening and where they are happening. CEGs should give clues as to what is happening in the mechanics of the game. A powerful weapon should have a powerful-looking CEG; a blast that affects a large area should have a large CEG. Use the alwaysVisisble and useAirLos tags where appropriate. Hopefully we will eventually have a radius operator so CEGs can automatically be scaled to the radius of the weapon.<br />
<br />
At the same time, you don't want to obstruct players' views of the game. A CEG should look cool for a moment, and then get out of the way.<br />
<br />
=== Performance ===<br />
<br />
Bascially, try not to use more particles than necessary, and try not to use them longer than necessary. Be aware of how often you expect your CEG to run; if it's a commander death or a nuclear missile, you can afford to spend some extra particles, but if it's a machine gun or a cegtag (which is called every frame), you'll want to keep it down.<br />
<br />
=== Randomness ===<br />
<br />
Always put a little randomness in your CEGs. CEGs are more interesting if they happen a little differently every time, especially if your CEG gets called more than once at the same time on the same screen.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=Game_and_Unit_development&diff=7963Game and Unit development2009-01-08T04:18:55Z<p>Evil4zerggin: </p>
<hr />
<div>=Mod development=<br />
Mods, next to Maps, is the content used in Spring.<br><br />
A mod is simply a combined file containing a small structure of files and directories holding all the data required.<br><br />
<br />
[[Mod_Development | Mod Development]] wiki is a starting page, linking to very useful information on the files included in a mod, their hierarchy and more.<br />
<br><br />
<br />
Almost the entire mod developing is the creation of units. Which isn't an easy job.<br><br />
Information about the creation of units are everywere, but not combined.<br><br />
This is a gathered list of all Tutorials and helpfull forums threads I could find:<br><br />
<br />
==General==<br />
*[[Mod Development]]<br />
*[[Mod specification]]<br><br />
*[http://spring.clan-sy.com/phpbb/viewtopic.php?t=6015 What do I need to create a mod]<br />
*[[Simple Mod Tutorial]]<br />
*[[Freely available and reusable content|Freely available and reusable content/games/mods]]<br />
<br />
==Unit Development==<br />
====Automated Mod Creation====<br />
* [[TA2Spring]] - Automatically adds and converts Total Annihilation unit packs (.ufo files, etc..) into Spring mods (requires a base modification for the game rules, XTA is recommended)<br />
====Models - s3o Files====<br />
*[http://user.supradigital.org/jcnossen/UpspringInstaller-1.54-EulerAngles.exe UpSpring, our second-gen import / export / rigging / animation tool.]<br />
* [http://lassie.student.utwente.nl/vliet/springtut.pdf Maestro's tutorial of Upspring and textures].<br />
* [[Basic s3o unit making guide]]<br />
* [[Simple Mod Tutorial]]<br />
* [[Units:CreateModel|UV Mapping in Wings3D]]<br />
* [http://spring.clan-sy.com/phpbb/viewtopic.php?t=10612 Wings UV Mapping Tutorial]<br />
* [http://spring.clan-sy.com/phpbb/viewtopic.php?f=9&t=12354 Saving polygons in Wings3d Tutorial]<br />
* [http://spring.clan-sy.com/phpbb/viewtopic.php?t=10947 Greeble Tutorial 1]<br />
* [http://spring.clan-sy.com/phpbb/viewtopic.php?f=9&t=12356 Greeble Tutorial 2]<br />
* [http://spring.clan-sy.com/phpbb/viewtopic.php?p=75495 various things about unit making. (Also contains an illustrated alpha-channel tut)]<br />
* [http://spring.clan-sy.com/phpbb/viewtopic.php?t=10503 Runecrafter's 3DS Max UV Mapping Tutorial]<br />
* [http://spring.clan-sy.com/phpbb/viewtopic.php?f=9&t=15106 Argh's UpSpring Easy Workflow Guide]<br />
* [[Trouble-shooting s3o units]]<br />
<br />
====Models - 3do Files====<br />
outdated model format used by OTA<br><br />
(Note: UpSpring has some problems with empty objects and groundplates)<br />
*use [http://spring.clan-sy.com/phpbb/viewtopic.php?f=12&t=7208&p=126129&hilit=upspring#p126129 UpSpring] and [http://www.fileuniverse.com/?p=show&a=it&id=305 3doBuilder] to edit those files<br />
<br />
====Scripting and Animation - COB/BOS Files====<br />
To edit those you need a program/compiler. The most famous one is Scriptor.<br />
*[[Units0:.bos ]] some examples<br />
*[[COB_Overview]]<br />
*[[COB_Animation]]<br />
*[[COB_Callins]]<br />
*[[COB_Constants]]<br />
*[[COB_Threads]]<br />
*[[COB_HitByWeaponID]]<br />
*[http://www.planetannihilation.com/tadc/tut_unit_01_1.asp PlanetAnnihilation] has a nice tutorial<br />
*[[Units:LuaCOB]] - how to interface COB with LUA<br />
*[[CEG_For_Units|Mod Development:Calling basic CEGs from COB]]<br />
* [http://spring.clan-sy.com/phpbb/viewtopic.php?p=132943#132943 GPL-compliant sourcecode, scripting code examples, and other things.]<br />
<br />
====Units - FBI Files====<br />
*[[Units:FBI]]<br />
*[[All_FBI-variable_values:_min,_max,_default,_type|Units:FBI (variable datatype list)]]<br />
*[[Unit_Categories]]<br />
<br />
====Weapons - TDF Files====<br />
*[[Weapon Variables]] : This is the most up to date<br />
*[[Units:WeaponMainDir]]<br />
*[[Units:Weapons]] : Various informations about the weapontypes (uncompleted)<br />
*[[All_Weapons_variable_values:_min%2C_max%2C_default%2C_type|Weapon datatype list]] : All weapon variables min/max/default values and datatypes listed.<br />
*[[Weapons:Antinukes]]: All about antinukes.<br />
<br />
====Explosions====<br />
*[[CEG_Overview]]<br />
*[[CEG_Calls]]<br />
*[[CEG_Format]]<br />
*[[CEG_Classes]]<br />
*[[CEG_Operators]]<br />
*[[CEG_Miscellaneous]]<br />
*[[CustomExplosionGenerators|Old CEG page]]<br />
<br />
====Misc====<br />
*[[Units:Design]]<br />
*[[Units:Textures]]<br />
*[[Units:Buildpics]]<br />
*[[Units:SideData TDF]]<br />
*[[Units:Download TDF]] <br />
*[[Units:FlankingBonus]]<br />
*[[Mod Development:Armor]]<br />
*[[Mod Development:Cursors]]<br />
*[[Mod Development:Archives]]<br />
*[[Mod Development:Sidepics]]<br />
*[[CustomUnitIcons|Mod Development:Custom unit icons]]</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG-Classes&diff=3774CEG-Classes2009-01-08T04:18:19Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/<br />
<br />
https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/Unsynced/<br />
<br />
== Common Properties ==<br />
All classes have the following properties, although not all of them use them:<br />
<br />
*pos (float3): The initial position of the spawner.<br />
*useAirLos (bool): Whether the spawner uses air LoS to determine if it is visible. This may allow the spawner to be seen from a further distance than normal.<br />
*alwaysVisible (bool): If true, the spawner is always visible, ignoring LoS.<br />
*speed (float3): The initial speed of the spawner.<br />
<br />
== CExpGenSpawner ==<br />
This is the closest thing CEG has to a function call. Instead of creating a graphical effect on its own, it creates another CEG.<br />
<br />
Properties:<br />
<br />
*delay (int): How long to wait before spawning the CEG.<br />
*dir (float3): The CEG will be called with this direction.<br />
*damage (float): The CEG will be called with this damage. The CEG doesn't actually deal any damage, but you can use this as a parameter and read it using the 'd' operator.<br />
*explosionGenerator (string): The name of the CEG you want to spawn.<br />
<br />
Suggested Use: <br />
*If you use a spawner a lot of times, you may want to make it a separate CEG to avoid having to copy-paste many times.<br />
*This is the only way to truly delay a graphical effect.<br />
*The spawned CEG still checks conditions, so if you want to, say, spawn an effect only if it is in water ''and'' doesn't hit a unit, you can give the CExpGenSpawner <code>nounit = 1;</code> and the spawned <code>CEG water = 1;</code>.<br />
*This allows you to give a set of spawners the same (and possibly random) direction.<br />
*You can animate an explosion flip-book style using delays and several bitmaps.<br />
<br />
== CBitmapMuzzleFlame ==<br />
This creates three rectangular textures at right angles to each other. The <code>frontTexture</code> has <code>dir</code> as its normal.<br />
<br />
Properties: <br />
*sideTexture (string)<br />
*frontTexture (string)<br />
*dir (float3)<br />
*colorMap (string)<br />
*size (float): The initial width of the muzzle flame.<br />
*length (float): The initial length of the muzzle flame.<br />
*sizeGrowth (float): By the end of its life, the muzzle flame grows to 1 + sizeGrowth times its initial size and length. The flame grows quickly at first and more slowly toward the end.<br />
*ttl (int): How long the muzzle flame lasts.<br />
*frontOffset (float): Where the frontTexture is along the length of the muzzle flame. 0 means it is in the back, 1 is in the front.<br />
<br />
Suggested Use:<br />
*Muzzle flames, obviously.<br />
*You can use an upward-pointing CBitmapMuzzleFlame as a simple splash of water or dirt.<br />
*Railgun trails.<br />
*This is the only class that both obeys perspective and allows for a custom texture. All other classes except CExploSpikeProjectile always face directly toward the viewer.<br />
<br />
== CExploSpikeProjectile ==<br />
<br />
This creates a glowy spike. Note that the spike is two sided, i.e., symmetric about the position of the spawner.<br />
<br />
*length (float): The initial length of (half) of the spike.<br />
*width (float): Half the initial width of of the spike.<br />
*alpha (float): The starting alpha of the spike.<br />
*alphaDecay (float): How quickly the alpha of the spike decreases.<br />
*lengthGrowth (float): How much the spike grows in length every frame. The spike does not grow in width.<br />
*dir (float3): The direction of the spike.<br />
*color (float3): The color of the spike.<br />
<br />
Suggested Use:<br />
*Anything glowy.<br />
*For large, slow missiles, you can try using this as an extended engine flame. Set the width to something fairly large.<br />
*Long and thin spikes will look spiky; meanwhile, shorter and wider spikes look more blobby.<br />
*The colors of spikes add together, so if you have several spikes and all three color channels are non-zero, it will be white in the center.<br />
<br />
== CHeatCloudProjectile ==<br />
<br />
Creates an expanding sprite. Simple but effective.<br />
<br />
*heat (float)<br />
*maxheat (float)<br />
*heatFalloff (float)<br />
This is really confusing way of representing alpha and alphaDecay. Basically alpha = heat/maxheat, and alphaDecay = heatFalloff/maxHeat.<br />
*size (float): The initial radius of the heatcloud.<br />
*sizeGrowth (float): The heatcloud grows by this amount every frame.<br />
*sizemod (float): The size of the heatcloud is multiplied by 1 - sizemod.<br />
*sizemodmod (float): Each frame, sizemod is multiplied by sizemodmod.<br />
*texture (string): The texture used for the heatcloud.<br />
<br />
Suggested Use:<br />
*As the main background to an explosion.<br />
<br />
== CSimpleParticleSystem ==<br />
<br />
Creates a sprite that can undergo complex motion. Probably the most versatile class. Since there are a lot of properties, I'll group them:<br />
<br />
=== Initial Velocity Properties ===<br />
*emitVector (float3): The basic direction in which the particle is emitted.<br />
*emitRot (float): At what angle to emit the particle relative to emitVector. 0 means that the particle will be emitted in emitVector's direction; 180 will emit the particle in the opposite direction. 90 will emit the particle in a random direction perpendicular to emitVector, which is good for creating rings.<br />
*emitRotSpread (float): For each particle, a random number between 0 and emitRotSpread is added to the emitRot.<br />
*emitMul (float3): Scales the initial particle velocity; for this property, +y is considered to be in the direction of emitVector. Good if you want to create an egg-shaped explosion.<br />
*particleSpeed (float): The particle's initial speed.<br />
*particleSpeedSpread (float): For each particle, a random number between 0 and particleSpeedSpread is added to the particleSpeed .<br />
<br />
=== Movement Properties ===<br />
*gravity (float3): This will be added to the particle's velocity every frame.<br />
*airdrag (float): The particle's velocity is multiplied by this every frame.<br />
<br />
=== Size Properties ===<br />
*particleSize (float): The initial size of the particle.<br />
*particleSizeSpread (float): For each particle, a random number between 0 and particleSizeSpread is added to the particleSize.<br />
*sizeGrowth (float): How much the particle grows each frame.<br />
*sizeMod (float): The size of the particle is multiplied by this each frame.<br />
<br />
=== Visual Properties ===<br />
*directional (bool): If true, the particle will point in the direction it is moving.<br />
*texture (string): The texture to use for the particle.<br />
*colorMap (string): The colormap to use for the particle.<br />
<br />
=== Life Properties ===<br />
*numParticles (int): How many particles to create. This is not the same as <code>count</code>; if you spawn multiple particles using <code>count</code>, any [[CEG_Operators]] will be reevaluated for each particle, whereas if you use <code>numParticles</code> they will not be. However, the spread properties are evaluated separately for each particle regardless of which one you use.<br />
*particleLife (float): How long each particle lasts. <br />
*particleLifeSpread (float); For each particle, a random number between 0 and particleLifeSpread is added to the particleLife .<br />
<br />
Suggested Use:<br />
*This is probably the most versatile class.<br />
*Anything moving that is not doing so at constant velocity.<br />
*If you want something that expands (or shrinks) to some size then stops, set sizeMod to something less than 1, and sizeGrowth to something positive. The particle will grow to a size equal to sizeGrowth/ (1 - sizeMod) and stop. The smaller sizeMod is, the faster it will reach this size.<br />
<br />
== CSpherePartSpawner ==<br />
<br />
Draws an expanding sphere.<br />
<br />
Properties:<br />
*alpha (float): The alpha of the sphere.<br />
*ttl (int): How long the sphere lasts.<br />
*expansionSpeed (float): How quickly the sphere expands.<br />
*color (float3): The color of the sphere.<br />
<br />
Suggested Use:<br />
*Looks like a shockwave.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG:Calls&diff=3849CEG:Calls2009-01-02T20:17:29Z<p>Evil4zerggin: </p>
<hr />
<div>== Overview ==<br />
There are three places where you can call a CEG: weapons, COB, and Lua.<br />
<br />
== Weapon CEGs ==<br />
<br />
There are three weapon tags that can spawn CEGs:<br />
<br />
*cegtag: Spawns the CEG every frame at the weapon projectile's position and direction.<br />
*explosionGenerator: Spawns the CEG when the weapon hits its target.<br />
*bounceExplosionGenerator: For bouncing weapons only. Spawns the CEG when the weapon bounces.<br />
<br />
You need to set these tags equal to custom:ExplosionGeneratorName. For example, in a .tdf,<br />
<code>explosionGenerator=custom:ExplosionGeneratorName;</code><br />
<br />
== COB CEGs ==<br />
<br />
Calling a CEG from COB requires two steps. First, in the unit's definition, you need to put<br />
<br />
<code><br />
[sfxtypes] {<br />
explosiongenerator0 = custom:ExplosionGeneratorName0;<br />
explosiongenerator1 = custom:ExplosionGeneratorName1;<br />
//and so on...<br />
}<br />
</code><br />
<br />
for a .fbi, or<br />
<br />
<code><br />
sfxtypes = {<br />
explosiongenerators = {<br />
"custom:ExplosionGeneratorName0",<br />
"custom:ExplosionGeneratorName1",<br />
--and so on...<br />
},<br />
},<br />
</code><br />
<br />
To actually generate the explosion, you need to <code>emit-sfx</code> 1024 plus the number of the explosion generator in the unit definition (the first one is 0, the next is 1, and so on). The CEG will have the position and direction of the piece you emit it from.<br />
<br />
There is another tag, <code>pieceTrailCEGTag</code>, which is used in <code>explode [piece] FALL;</code>, but I'm not sure what this does.<br />
<br />
'''CEG_DAMAGE:''' In a COB script, you can do <code>SET CEG_DAMAGE [value]</code>. Any <code>emit-sfx</code> instructions will then use that value for the "damage" (use the 'd' operator to access this value).<br />
<br />
== Lua CEGs ==<br />
See [[Lua_SyncedCtrl]].</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG:Operators&diff=3923CEG:Operators2009-01-02T01:11:20Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/ExplosionGenerator.cpp<br />
<br />
== Introduction ==<br />
You are not limited to using fixed numbers in CEGs for positions, speeds, and so forth. Instead, you can use operators to change the CEG based on a variety of things.<br />
<br />
== Syntax ==<br />
Operators are read left to right. The operand is always to the right of the operator. Spaces are ignored, except to separate numbers. A number with no operator defaults to addition.<br />
<br />
== The Buffer ==<br />
CEG provides you with a buffer in which you can store numbers using the yank ('y') operator. This buffer can store 16 values, numbered 0 to 15.<br />
<br />
== Operators ==<br />
These are listed in the format "Operator Name (operator)".<br />
<br />
=== Index ('i') ===<br />
Multiplies the operand by the current count index. This index starts at 0 and increments every time the spawn is run, until the spawn has run a number of times equal to its count.<br />
<br />
Suggested use: Spawning things in a line.<br />
<br />
=== Rand ('r') ===<br />
Multiplies the operand by a random float between 0 and 1.<br />
<br />
Suggested use: Keeping explosions from looking too "perfect", making explosions look different every time.<br />
<br />
=== Damage ('d') ===<br />
Multiplies the operand by damage.<br />
<br />
'''CEG_DAMAGE:''' In a COB script, you can do <code>SET CEG_DAMAGE [value]</code>. Any <code>emit-sfx</code> instructions will then use that value for the "damage" (use the 'd' operator to access this value).<br />
<br />
=== Sawtooth ('m') ===<br />
Calculates the floating-point remainder of the operand.<br />
<br />
=== Discrete ('k') ===<br />
Calculates the floor of the operand.<br />
<br />
=== Sine ('s') ===<br />
Calculates the sine of the operand.<br />
<br />
=== Yank ('y') ===<br />
Saves the running result into buffer[operand], and resets the running result to zero.<br />
<br />
=== Multiply ('x') ===<br />
Multiplies the running result by buffer[operand].<br />
<br />
=== Add Buffer ('a') ===<br />
Adds buffer[operand] to the running result.<br />
<br />
=== Power ('p') ===<br />
Raises the running result to the operandth power<br />
<br />
=== Power Buffer ('q') ===<br />
Raises the running result to the buffer[operand]th power.<br />
<br />
=== Add (default) ===<br />
Adds the operand to the running result. This operator is used if no other operator is given.<br />
<br />
== Example ==<br />
<pre><br />
i0.03125y0 -0.2x0x0<br />
</pre><br />
<br />
This multiplies the index by 0.03125 and saves it to buffer[0]. It then multiplies -0.2 by buffer[0] twice. The result is then -0.2 (i * 0.03125)^2. This type of thing is useful for making a series of particles follow a curved path.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG:Calls&diff=3848CEG:Calls2009-01-02T01:11:15Z<p>Evil4zerggin: </p>
<hr />
<div>== Overview ==<br />
There are three places where you can call a CEG: weapons, COB, and Lua.<br />
<br />
== Weapon CEGs ==<br />
<br />
There are three weapon tags that can spawn CEGs:<br />
<br />
*cegtag: Spawns the CEG every frame at the weapon projectile's position and direction.<br />
*explosionGenerator: Spawns the CEG when the weapon hits its target.<br />
*bounceExplosionGenerator: For bouncing weapons only. Spawns the CEG when the weapon bounces.<br />
<br />
You need to set these tags equal to custom:ExplosionGeneratorName. For example, in a .tdf,<br />
<code>explosionGenerator=custom:ExplosionGeneratorName;</code><br />
<br />
== COB CEGs ==<br />
<br />
Calling a CEG from COB requires two steps. First, in the unit's definition, you need to put<br />
<br />
<code><br />
[sfxtypes] {<br />
explosiongenerator0 = custom:ExplosionGeneratorName0;<br />
explosiongenerator1 = custom:ExplosionGeneratorName1;<br />
//and so on...<br />
}<br />
</code><br />
<br />
for a .fbi, or<br />
<br />
<code><br />
sfxtypes = {<br />
explosiongenerators = {<br />
"custom:ExplosionGeneratorName0",<br />
"custom:ExplosionGeneratorName1",<br />
--and so on...<br />
},<br />
},<br />
</code><br />
<br />
To actually generate the explosion, you need to <code>emit-sfx</code> 1024 plus the number of the explosion generator in the unit definition (the first one is 0, the next is 1, and so on). The CEG will have the position and direction of the piece you emit it from.<br />
<br />
'''CEG_DAMAGE:''' In a COB script, you can do <code>SET CEG_DAMAGE [value]</code>. Any <code>emit-sfx</code> instructions will then use that value for the "damage" (use the 'd' operator to access this value).<br />
<br />
== Lua CEGs ==<br />
See [[Lua_SyncedCtrl]].</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG:Calls&diff=3847CEG:Calls2009-01-02T01:10:53Z<p>Evil4zerggin: </p>
<hr />
<div>== Overview ==<br />
There are three places where you can call a CEG: weapons, COB, and Lua.<br />
<br />
== Weapon CEGs ==<br />
<br />
There are three weapon tags that can spawn CEGs:<br />
<br />
*cegtag: Spawns the CEG every frame at the weapon projectile's position and direction.<br />
*explosionGenerator: Spawns the CEG when the weapon hits its target.<br />
*bounceExplosionGenerator: For bouncing weapons only. Spawns the CEG when the weapon bounces.<br />
<br />
You need to set these tags equal to custom:ExplosionGeneratorName. For example, in a .tdf,<br />
<code>explosionGenerator=custom:ExplosionGeneratorName;</code><br />
<br />
== COB CEGs ==<br />
<br />
Calling a CEG from COB requires two steps. First, in the unit's definition, you need to put<br />
<br />
<code><br />
[sfxtypes] {<br />
explosiongenerator0 = custom:ExplosionGeneratorName0;<br />
explosiongenerator1 = custom:ExplosionGeneratorName1;<br />
//and so on...<br />
}<br />
</code><br />
<br />
for a .fbi, or<br />
<br />
<code><br />
sfxtypes = {<br />
explosiongenerators = {<br />
"custom:ExplosionGeneratorName0",<br />
"custom:ExplosionGeneratorName1",<br />
--and so on...<br />
},<br />
},<br />
</code><br />
<br />
To actually generate the explosion, you need to <code>emit-sfx</code> 1024 plus the number of the explosion generator in the unit definition (the first one is 0, the next is 1, and so on). The CEG will have the position and direction of the piece you emit it from.<br />
<br />
'''CEG_DAMAGE:''' In a COB script, you can do <code>SET CEG_DAMAGE [value]</code>. Any <code>emit-sfx</code> instructions will then use that value for the "damage".<br />
<br />
== Lua CEGs ==<br />
See [[Lua_SyncedCtrl]].</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG:Operators&diff=3922CEG:Operators2009-01-02T01:10:20Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/ExplosionGenerator.cpp<br />
<br />
== Introduction ==<br />
You are not limited to using fixed numbers in CEGs for positions, speeds, and so forth. Instead, you can use operators to change the CEG based on a variety of things.<br />
<br />
== Syntax ==<br />
Operators are read left to right. The operand is always to the right of the operator. Spaces are ignored, except to separate numbers. A number with no operator defaults to addition.<br />
<br />
== The Buffer ==<br />
CEG provides you with a buffer in which you can store numbers using the yank ('y') operator. This buffer can store 16 values, numbered 0 to 15.<br />
<br />
== Operators ==<br />
These are listed in the format "Operator Name (operator)".<br />
<br />
=== Index ('i') ===<br />
Multiplies the operand by the current count index. This index starts at 0 and increments every time the spawn is run, until the spawn has run a number of times equal to its count.<br />
<br />
Suggested use: Spawning things in a line.<br />
<br />
=== Rand ('r') ===<br />
Multiplies the operand by a random float between 0 and 1.<br />
<br />
Suggested use: Keeping explosions from looking too "perfect", making explosions look different every time.<br />
<br />
=== Damage ('d') ===<br />
Multiplies the operand by damage.<br />
<br />
'''Special Note:''' In a COB script, you can do <code>SET CEG_DAMAGE [value]</code>. Any <code>emit-sfx</code> instructions will then use that value for the "damage".<br />
<br />
=== Sawtooth ('m') ===<br />
Calculates the floating-point remainder of the operand.<br />
<br />
=== Discrete ('k') ===<br />
Calculates the floor of the operand.<br />
<br />
=== Sine ('s') ===<br />
Calculates the sine of the operand.<br />
<br />
=== Yank ('y') ===<br />
Saves the running result into buffer[operand], and resets the running result to zero.<br />
<br />
=== Multiply ('x') ===<br />
Multiplies the running result by buffer[operand].<br />
<br />
=== Add Buffer ('a') ===<br />
Adds buffer[operand] to the running result.<br />
<br />
=== Power ('p') ===<br />
Raises the running result to the operandth power<br />
<br />
=== Power Buffer ('q') ===<br />
Raises the running result to the buffer[operand]th power.<br />
<br />
=== Add (default) ===<br />
Adds the operand to the running result. This operator is used if no other operator is given.<br />
<br />
== Example ==<br />
<pre><br />
i0.03125y0 -0.2x0x0<br />
</pre><br />
<br />
This multiplies the index by 0.03125 and saves it to buffer[0]. It then multiplies -0.2 by buffer[0] twice. The result is then -0.2 (i * 0.03125)^2. This type of thing is useful for making a series of particles follow a curved path.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG-Classes&diff=3773CEG-Classes2008-12-31T23:44:01Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/<br />
<br />
https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/Unsynced/<br />
<br />
== Common Properties ==<br />
All classes have the following properties, although not all of them use them:<br />
<br />
*pos (float3): The initial position of the spawner.<br />
*useAirLos (bool): Whether the spawner uses air LoS to determine if it is visible. This may allow the spawner to be seen from a further distance than normal.<br />
*alwaysVisible (bool): If true, the spawner is always visible, ignoring LoS.<br />
*speed (float3): The initial speed of the spawner.<br />
<br />
== CExpGenSpawner ==<br />
This is the closest thing CEG has to a function call. Instead of creating a graphical effect on its own, it creates another CEG.<br />
<br />
Properties:<br />
<br />
*delay (int): How long to wait before spawning the CEG.<br />
*dir (float3): The CEG will be called with this direction.<br />
*damage (float): The CEG will be called with this damage. The CEG doesn't actually deal any damage, but you can use this as a parameter and read it using the 'd' operator.<br />
*explosionGenerator (string): The name of the CEG you want to spawn.<br />
<br />
Suggested Use: <br />
*If you use a spawner a lot of times, you may want to make it a separate CEG to avoid having to copy-paste many times.<br />
*This is the only way to truly delay a graphical effect.<br />
*The spawned CEG still checks conditions, so if you want to, say, spawn an effect only if it is in water ''and'' doesn't hit a unit, you can give the CExpGenSpawner <code>nounit = 1;</code> and the spawned <code>CEG water = 1;</code>.<br />
*This allows you to give a set of spawners the same (and possibly random) direction.<br />
*You can animate an explosion flip-book style using delays and several bitmaps.<br />
<br />
== CBitmapMuzzleFlame ==<br />
This creates three rectangular textures at right angles to each other. The <code>frontTexture</code> has <code>dir</code> as its normal.<br />
<br />
Properties: <br />
*sideTexture (string)<br />
*frontTexture (string)<br />
*dir (float3)<br />
*colorMap (string)<br />
*size (float): The initial width of the muzzle flame.<br />
*length (float): The initial length of the muzzle flame.<br />
*sizeGrowth (float): By the end of its life, the muzzle flame grows to 1 + sizeGrowth times its initial size and length. The flame grows quickly at first and more slowly toward the end.<br />
*ttl (int): How long the muzzle flame lasts.<br />
*frontOffset (float): Where the frontTexture is along the length of the muzzle flame. 0 means it is in the back, 1 is in the front.<br />
<br />
Suggested Use:<br />
*Muzzle flames, obviously.<br />
*You can use an upward-pointing CBitmapMuzzleFlame as a simple splash of water or dirt.<br />
*Railgun trails.<br />
*This is the only class that both obeys perspective and allows for a custom texture. All other classes except CExploSpikeProjectile always face directly toward the viewer.<br />
<br />
== CExploSpikeProjectile ==<br />
<br />
This creates a glowy spike. Note that the spike is two sided, i.e., symmetric about the position of the spawner.<br />
<br />
*length (float): The initial length of (half) of the spike.<br />
*width (float): Half the initial width of of the spike.<br />
*alpha (float): The starting alpha of the spike.<br />
*alphaDecay (float): How quickly the alpha of the spike decreases.<br />
*lengthGrowth (float): How much the spike grows in length every frame. The spike does not grow in width.<br />
*dir (float3): The direction of the spike.<br />
*color (float3): The color of the spike.<br />
<br />
Suggested Use:<br />
*Anything glowy.<br />
*For large, slow missiles, you can try using this as an extended engine flame. Set the width to something fairly large.<br />
*Long and thin spikes will look spiky; meanwhile, shorter and wider spikes look more blobby.<br />
*The colors of spikes add together, so if you have several spikes and all three color channels are non-zero, it will be white in the center.<br />
<br />
== CHeatCloudProjectile ==<br />
<br />
Creates an expanding sprite. Simple but effective.<br />
<br />
*heat (float)<br />
*maxheat (float)<br />
*heatFalloff (float)<br />
This is really confusing way of representing alpha and alphaDecay. Basically alpha = heat/maxheat, and alphaDecay = heatFalloff/maxHeat.<br />
*size (float): The initial radius of the heatcloud.<br />
*sizeGrowth (float): The heatcloud grows by this amount every frame.<br />
*sizemod (float): The size of the heatcloud is multiplied by 1 - sizemod.<br />
*sizemodmod (float): Each frame, sizemod is multiplied by sizemodmod.<br />
*texture (string): The texture used for the heatcloud.<br />
<br />
Suggested Use:<br />
*As the main background to an explosion.<br />
<br />
== CSimpleParticleSystem ==<br />
<br />
Creates a sprite that can undergo complex motion. Probably the most versatile class. Since there are a lot of properties, I'll group them:<br />
<br />
=== Initial Velocity Properties ===<br />
*emitVector (float3): The basic direction in which the particle is emitted.<br />
*emitRot (float): At what angle to emit the particle relative to emitVector. 0 means that the particle will be emitted in emitVector's direction; 180 will emit the particle in the opposite direction. 90 will emit the particle in a random direction perpendicular to emitVector, which is good for creating rings.<br />
*emitRotSpread (float): For each particle, a random number between 0 and emitRotSpread is added to the emitRot.<br />
*emitMul (float3): Scales the initial particle velocity; for this property, +y is considered to be in the direction of emitVector. Good if you want to create an egg-shaped explosion.<br />
*particleSpeed (float): The particle's initial speed.<br />
*particleSpeedSpread (float): For each particle, a random number between 0 and particleSpeedSpread is added to the particleSpeed .<br />
<br />
=== Movement Properties ===<br />
*gravity (float3): This will be added to the particle's velocity every frame.<br />
*airdrag (float): The particle's velocity is multiplied by this every frame.<br />
<br />
=== Size Properties ===<br />
*particleSize (float): The initial size of the particle.<br />
*particleSizeSpread (float): For each particle, a random number between 0 and particleSizeSpread is added to the particleSize.<br />
*sizeGrowth (float): How much the particle grows each frame.<br />
*sizeMod (float): The size of the particle is multiplied by this each frame.<br />
<br />
=== Visual Properties ===<br />
*directional (bool): If true, the particle will point in the direction it is moving.<br />
*texture (string): The texture to use for the particle.<br />
*colorMap (string): The colormap to use for the particle.<br />
<br />
=== Life Properties ===<br />
*numParticles (int): How many particles to create. This is not the same as <code>count</code>; if you spawn multiple particles using <code>count</code>, any [[CEG_Operators]] will be reevaluated for each particle, whereas if you use <code>numParticles</code> they will not be. However, the spread properties are evaluated separately for each particle regardless of which one you use.<br />
*particleLife (float): How long each particle lasts. <br />
*particleLifeSpread (float); For each particle, a random number between 0 and particleLifeSpread is added to the particleLife .<br />
<br />
=== Miscellaneous ===<br />
So far as I can tell, CEGs use the blending mode GL_ONE, GL_ONE_MINUS_SRC_ALPHA. This means that you can make a particle's color more intense or give it "washout" by setting its color channels greater than its alpha. Conversely, if you don't want washout, make sure none of the color channels exceeds the alpha.<br />
<br />
If you have several moving particles with high alpha, you may get z-fighting problems where particles flicker as they move past one another. Reducing the alpha can help with this.<br />
<br />
Suggested Use:<br />
*This is probably the most versatile class.<br />
*Anything moving that is not doing so at constant velocity.<br />
*If you want something that expands (or shrinks) to some size then stops, set sizeMod to something less than 1, and sizeGrowth to something positive. The particle will grow to a size equal to sizeGrowth/ (1 - sizeMod) and stop. The smaller sizeMod is, the faster it will reach this size.<br />
<br />
== CSpherePartSpawner ==<br />
<br />
Draws an expanding sphere.<br />
<br />
Properties:<br />
*alpha (float): The alpha of the sphere.<br />
*ttl (int): How long the sphere lasts.<br />
*expansionSpeed (float): How quickly the sphere expands.<br />
*color (float3): The color of the sphere.<br />
<br />
Suggested Use:<br />
*Looks like a shockwave.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG-Classes&diff=3772CEG-Classes2008-12-31T21:46:07Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/<br />
<br />
https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/Unsynced/<br />
<br />
== Common Properties ==<br />
All classes have the following properties, although not all of them use them:<br />
<br />
*pos (float3): The initial position of the spawner.<br />
*useAirLos (bool): Whether the spawner uses air LoS to determine if it is visible. This may allow the spawner to be seen from a further distance than normal.<br />
*alwaysVisible (bool): If true, the spawner is always visible, ignoring LoS.<br />
*speed (float3): The initial speed of the spawner.<br />
<br />
== CExpGenSpawner ==<br />
This is the closest thing CEG has to a function call. Instead of creating a graphical effect on its own, it creates another CEG.<br />
<br />
Properties:<br />
<br />
*delay (int): How long to wait before spawning the CEG.<br />
*dir (float3): The CEG will be called with this direction.<br />
*damage (float): The CEG will be called with this damage. The CEG doesn't actually deal any damage, but you can use this as a parameter and read it using the 'd' operator.<br />
*explosionGenerator (string): The name of the CEG you want to spawn.<br />
<br />
Suggested Use: <br />
*If you use a spawner a lot of times, you may want to make it a separate CEG to avoid having to copy-paste many times.<br />
*This is the only way to truly delay a graphical effect.<br />
*The spawned CEG still checks conditions, so if you want to, say, spawn an effect only if it is in water ''and'' doesn't hit a unit, you can give the CExpGenSpawner <code>nounit = 1;</code> and the spawned <code>CEG water = 1;</code>.<br />
*This allows you to give a set of spawners the same (and possibly random) direction.<br />
<br />
== CBitmapMuzzleFlame ==<br />
This creates three rectangular textures at right angles to each other. The <code>frontTexture</code> has <code>dir</code> as its normal.<br />
<br />
Properties: <br />
*sideTexture (string)<br />
*frontTexture (string)<br />
*dir (float3)<br />
*colorMap (string)<br />
*size (float): The initial width of the muzzle flame.<br />
*length (float): The initial length of the muzzle flame.<br />
*sizeGrowth (float): By the end of its life, the muzzle flame grows to 1 + sizeGrowth times its initial size and length. The flame grows quickly at first and more slowly toward the end.<br />
*ttl (int): How long the muzzle flame lasts.<br />
*frontOffset (float): Where the frontTexture is along the length of the muzzle flame. 0 means it is in the back, 1 is in the front.<br />
<br />
Suggested Use:<br />
*Muzzle flames, obviously.<br />
*You can use an upward-pointing CBitmapMuzzleFlame as a simple splash of water or dirt.<br />
*Railgun trails.<br />
*This is the only class that both obeys perspective and allows for a custom texture. All other classes except CExploSpikeProjectile always face directly toward the viewer.<br />
<br />
== CExploSpikeProjectile ==<br />
<br />
This creates a glowy spike. Note that the spike is two sided, i.e., symmetric about the position of the spawner.<br />
<br />
*length (float): The initial length of (half) of the spike.<br />
*width (float): Half the initial width of of the spike.<br />
*alpha (float): The starting alpha of the spike.<br />
*alphaDecay (float): How quickly the alpha of the spike decreases.<br />
*lengthGrowth (float): How much the spike grows in length every frame. The spike does not grow in width.<br />
*dir (float3): The direction of the spike.<br />
*color (float3): The color of the spike.<br />
<br />
Suggested Use:<br />
*Anything glowy.<br />
*For large, slow missiles, you can try using this as an extended engine flame. Set the width to something fairly large.<br />
<br />
== CHeatCloudProjectile ==<br />
<br />
Creates an expanding sprite. Simple but effective.<br />
<br />
*heat (float)<br />
*maxheat (float)<br />
*heatFalloff (float)<br />
This is really confusing way of representing alpha and alphaDecay. Basically alpha = heat/maxheat, and alphaDecay = heatFalloff/maxHeat.<br />
*size (float): The initial radius of the heatcloud.<br />
*sizeGrowth (float): The heatcloud grows by this amount every frame.<br />
*sizemod (float): The size of the heatcloud is multiplied by 1 - sizemod.<br />
*sizemodmod (float): Each frame, sizemod is multiplied by sizemodmod.<br />
*texture (string): The texture used for the heatcloud.<br />
<br />
Suggested Use:<br />
*As the main background to an explosion.<br />
<br />
== CSimpleParticleSystem ==<br />
<br />
Creates a sprite that can undergo complex motion. Probably the most versatile class. Since there are a lot of properties, I'll group them:<br />
<br />
=== Initial Velocity Properties ===<br />
*emitVector (float3): The basic direction in which the particle is emitted.<br />
*emitRot (float): At what angle to emit the particle relative to emitVector. 0 means that the particle will be emitted in emitVector's direction; 180 will emit the particle in the opposite direction. 90 will emit the particle in a random direction perpendicular to emitVector, which is good for creating rings.<br />
*emitRotSpread (float): For each particle, a random number between 0 and emitRotSpread is added to the emitRot.<br />
*emitMul (float3): Scales the initial particle velocity; for this property, +y is considered to be in the direction of emitVector. Good if you want to create an egg-shaped explosion.<br />
*particleSpeed (float): The particle's initial speed.<br />
*particleSpeedSpread (float): For each particle, a random number between 0 and particleSpeedSpread is added to the particleSpeed .<br />
<br />
=== Movement Properties ===<br />
*gravity (float3): This will be added to the particle's velocity every frame.<br />
*airdrag (float): The particle's velocity is multiplied by this every frame.<br />
<br />
=== Size Properties ===<br />
*particleSize (float): The initial size of the particle.<br />
*particleSizeSpread (float): For each particle, a random number between 0 and particleSizeSpread is added to the particleSize.<br />
*sizeGrowth (float): How much the particle grows each frame.<br />
*sizeMod (float): The size of the particle is multiplied by this each frame.<br />
<br />
=== Visual Properties ===<br />
*directional (bool): If true, the particle will point in the direction it is moving.<br />
*texture (string): The texture to use for the particle.<br />
*colorMap (string): The colormap to use for the particle.<br />
<br />
=== Life Properties ===<br />
*numParticles (int): How many particles to create. This is not the same as <code>count</code>; if you spawn multiple particles using <code>count</code>, any [[CEG_Operators]] will be reevaluated for each particle, whereas if you use <code>numParticles</code> they will not be. However, the spread properties are evaluated separately for each particle regardless of which one you use.<br />
*particleLife (float): How long each particle lasts. <br />
*particleLifeSpread (float); For each particle, a random number between 0 and particleLifeSpread is added to the particleLife .<br />
<br />
=== Miscellaneous ===<br />
So far as I can tell, CEGs use the blending mode GL_ONE, GL_ONE_MINUS_SRC_ALPHA. This means that you can make a particle's color more intense or give it "washout" by setting its color channels greater than its alpha. Conversely, if you don't want washout, make sure none of the color channels exceeds the alpha.<br />
<br />
If you have several moving particles with high alpha, you may get z-fighting problems where particles flicker as they move past one another. Reducing the alpha can help with this.<br />
<br />
Suggested Use:<br />
*This is probably the most versatile class.<br />
*Anything moving that is not doing so at constant velocity.<br />
<br />
== CSpherePartSpawner ==<br />
<br />
Draws an expanding sphere.<br />
<br />
Properties:<br />
*alpha (float): The alpha of the sphere.<br />
*ttl (int): How long the sphere lasts.<br />
*expansionSpeed (float): How quickly the sphere expands.<br />
*color (float3): The color of the sphere.<br />
<br />
Suggested Use:<br />
*Looks like a shockwave.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG:Operators&diff=3921CEG:Operators2008-12-31T21:42:29Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/ExplosionGenerator.cpp<br />
<br />
== Introduction ==<br />
You are not limited to using fixed numbers in CEGs for positions, speeds, and so forth. Instead, you can use operators to change the CEG based on a variety of things.<br />
<br />
== Syntax ==<br />
Operators are read left to right. The operand is always to the right of the operator. Spaces are ignored, except to separate numbers. A number with no operator defaults to addition.<br />
<br />
== The Buffer ==<br />
CEG provides you with a buffer in which you can store numbers using the yank ('y') operator. This buffer can store 16 values, numbered 0 to 15.<br />
<br />
== Operators ==<br />
These are listed in the format "Operator Name (operator)".<br />
<br />
=== Index ('i') ===<br />
Multiplies the operand by the current count index. This index starts at 0 and increments every time the spawn is run, until the spawn has run a number of times equal to its count.<br />
<br />
Suggested use: Spawning things in a line.<br />
<br />
=== Rand ('r') ===<br />
Multiplies the operand by a random float between 0 and 1.<br />
<br />
Suggested use: Keeping explosions from looking too "perfect", making explosions look different every time.<br />
<br />
=== Damage ('d') ===<br />
Multiplies the operand by damage.<br />
<br />
=== Sawtooth ('m') ===<br />
Calculates the floating-point remainder of the operand.<br />
<br />
=== Discrete ('k') ===<br />
Calculates the floor of the operand.<br />
<br />
=== Sine ('s') ===<br />
Calculates the sine of the operand.<br />
<br />
=== Yank ('y') ===<br />
Saves the running result into buffer[operand], and resets the running result to zero.<br />
<br />
=== Multiply ('x') ===<br />
Multiplies the running result by buffer[operand].<br />
<br />
=== Add Buffer ('a') ===<br />
Adds buffer[operand] to the running result.<br />
<br />
=== Power ('p') ===<br />
Raises the running result to the operandth power<br />
<br />
=== Power Buffer ('q') ===<br />
Raises the running result to the buffer[operand]th power.<br />
<br />
=== Add (default) ===<br />
Adds the operand to the running result. This operator is used if no other operator is given.<br />
<br />
== Example ==<br />
<pre><br />
i0.03125y0 -0.2x0x0<br />
</pre><br />
<br />
This multiplies the index by 0.03125 and saves it to buffer[0]. It then multiplies -0.2 by buffer[0] twice. The result is then -0.2 (i * 0.03125)^2. This type of thing is useful for making a series of particles follow a curved path.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG-Classes&diff=3771CEG-Classes2008-12-31T21:41:34Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/<br />
<br />
https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/Unsynced/<br />
<br />
== Common Properties ==<br />
All classes have the following properties, although not all of them use them:<br />
<br />
*pos (float3): The initial position of the spawner.<br />
*useAirLos (bool): Whether the spawner uses air LoS to determine if it is visible. This may allow the spawner to be seen from a further distance than normal.<br />
*alwaysVisible (bool): If true, the spawner is always visible, ignoring LoS.<br />
*speed (float3): The initial speed of the spawner.<br />
<br />
== CExpGenSpawner ==<br />
This is the closest thing CEG has to a function call. Instead of creating a graphical effect on its own, it creates another CEG.<br />
<br />
Properties:<br />
<br />
*delay (int): How long to wait before spawning the CEG.<br />
*dir (float3): The CEG will be called with this direction.<br />
*damage (float): The CEG will be called with this damage. The CEG doesn't actually deal any damage, but you can use this as a parameter and read it using the 'd' operator.<br />
*explosionGenerator (string): The name of the CEG you want to spawn.<br />
<br />
Suggested Use: <br />
*If you use a spawner a lot of times, you may want to make it a separate CEG to avoid having to copy-paste many times.<br />
*This is the only way to truly delay a graphical effect.<br />
*The spawned CEG still checks conditions, so if you want to, say, spawn an effect only if it is in water ''and'' doesn't hit a unit, you can give the CExpGenSpawner <code>nounit = 1;</code> and the spawned <code>CEG water = 1;</code>.<br />
*This allows you to give a set of spawners the same (and possibly random) direction.<br />
<br />
== CBitmapMuzzleFlame ==<br />
This creates three rectangular textures at right angles to each other. The <code>frontTexture</code> has <code>dir</code> as its normal.<br />
<br />
Properties: <br />
*sideTexture (string)<br />
*frontTexture (string)<br />
*dir (float3)<br />
*colorMap (string)<br />
*size (float): The initial width of the muzzle flame.<br />
*length (float): The initial length of the muzzle flame.<br />
*sizeGrowth (float): By the end of its life, the muzzle flame grows to 1 + sizeGrowth times its initial size and length. The flame grows quickly at first and more slowly toward the end.<br />
*ttl (int): How long the muzzle flame lasts.<br />
*frontOffset (float): Where the frontTexture is along the length of the muzzle flame. 0 means it is in the back, 1 is in the front.<br />
<br />
Suggested Use:<br />
*Muzzle flames, obviously.<br />
*You can use an upward-pointing CBitmapMuzzleFlame as a simple splash of water or dirt.<br />
*Railgun trails.<br />
*This is the only class that both obeys perspective and allows for a custom texture. All other classes except CExploSpikeProjectile always face directly toward the viewer.<br />
<br />
== CExploSpikeProjectile ==<br />
<br />
This creates a glowy spike. Note that the spike is two sided, i.e., symmetric about the position of the spawner.<br />
<br />
*length (float): The initial length of (half) of the spike.<br />
*width (float): Half the initial width of of the spike.<br />
*alpha (float): The starting alpha of the spike.<br />
*alphaDecay (float): How quickly the alpha of the spike decreases.<br />
*lengthGrowth (float): How much the spike grows in length every frame. The spike does not grow in width.<br />
*dir (float3): The direction of the spike.<br />
*color (float3): The color of the spike.<br />
<br />
Suggested Use:<br />
*Anything glowy.<br />
*For large, slow missiles, you can try using this as an extended engine flame. Set the width to something fairly large.<br />
<br />
== CHeatCloudProjectile ==<br />
<br />
Creates an expanding sprite. Simple but effective.<br />
<br />
*heat (float)<br />
*maxheat (float)<br />
*heatFalloff (float)<br />
This is really confusing way of representing alpha and alphaDecay. Basically alpha = heat/maxheat, and alphaDecay = heatFalloff/maxHeat.<br />
*size (float): The initial radius of the heatcloud.<br />
*sizeGrowth (float): The heatcloud grows by this amount every frame.<br />
*sizemod (float): The size of the heatcloud is multiplied by 1 - sizemod.<br />
*sizemodmod (float): Each frame, sizemod is multiplied by sizemodmod.<br />
*texture (string): The texture used for the heatcloud.<br />
<br />
Suggested Use:<br />
*As the main background to an explosion.<br />
<br />
== CSimpleParticleSystem ==<br />
<br />
Creates a sprite that can undergo complex motion. Probably the most versatile class. Since there are a lot of properties, I'll group them:<br />
<br />
=== Initial Velocity Properties ===<br />
*emitVector (float3): The basic direction in which the particle is emitted.<br />
*emitRot (float): At what angle to emit the particle relative to emitVector. 0 means that the particle will be emitted in emitVector's direction; 180 will emit the particle in the opposite direction. 90 will emit the particle in a random direction perpendicular to emitVector, which is good for creating rings.<br />
*emitRotSpread (float): For each particle, a random number between 0 and emitRotSpread is added to the emitRot.<br />
*emitMul (float3): Scales the initial particle velocity; for this property, +y is considered to be in the direction of emitVector. Good if you want to create an egg-shaped explosion.<br />
*particleSpeed (float): The particle's initial speed.<br />
*particleSpeedSpread (float): For each particle, a random number between 0 and particleSpeedSpread is added to the particleSpeed .<br />
<br />
=== Movement Properties ===<br />
*gravity (float3): This will be added to the particle's velocity every frame.<br />
*airdrag (float): The particle's velocity is multiplied by this every frame.<br />
<br />
=== Size Properties ===<br />
*particleSize (float): The initial size of the particle.<br />
*particleSizeSpread (float): For each particle, a random number between 0 and particleSizeSpread is added to the particleSize.<br />
*sizeGrowth (float): How much the particle grows each frame.<br />
*sizeMod (float): The size of the particle is multiplied by this each frame.<br />
<br />
=== Visual Properties ===<br />
*directional (bool): If true, the particle will point in the direction it is moving.<br />
*texture (string): The texture to use for the particle.<br />
*colorMap (string): The colormap to use for the particle.<br />
<br />
=== Life Properties ===<br />
*numParticles (int): How many particles to create.<br />
*particleLife (float): How long each particle lasts. <br />
*particleLifeSpread (float); For each particle, a random number between 0 and particleLifeSpread is added to the particleLife .<br />
<br />
=== Miscellaneous ===<br />
So far as I can tell, CEGs use the blending mode GL_ONE, GL_ONE_MINUS_SRC_ALPHA. This means that you can make a particle's color more intense or give it "washout" by setting its color channels greater than its alpha. Conversely, if you don't want washout, make sure none of the color channels exceeds the alpha.<br />
<br />
If you have several moving particles with high alpha, you may get z-fighting problems where particles flicker as they move past one another. Reducing the alpha can help with this.<br />
<br />
Suggested Use:<br />
*This is probably the most versatile class.<br />
*Anything moving that is not doing so at constant velocity.<br />
<br />
== CSpherePartSpawner ==<br />
<br />
Draws an expanding sphere.<br />
<br />
Properties:<br />
*alpha (float): The alpha of the sphere.<br />
*ttl (int): How long the sphere lasts.<br />
*expansionSpeed (float): How quickly the sphere expands.<br />
*color (float3): The color of the sphere.<br />
<br />
Suggested Use:<br />
*Looks like a shockwave.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG-Classes&diff=3770CEG-Classes2008-12-31T21:39:42Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/<br />
<br />
https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/Unsynced/<br />
<br />
== Common Properties ==<br />
All classes have the following properties, although not all of them use them:<br />
<br />
*pos (float3): The initial position of the spawner.<br />
*useAirLos (bool): Whether the spawner uses air LoS to determine if it is visible. This may allow the spawner to be seen from a further distance than normal.<br />
*alwaysVisible (bool): If true, the spawner is always visible, ignoring LoS.<br />
*speed (float3): The initial speed of the spawner.<br />
<br />
== CExpGenSpawner ==<br />
This is the closest thing CEG has to a function call. Instead of creating a graphical effect on its own, it creates another ceg.<br />
<br />
Properties:<br />
<br />
*delay (int): How long to wait before spawning the CEG.<br />
*dir (float3): The CEG will be called with this direction.<br />
*damage (float): The CEG will be called with this damage. The CEG doesn't actually deal any damage, but you can use this as a parameter and read it using the 'd' operator.<br />
*explosionGenerator (string): The name of the CEG you want to spawn.<br />
<br />
Suggested Use: <br />
*If you use a spawner a lot of times, you may want to make it a separate CEG to avoid having to copy-paste many times.<br />
*This is the only way to truly delay a graphical effect.<br />
*The spawned CEG still checks conditions, so if you want to, say, spawn an effect only if it is in water ''and'' doesn't hit a unit, you can give the CExpGenSpawner <code>nounit = 1;</code> and the spawned <code>CEG water = 1;</code>.<br />
*This allows you to give a set of spawners the same (and possibly random) direction.<br />
<br />
== CBitmapMuzzleFlame ==<br />
This creates three rectangular textures at right angles to each other. The <code>frontTexture</code> has <code>dir</code> as its normal.<br />
<br />
Properties: <br />
*sideTexture (string)<br />
*frontTexture (string)<br />
*dir (float3)<br />
*colorMap (string)<br />
*size (float): The initial width of the muzzle flame.<br />
*length (float): The initial length of the muzzle flame.<br />
*sizeGrowth (float): By the end of its life, the muzzle flame grows to 1 + sizeGrowth times its initial size and length. The flame grows quickly at first and more slowly toward the end.<br />
*ttl (int): How long the muzzle flame lasts.<br />
*frontOffset (float): Where the frontTexture is along the length of the muzzle flame. 0 means it is in the back, 1 is in the front.<br />
<br />
Suggested Use:<br />
*Muzzle flames, obviously.<br />
*You can use an upward-pointing CBitmapMuzzleFlame as a simple splash of water or dirt.<br />
*Railgun trails.<br />
*This is the only class that both obeys perspective and allows for a custom texture. All other classes except CExploSpikeProjectile always face directly toward the viewer.<br />
<br />
== CExploSpikeProjectile ==<br />
<br />
This creates a glowy spike. Note that the spike is two sided, i.e., symmetric about the position of the spawner.<br />
<br />
*length (float): The initial length of (half) of the spike.<br />
*width (float): Half the initial width of of the spike.<br />
*alpha (float): The starting alpha of the spike.<br />
*alphaDecay (float): How quickly the alpha of the spike decreases.<br />
*lengthGrowth (float): How much the spike grows in length every frame. The spike does not grow in width.<br />
*dir (float3): The direction of the spike.<br />
*color (float3): The color of the spike.<br />
<br />
Suggested Use:<br />
*Anything glowy.<br />
*For large, slow missiles, you can try using this as an extended engine flame. Set the width to something fairly large.<br />
<br />
== CHeatCloudProjectile ==<br />
<br />
Creates an expanding sprite. Simple but effective.<br />
<br />
*heat (float)<br />
*maxheat (float)<br />
*heatFalloff (float)<br />
This is really confusing way of representing alpha and alphaDecay. Basically alpha = heat/maxheat, and alphaDecay = heatFalloff/maxHeat.<br />
*size (float): The initial radius of the heatcloud.<br />
*sizeGrowth (float): The heatcloud grows by this amount every frame.<br />
*sizemod (float): The size of the heatcloud is multiplied by 1 - sizemod.<br />
*sizemodmod (float): Each frame, sizemod is multiplied by sizemodmod.<br />
*texture (string): The texture used for the heatcloud.<br />
<br />
Suggested Use:<br />
*As the main background to an explosion.<br />
<br />
== CSimpleParticleSystem ==<br />
<br />
Creates a sprite that can undergo complex motion. Probably the most versatile class. Since there are a lot of properties, I'll group them:<br />
<br />
=== Initial Velocity Properties ===<br />
*emitVector (float3): The basic direction in which the particle is emitted.<br />
*emitRot (float): At what angle to emit the particle relative to emitVector. 0 means that the particle will be emitted in emitVector's direction; 180 will emit the particle in the opposite direction. 90 will emit the particle in a random direction perpendicular to emitVector, which is good for creating rings.<br />
*emitRotSpread (float): For each particle, a random number between 0 and emitRotSpread is added to the emitRot.<br />
*emitMul (float3): Scales the initial particle velocity; for this property, +y is considered to be in the direction of emitVector. Good if you want to create an egg-shaped explosion.<br />
*particleSpeed (float): The particle's initial speed.<br />
*particleSpeedSpread (float): For each particle, a random number between 0 and particleSpeedSpread is added to the particleSpeed .<br />
<br />
=== Movement Properties ===<br />
*gravity (float3): This will be added to the particle's velocity every frame.<br />
*airdrag (float): The particle's velocity is multiplied by this every frame.<br />
<br />
=== Size Properties ===<br />
*particleSize (float): The initial size of the particle.<br />
*particleSizeSpread (float): For each particle, a random number between 0 and particleSizeSpread is added to the particleSize.<br />
*sizeGrowth (float): How much the particle grows each frame.<br />
*sizeMod (float): The size of the particle is multiplied by this each frame.<br />
<br />
=== Visual Properties ===<br />
*directional (bool): If true, the particle will point in the direction it is moving.<br />
*texture (string): The texture to use for the particle.<br />
*colorMap (string): The colormap to use for the particle.<br />
<br />
=== Life Properties ===<br />
*numParticles (int): How many particles to create.<br />
*particleLife (float): How long each particle lasts. <br />
*particleLifeSpread (float); For each particle, a random number between 0 and particleLifeSpread is added to the particleLife .<br />
<br />
=== Miscellaneous ===<br />
So far as I can tell, CEGs use the blending mode GL_ONE, GL_ONE_MINUS_SRC_ALPHA. This means that you can make a particle's color more intense or give it "washout" by setting its color channels greater than its alpha. Conversely, if you don't want washout, make sure none of the color channels exceeds the alpha.<br />
<br />
If you have several moving particles with high alpha, you may get z-fighting problems where particles flicker as they move past one another. Reducing the alpha can help with this.<br />
<br />
Suggested Use:<br />
*This is probably the most versatile class.<br />
*Anything moving that is not doing so at constant velocity.<br />
<br />
== CSpherePartSpawner ==<br />
<br />
Draws an expanding sphere.<br />
<br />
Properties:<br />
*alpha (float): The alpha of the sphere.<br />
*ttl (int): How long the sphere lasts.<br />
*expansionSpeed (float): How quickly the sphere expands.<br />
*color (float3): The color of the sphere.<br />
<br />
Suggested Use:<br />
*Looks like a shockwave.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG-Classes&diff=3769CEG-Classes2008-12-31T21:38:15Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/<br />
<br />
https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/Unsynced/<br />
<br />
== Common Properties ==<br />
All classes have the following properties, although not all of them use them:<br />
<br />
*pos (float3): The initial position of the spawner.<br />
*useAirLos (bool): Whether the spawner uses air LoS to determine if it is visible. This may allow the spawner to be seen from a further distance than normal.<br />
*alwaysVisible (bool): If true, the spawner is always visible, ignoring LoS.<br />
*speed (float3): The initial speed of the spawner.<br />
<br />
== CExpGenSpawner ==<br />
This is the closest thing CEG has to a function call. Instead of creating a graphical effect on its own, it creates another ceg.<br />
<br />
Properties:<br />
<br />
*delay (int): How long to wait before spawning the CEG.<br />
*dir (float3): The CEG will be called with this direction.<br />
*damage (float): The CEG will be called with this damage. The CEG doesn't actually deal any damage, but you can use this as a parameter and read it using the 'd' operator.<br />
*explosionGenerator (string): The name of the CEG you want to spawn.<br />
<br />
Suggested Use: <br />
*If you use a spawner a lot of times, you may want to make it a separate CEG to avoid having to copy-paste many times.<br />
*This is the only way to truly delay a graphical effect.<br />
*The spawned CEG still checks conditions, so if you want to, say, spawn an effect only if it is in water ''and'' doesn't hit a unit, you can give the CExpGenSpawner <code>nounit = 1;</code> and the spawned <code>CEG water = 1;</code>.<br />
*This allows you to give a set of spawners the same (and possibly random) direction.<br />
<br />
== CBitmapMuzzleFlame ==<br />
This creates three rectangular textures at right angles to each other. The <code>frontTexture</code> has <code>dir</code> as its normal.<br />
<br />
Properties: <br />
*sideTexture (string)<br />
*frontTexture (string)<br />
*dir (float3)<br />
*colorMap (string)<br />
*size (float): The initial width of the muzzle flame.<br />
*length (float): The initial length of the muzzle flame.<br />
*sizeGrowth (float): By the end of its life, the muzzle flame grows to 1 + sizeGrowth times its initial size and length. The flame grows quickly at first and more slowly toward the end.<br />
*ttl (int): How long the muzzle flame lasts.<br />
*frontOffset (float): Where the frontTexture is along the length of the muzzle flame. 0 means it is in the back, 1 is in the front.<br />
<br />
Suggested Use:<br />
*Muzzle flames, obviously.<br />
*You can use an upward-pointing CBitmapMuzzleFlame as a simple splash of water or dirt.<br />
*Railgun trails.<br />
*This is the only class that both obeys perspective and allows for a custom texture. All other classes except CExploSpikeProjectile always face directly toward the viewer.<br />
<br />
== CExploSpikeProjectile ==<br />
<br />
This creates a glowy spike. Note that the spike is two sided, i.e., symmetric about the position of the spawner.<br />
<br />
*length (float): The initial length of (half) of the spike.<br />
*width (float): Half the initial width of of the spike.<br />
*alpha (float): The starting alpha of the spike.<br />
*alphaDecay (float): How quickly the alpha of the spike decreases.<br />
*lengthGrowth (float): How much the spike grows in length every frame. The spike does not grow in width.<br />
*dir (float3): The direction of the spike.<br />
*color (float3): The color of the spike.<br />
<br />
Suggested Use:<br />
*Anything glowy.<br />
*For large, slow missiles, you can try using this as an extended engine flame. Set the width to something fairly large.<br />
<br />
== CHeatCloudProjectile ==<br />
<br />
Creates an expanding sprite. Simple but effective.<br />
<br />
*heat (float)<br />
*maxheat (float)<br />
*heatFalloff (float)<br />
This is really confusing way of representing alpha and alphaDecay. Basically alpha = heat/maxheat, and alphaDecay = heatFalloff/maxHeat.<br />
*size (float): The initial radius of the heatcloud.<br />
*sizeGrowth (float): The heatcloud grows by this amount every frame.<br />
*sizemod (float): The size of the heatcloud is multiplied by 1 - sizemod.<br />
*sizemodmod (float): Each frame, sizemod is multiplied by sizemodmod.<br />
*texture (string): The texture used for the heatcloud.<br />
<br />
Suggested Use:<br />
*As the main background to an explosion.<br />
<br />
== CSimpleParticleSystem ==<br />
<br />
Creates a sprite that can undergo complex motion. Probably the most versatile class. Since there are a lot of properties, I'll group them:<br />
<br />
=== Initial Velocity Properties ===<br />
*emitVector (float3): The basic direction in which the particle is emitted.<br />
*emitRot (float): At what angle to emit the particle relative to emitVector. 0 means that the particle will be emitted in emitVector's direction; 180 will emit the particle in the opposite direction. 90 will emit the particle in a random direction perpendicular to emitVector, which is good for creating rings.<br />
*emitRotSpread (float): For each particle, a random number between 0 and emitRotSpread is added to the emitRot.<br />
*emitMul (float3): Scales the initial particle velocity; for this property, +y is considered to be in the direction of emitVector. Good if you want to create an egg-shaped explosion.<br />
*particleSpeed (float): The particle's initial speed.<br />
*particleSpeedSpread (float): For each particle, a random number between 0 and particleSpeedSpread is added to the particleSpeed .<br />
<br />
=== Movement Properties ===<br />
*gravity (float3): This will be added to the particle's velocity every frame.<br />
*airdrag (float): The particle's velocity is multiplied by this every frame.<br />
<br />
=== Size Properties ===<br />
*particleSize (float): The initial size of the particle.<br />
*particleSizeSpread (float): For each particle, a random number between 0 and particleSizeSpread is added to the particleSize.<br />
*sizeGrowth (float): How much the particle grows each frame.<br />
*sizeMod (float): The size of the particle is multiplied by this each frame.<br />
<br />
=== Visual Properties ===<br />
*directional (bool): If true, the particle will point in the direction it is moving.<br />
*texture (string): The texture to use for the particle.<br />
*colorMap (string): The colormap to use for the particle.<br />
<br />
=== Life Properties ===<br />
*numParticles (int): How many particles to create.<br />
*particleLife (float): How long each particle lasts. <br />
*particleLifeSpread (float); For each particle, a random number between 0 and particleLifeSpread is added to the particleLife .<br />
<br />
=== Blending ===<br />
Not a property, but worth mentioning. So far as I can tell, CEGs use the blending mode GL_ONE, GL_ONE_MINUS_SRC_ALPHA. This means that you can make a particle's color more intense or give it "washout" by setting its color channels greater than its alpha. Conversely, if you don't want washout, make sure none of the color channels exceeds the alpha.<br />
<br />
*If you set the color components of a CEG higher than the alpha, <br />
<br />
Suggested Use:<br />
*This is probably the most versatile class.<br />
*Anything moving that is not doing so at constant velocity.<br />
<br />
== CSpherePartSpawner ==<br />
<br />
Draws an expanding sphere.<br />
<br />
Properties:<br />
*alpha (float): The alpha of the sphere.<br />
*ttl (int): How long the sphere lasts.<br />
*expansionSpeed (float): How quickly the sphere expands.<br />
*color (float3): The color of the sphere.<br />
<br />
Suggested Use:<br />
*Looks like a shockwave.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG-Classes&diff=3768CEG-Classes2008-12-31T21:33:56Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/<br />
<br />
https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/Unsynced/<br />
<br />
== Common Properties ==<br />
All classes have the following properties, although not all of them use them:<br />
<br />
*pos (float3): The initial position of the spawner.<br />
*useAirLos (bool): Whether the spawner uses air LoS to determine if it is visible. This may allow the spawner to be seen from a further distance than normal.<br />
*alwaysVisible (bool): If true, the spawner is always visible, ignoring LoS.<br />
*speed (float3): The initial speed of the spawner.<br />
<br />
== CExpGenSpawner ==<br />
This is the closest thing CEG has to a function call. Instead of creating a graphical effect on its own, it creates another ceg.<br />
<br />
Properties:<br />
<br />
*delay (int): How long to wait before spawning the CEG.<br />
*dir (float3): The CEG will be called with this direction.<br />
*damage (float): The CEG will be called with this damage. The CEG doesn't actually deal any damage, but you can use this as a parameter and read it using the 'd' operator.<br />
*explosionGenerator (string): The name of the CEG you want to spawn.<br />
<br />
Suggested Use: <br />
*If you use a spawner a lot of times, you may want to make it a separate CEG to avoid having to copy-paste many times.<br />
*This is the only way to truly delay a graphical effect.<br />
*The spawned CEG still checks conditions, so if you want to, say, spawn an effect only if it is in water ''and'' doesn't hit a unit, you can give the CExpGenSpawner <code>nounit = 1;</code> and the spawned <code>CEG water = 1;</code>.<br />
*This allows you to give a set of spawners the same (and possibly random) direction.<br />
<br />
== CBitmapMuzzleFlame ==<br />
This creates three rectangular textures at right angles to each other. The <code>frontTexture</code> has <code>dir</code> as its normal.<br />
<br />
Properties: <br />
*sideTexture (string)<br />
*frontTexture (string)<br />
*dir (float3)<br />
*colorMap (string)<br />
*size (float): The initial width of the muzzle flame.<br />
*length (float): The initial length of the muzzle flame.<br />
*sizeGrowth (float): By the end of its life, the muzzle flame grows to 1 + sizeGrowth times its initial size and length. The flame grows quickly at first and more slowly toward the end.<br />
*ttl (int): How long the muzzle flame lasts.<br />
*frontOffset (float): Where the frontTexture is along the length of the muzzle flame. 0 means it is in the back, 1 is in the front.<br />
<br />
Suggested Use:<br />
*Muzzle flames, obviously.<br />
*You can use an upward-pointing CBitmapMuzzleFlame as a simple splash of water or dirt.<br />
*Railgun trails.<br />
*This is the only class that both obeys perspective and allows for a custom texture. All other classes except CExploSpikeProjectile always face directly toward the viewer.<br />
<br />
== CExploSpikeProjectile ==<br />
<br />
This creates a glowy spike. Note that the spike is two sided, i.e., symmetric about the position of the spawner.<br />
<br />
*length (float): The initial length of (half) of the spike.<br />
*width (float): Half the initial width of of the spike.<br />
*alpha (float): The starting alpha of the spike.<br />
*alphaDecay (float): How quickly the alpha of the spike decreases.<br />
*lengthGrowth (float): How much the spike grows in length every frame. The spike does not grow in width.<br />
*dir (float3): The direction of the spike.<br />
*color (float3): The color of the spike.<br />
<br />
Suggested Use:<br />
*Anything glowy.<br />
*For large, slow missiles, you can try using this as an extended engine flame. Set the width to something fairly large.<br />
<br />
== CHeatCloudProjectile ==<br />
<br />
Creates an expanding sprite. Simple but effective.<br />
<br />
*heat (float)<br />
*maxheat (float)<br />
*heatFalloff (float)<br />
This is really confusing way of representing alpha and alphaDecay. Basically alpha = heat/maxheat, and alphaDecay = heatFalloff/maxHeat.<br />
*size (float): The initial radius of the heatcloud.<br />
*sizeGrowth (float): The heatcloud grows by this amount every frame.<br />
*sizemod (float): The size of the heatcloud is multiplied by 1 - sizemod.<br />
*sizemodmod (float): Each frame, sizemod is multiplied by sizemodmod.<br />
*texture (string): The texture used for the heatcloud.<br />
<br />
Suggested Use:<br />
*As the main background to an explosion.<br />
<br />
== CSimpleParticleSystem ==<br />
<br />
Creates a sprite that can undergo complex motion. Probably the most versatile class. Since there are a lot of properties, I'll group them:<br />
<br />
=== Initial Velocity Properties ===<br />
*emitVector (float3): The basic direction in which the particle is emitted.<br />
*emitRot (float): At what angle to emit the particle relative to emitVector. 0 means that the particle will be emitted in emitVector's direction; 180 will emit the particle in the opposite direction. 90 will emit the particle in a random direction perpendicular to emitVector, which is good for creating rings.<br />
*emitRotSpread (float): For each particle, a random number between 0 and emitRotSpread is added to the emitRot.<br />
*emitMul (float3): Scales the initial particle velocity; for this property, +y is considered to be in the direction of emitVector. Good if you want to create an egg-shaped explosion.<br />
*particleSpeed (float): The particle's initial speed.<br />
*particleSpeedSpread (float): For each particle, a random number between 0 and particleSpeedSpread is added to the particleSpeed .<br />
<br />
=== Movement Properties ===<br />
*gravity (float3): This will be added to the particle's velocity every frame.<br />
*airdrag (float): The particle's velocity is multiplied by this every frame.<br />
<br />
=== Size Properties ===<br />
*particleSize (float): The initial size of the particle.<br />
*particleSizeSpread (float): For each particle, a random number between 0 and particleSizeSpread is added to the particleSize.<br />
*sizeGrowth (float): How much the particle grows each frame.<br />
*sizeMod (float): The size of the particle is multiplied by this each frame.<br />
<br />
=== Visual Properties ===<br />
*directional (bool): If true, the particle will point in the direction it is moving.<br />
*texture (string): The texture to use for the particle.<br />
*colorMap (string): The colormap to use for the particle.<br />
<br />
=== Life Properties ===<br />
*numParticles (int): How many particles to create.<br />
*particleLife (float): How long each particle lasts. <br />
*particleLifeSpread (float); For each particle, a random number between 0 and particleLifeSpread is added to the particleLife .<br />
<br />
Suggested Use:<br />
*This is probably the most versatile class.<br />
*Anything moving that is not doing so at constant velocity.<br />
<br />
== CSpherePartSpawner ==<br />
<br />
Draws an expanding sphere.<br />
<br />
Properties:<br />
*alpha (float): The alpha of the sphere.<br />
*ttl (int): How long the sphere lasts.<br />
*expansionSpeed (float): How quickly the sphere expands.<br />
*color (float3): The color of the sphere.<br />
<br />
Suggested Use:<br />
*Looks like a shockwave.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG-Classes&diff=3767CEG-Classes2008-12-31T21:32:04Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/<br />
<br />
https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/Unsynced/<br />
<br />
== Common Properties ==<br />
All classes have the following properties, although not all of them use them:<br />
<br />
*pos (float3): The initial position of the spawner.<br />
*useAirLos (bool): Whether the spawner uses air LoS to determine if it is visible. This may allow the spawner to be seen from a further distance than normal.<br />
*alwaysVisible (bool): If true, the spawner is always visible, ignoring LoS.<br />
*speed (float3): The initial speed of the spawner.<br />
<br />
== CExpGenSpawner ==<br />
This is the closest thing CEG has to a function call. Instead of creating a graphical effect on its own, it creates another ceg.<br />
<br />
Properties:<br />
<br />
*delay (int): How long to wait before spawning the CEG.<br />
*dir (float3): The CEG will be called with this direction.<br />
*damage (float): The CEG will be called with this damage. The CEG doesn't actually deal any damage, but you can use this as a parameter and read it using the 'd' operator.<br />
*explosionGenerator (string): The name of the CEG you want to spawn.<br />
<br />
Suggested Use: <br />
*If you use a spawner a lot of times, you may want to make it a separate CEG to avoid having to copy-paste many times.<br />
*This is the only way to truly delay a graphical effect.<br />
*The spawned CEG still checks conditions, so if you want to, say, spawn an effect only if it is in water ''and'' doesn't hit a unit, you can give the CExpGenSpawner <code>nounit = 1;</code> and the spawned <code>CEG water = 1;</code>.<br />
*This allows you to give a set of spawners the same (and possibly random) direction.<br />
<br />
== CBitmapMuzzleFlame ==<br />
This creates three rectangular textures at right angles to each other. The <code>frontTexture</code> has <code>dir</code> as its normal.<br />
<br />
Properties: <br />
*sideTexture (string)<br />
*frontTexture (string)<br />
*dir (float3)<br />
*colorMap (string)<br />
*size (float): The initial width of the muzzle flame.<br />
*length (float): The initial length of the muzzle flame.<br />
*sizeGrowth (float): By the end of its life, the muzzle flame grows to 1 + sizeGrowth times its initial size and length. The flame grows quickly at first and more slowly toward the end.<br />
*ttl (int): How long the muzzle flame lasts.<br />
*frontOffset (float): Where the frontTexture is along the length of the muzzle flame. 0 means it is in the back, 1 is in the front.<br />
<br />
Suggested Use:<br />
*Muzzle flames, obviously.<br />
*You can use an upward-pointing CBitmapMuzzleFlame as a simple splash of water or dirt.<br />
*Railgun trails.<br />
*This is the only class that both obeys perspective and allows for a custom texture. All other classes except CExploSpikeProjectile always face directly toward the viewer.<br />
<br />
== CExploSpikeProjectile ==<br />
<br />
This creates a glowy spike. Note that the spike is two sided, i.e., symmetric about the position of the spawner.<br />
<br />
*length (float): The initial length of (half) of the spike.<br />
*width (float): Half the initial width of of the spike.<br />
*alpha (float): The starting alpha of the spike.<br />
*alphaDecay (float): How quickly the alpha of the spike decreases.<br />
*lengthGrowth (float): How much the spike grows in length every frame. The spike does not grow in width.<br />
*dir (float3): The direction of the spike.<br />
*color (float3): The color of the spike.<br />
<br />
Suggested Use:<br />
*Anything glowy.<br />
*For large, slow missiles, you can try using this as an extended engine flame. Set the width to something fairly large.<br />
<br />
== CHeatCloudProjectile ==<br />
<br />
Creates an expanding sprite. Simple but effective.<br />
<br />
*heat (float)<br />
*maxheat (float)<br />
*heatFalloff (float)<br />
This is really confusing way of representing alpha and alphaDecay. Basically alpha = heat/maxheat, and alphaDecay = heatFalloff/maxHeat.<br />
*size (float): The initial radius of the heatcloud.<br />
*sizeGrowth (float): The heatcloud grows by this amount every frame.<br />
*sizemod (float): The size of the heatcloud is multiplied by 1 - sizemod.<br />
*sizemodmod (float): Each frame, sizemod is multiplied by sizemodmod.<br />
*texture (string): The texture used for the heatcloud.<br />
<br />
Suggested Use:<br />
*As the main background to an explosion.<br />
<br />
== CSimpleParticleSystem ==<br />
<br />
Creates a sprite that can undergo complex motion. Probably the most versatile class. Since there are a lot of properties, I'll group them:<br />
<br />
=== Initial Velocity Properties ===<br />
*emitVector (float3): The basic direction in which the particle is emitted.<br />
*emitRot (float): At what angle to emit the particle relative to emitVector. 0 means that the particle will be emitted in emitVector's direction; 180 will emit the particle in the opposite direction. 90 will emit the particle in a random direction perpendicular to emitVector, which is good for creating rings.<br />
*emitRotSpread (float): For each particle, a random number between 0 and emitRotSpread is added to the emitRot.<br />
*emitMul (float3): Scales the initial particle velocity.<br />
*particleSpeed (float): The particle's initial speed.<br />
*particleSpeedSpread (float): For each particle, a random number between 0 and particleSpeedSpread is added to the particleSpeed .<br />
<br />
=== Movement Properties ===<br />
*gravity (float3): This will be added to the particle's velocity every frame.<br />
*airdrag (float): The particle's velocity is multiplied by this every frame.<br />
<br />
=== Size Properties ===<br />
*particleSize (float): The initial size of the particle.<br />
*particleSizeSpread (float): For each particle, a random number between 0 and particleSizeSpread is added to the particleSize.<br />
*sizeGrowth (float): How much the particle grows each frame.<br />
*sizeMod (float): The size of the particle is multiplied by this each frame.<br />
<br />
=== Visual Properties ===<br />
*directional (bool): If true, the particle will point in the direction it is moving.<br />
*texture (string): The texture to use for the particle.<br />
*colorMap (string): The colormap to use for the particle.<br />
<br />
=== Life Properties ===<br />
*numParticles (int): How many particles to create.<br />
*particleLife (float): How long each particle lasts. <br />
*particleLifeSpread (float); For each particle, a random number between 0 and particleLifeSpread is added to the particleLife .<br />
<br />
Suggested Use:<br />
*This is probably the most versatile class.<br />
*Anything moving that is not doing so at constant velocity.<br />
<br />
== CSpherePartSpawner ==<br />
<br />
Draws an expanding sphere.<br />
<br />
Properties:<br />
*alpha (float): The alpha of the sphere.<br />
*ttl (int): How long the sphere lasts.<br />
*expansionSpeed (float): How quickly the sphere expands.<br />
*color (float3): The color of the sphere.<br />
<br />
Suggested Use:<br />
*Looks like a shockwave.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG-Classes&diff=3766CEG-Classes2008-12-31T21:13:49Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/<br />
<br />
https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/Unsynced/<br />
<br />
== Common Properties ==<br />
All classes have the following properties, although not all of them use them:<br />
<br />
*pos (float3): The initial position of the spawner.<br />
*useAirLos (bool): Whether the spawner uses air LoS to determine if it is visible. This may allow the spawner to be seen from a further distance than normal.<br />
*alwaysVisible (bool): If true, the spawner is always visible, ignoring LoS.<br />
*speed (float3): The initial speed of the spawner.<br />
<br />
== CExpGenSpawner ==<br />
This is the closest thing CEG has to a function call. Instead of creating a graphical effect on its own, it creates another ceg.<br />
<br />
Properties:<br />
<br />
*delay (int): How long to wait before spawning the CEG.<br />
*dir (float3): The CEG will be called with this direction.<br />
*damage (float): The CEG will be called with this damage. The CEG doesn't actually deal any damage, but you can use this as a parameter and read it using the 'd' operator.<br />
*explosionGenerator (string): The name of the CEG you want to spawn.<br />
<br />
Suggested Use: <br />
*If you use a spawner a lot of times, you may want to make it a separate CEG to avoid having to copy-paste many times.<br />
*This is the only way to truly delay a graphical effect.<br />
*The spawned CEG still checks conditions, so if you want to, say, spawn an effect only if it is in water ''and'' doesn't hit a unit, you can give the CExpGenSpawner <code>nounit = 1;</code> and the spawned <code>CEG water = 1;</code>.<br />
*This allows you to give a set of spawners the same (and possibly random) direction.<br />
<br />
== CBitmapMuzzleFlame ==<br />
This creates three rectangular textures at right angles to each other. The <code>frontTexture</code> has <code>dir</code> as its normal.<br />
<br />
Properties: <br />
*sideTexture (string)<br />
*frontTexture (string)<br />
*dir (float3)<br />
*colorMap (string)<br />
*size (float): The initial width of the muzzle flame.<br />
*length (float): The initial length of the muzzle flame.<br />
*sizeGrowth (float): By the end of its life, the muzzle flame grows to 1 + sizeGrowth times its initial size and length. The flame grows quickly at first and more slowly toward the end.<br />
*ttl (int): How long the muzzle flame lasts.<br />
*frontOffset (float): Where the frontTexture is along the length of the muzzle flame. 0 means it is in the back, 1 is in the front.<br />
<br />
Suggested Use:<br />
*Muzzle flames, obviously.<br />
*You can use an upward-pointing CBitmapMuzzleFlame as a simple splash of water or dirt.<br />
*Railgun trails.<br />
*This is the only class that obeys perspective. All other classes always face directly toward the viewer.<br />
<br />
== CExploSpikeProjectile ==<br />
<br />
This creates a glowy spike. Note that the spike is two sided, i.e., symmetric about the position of the spawner.<br />
<br />
*length (float): The initial length of (half) of the spike.<br />
*width (float): Half the initial width of of the spike.<br />
*alpha (float): The starting alpha of the spike.<br />
*alphaDecay (float): How quickly the alpha of the spike decreases.<br />
*lengthGrowth (float): How much the spike grows in length every frame. The spike does not grow in width.<br />
*dir (float3): The direction of the spike.<br />
*color (float3): The color of the spike.<br />
<br />
Suggested Use:<br />
*Anything glowy.<br />
*For large, slow missiles, you can try using this as an extended engine flame. Set the width to something fairly large.<br />
<br />
== CHeatCloudProjectile ==<br />
<br />
*heat (float)<br />
*maxheat (float)<br />
*heatFalloff (float)<br />
This is really confusing way of representing alpha and alphaDecay. Basically alpha = heat/maxheat, and alphaDecay = heatFalloff/maxHeat.<br />
*size (float): The initial radius of the heatcloud.<br />
*sizeGrowth (float): The heatcloud grows by this amount every frame.<br />
*sizemod (float): The size of the heatcloud is multiplied by 1 - sizemod.<br />
*sizemodmod (float): Each frame, sizemod is multiplied by sizemodmod.<br />
*texture (string)<br />
<br />
Suggested Use:<br />
*As the main background to an explosion.<br />
<br />
== CSimpleParticleSystem ==<br />
<br />
*emitVector (float3)<br />
*emitMul (float3)<br />
*gravity (float3)<br />
*colorMap (string)<br />
*texture (string)<br />
*airdrag (float)<br />
*particleLife (float)<br />
*particleLifeSpread (float)<br />
*numParticles (int)<br />
*particleSpeed (float)<br />
*particleSpeedSpread (float)<br />
*particleSize (float)<br />
*particleSizeSpread (float)<br />
*emitRot (float)<br />
*emitRotSpread (float)<br />
*directional (bool)<br />
*sizeGrowth (float)<br />
*sizeMod (float)<br />
<br />
Suggested Use:<br />
*This is probably the most versatile class.<br />
*Anything moving that is not doing so at constant velocity.<br />
<br />
== CSpherePartSpawner ==<br />
<br />
Draws an expanding sphere.<br />
<br />
Properties:<br />
*alpha (float): The alpha of the sphere.<br />
*ttl (int): How long the sphere lasts.<br />
*expansionSpeed (float): How quickly the sphere expands.<br />
*color (float3): The color of the sphere.<br />
<br />
Suggested Use:<br />
*Looks like a shockwave.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG-Classes&diff=3765CEG-Classes2008-12-31T21:07:54Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/<br />
<br />
https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/Unsynced/<br />
<br />
== Common Properties ==<br />
All classes have the following properties, although not all of them use them:<br />
<br />
*pos (float3): The initial position of the spawner.<br />
*useAirLos (bool): Whether the spawner uses air LoS to determine if it is visible. This may allow the spawner to be seen from a further distance than normal.<br />
*alwaysVisible (bool): If true, the spawner is always visible, ignoring LoS.<br />
*speed (float3): The initial speed of the spawner.<br />
<br />
== CExpGenSpawner ==<br />
This is the closest thing CEG has to a function call. Instead of creating a graphical effect on its own, it creates another ceg.<br />
<br />
Properties:<br />
<br />
*delay (int): How long to wait before spawning the CEG.<br />
*dir (float3): The CEG will be called with this direction.<br />
*damage (float): The CEG will be called with this damage. The CEG doesn't actually deal any damage, but you can use this as a parameter and read it using the 'd' operator.<br />
*explosionGenerator (string): The name of the CEG you want to spawn.<br />
<br />
Suggested Use: <br />
*If you use a spawner a lot of times, you may want to make it a separate CEG to avoid having to copy-paste many times.<br />
*This is the only way to truly delay a graphical effect.<br />
*The spawned CEG still checks conditions, so if you want to, say, spawn an effect only if it is in water ''and'' doesn't hit a unit, you can give the CExpGenSpawner <code>nounit = 1;</code> and the spawned <code>CEG water = 1;</code>.<br />
*This allows you to give a set of spawners the same (and possibly random) direction.<br />
<br />
== CBitmapMuzzleFlame ==<br />
This creates three rectangular textures at right angles to each other. The <code>frontTexture</code> has <code>dir</code> as its normal.<br />
<br />
Properties: <br />
*sideTexture (string)<br />
*frontTexture (string)<br />
*dir (float3)<br />
*colorMap (string)<br />
*size (float): The initial width of the muzzle flame.<br />
*length (float): The initial length of the muzzle flame.<br />
*sizeGrowth (float): By the end of its life, the muzzle flame grows to 1 + sizeGrowth times its initial size and length. The flame grows quickly at first and more slowly toward the end.<br />
*ttl (int): How long the muzzle flame lasts.<br />
*frontOffset (float): Where the frontTexture is along the length of the muzzle flame. 0 means it is in the back, 1 is in the front.<br />
<br />
Suggested Use:<br />
*Muzzle flames, obviously.<br />
*You can use an upward-pointing CBitmapMuzzleFlame as a simple splash of water or dirt.<br />
*Railgun trails.<br />
*This is the only class that obeys perspective. All other classes always face directly toward the viewer.<br />
<br />
== CExploSpikeProjectile ==<br />
<br />
This creates a glowy spike. Note that the spike is two sided, i.e., symmetric about the position of the spawner.<br />
<br />
*length (float): The initial length of (half) of the spike.<br />
*width (float): Half the initial width of of the spike.<br />
*alpha (float): The starting alpha of the spike.<br />
*alphaDecay (float): How quickly the alpha of the spike decreases.<br />
*lengthGrowth (float): How much the spike grows in length every frame. The spike does not grow in width.<br />
*dir (float3): The direction of the spike.<br />
*color (float3): The color of the spike.<br />
<br />
Suggested Use:<br />
*Anything glowy.<br />
*For large, slow missiles, you can try using this as an extended engine flame. Set the width to something fairly large.<br />
<br />
== CHeatCloudProjectile ==<br />
<br />
*heat (float)<br />
*maxheat (float)<br />
*heatFalloff (float)<br />
*size (float)<br />
*sizeGrowth (float)<br />
*sizemod (float)<br />
*sizemodmod (float)<br />
*texture (string)<br />
<br />
Suggested Use:<br />
*As the main background to an explosion.<br />
<br />
== CSimpleParticleSystem ==<br />
<br />
*emitVector (float3)<br />
*emitMul (float3)<br />
*gravity (float3)<br />
*colorMap (string)<br />
*texture (string)<br />
*airdrag (float)<br />
*particleLife (float)<br />
*particleLifeSpread (float)<br />
*numParticles (int)<br />
*particleSpeed (float)<br />
*particleSpeedSpread (float)<br />
*particleSize (float)<br />
*particleSizeSpread (float)<br />
*emitRot (float)<br />
*emitRotSpread (float)<br />
*directional (bool)<br />
*sizeGrowth (float)<br />
*sizeMod (float)<br />
<br />
Suggested Use:<br />
*This is probably the most versatile class.<br />
*Anything moving.<br />
<br />
== CSpherePartSpawner ==<br />
<br />
Draws an expanding sphere.<br />
<br />
Properties:<br />
*alpha (float)<br />
*ttl (int)<br />
*expansionSpeed (float)<br />
*color (float3)<br />
<br />
Suggested Use:<br />
*Looks like a shockwave.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG-Classes&diff=3764CEG-Classes2008-12-31T21:03:21Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/<br />
<br />
https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/Unsynced/<br />
<br />
== Common Properties ==<br />
All classes have the following properties, although not all of them use them:<br />
<br />
*pos (float3): The initial position of the spawner.<br />
*useAirLos (bool): Whether the spawner uses air LoS to determine if it is visible. This may allow the spawner to be seen from a further distance than normal.<br />
*alwaysVisible (bool): If true, the spawner is always visible, ignoring LoS.<br />
*speed (float3): The initial speed of the spawner.<br />
<br />
== CExpGenSpawner ==<br />
This is the closest thing CEG has to a function call. Instead of creating a graphical effect on its own, it creates another ceg.<br />
<br />
Properties:<br />
<br />
*delay (int): How long to wait before spawning the CEG.<br />
*dir (float3): The CEG will be called with this direction.<br />
*damage (float): The CEG will be called with this damage. The CEG doesn't actually deal any damage, but you can use this as a parameter and read it using the 'd' operator.<br />
*explosionGenerator (string): The name of the CEG you want to spawn.<br />
<br />
Suggested Use: <br />
*If you use a spawner a lot of times, you may want to make it a separate CEG to avoid having to copy-paste many times.<br />
*This is the only way to truly delay a graphical effect.<br />
*The spawned CEG still checks conditions, so if you want to, say, spawn an effect only if it is in water ''and'' doesn't hit a unit, you can give the CExpGenSpawner <code>nounit = 1;</code> and the spawned <code>CEG water = 1;</code>.<br />
*This allows you to give a set of spawners the same (and possibly random) direction.<br />
<br />
== CBitmapMuzzleFlame ==<br />
This creates three rectangular textures at right angles to each other. The <code>frontTexture</code> has <code>dir</code> as its normal.<br />
<br />
Properties: <br />
*sideTexture (string)<br />
*frontTexture (string)<br />
*dir (float3)<br />
*colorMap (string)<br />
*size (float): The initial width of the muzzle flame.<br />
*length (float): The initial length of the muzzle flame.<br />
*sizeGrowth (float): By the end of its life, the muzzle flame grows to 1 + sizeGrowth times its initial size and length.<br />
*ttl (int): How long the muzzle flame lasts.<br />
*frontOffset (float): Where the frontTexture is along the length of the muzzle flame. 0 means it is in the back, 1 is in the front.<br />
<br />
Suggested Use:<br />
*Muzzle flames, obviously.<br />
*You can use an upward-pointing CBitmapMuzzleFlame as a simple splash of water or dirt.<br />
*Railgun trails.<br />
*This is the only class that obeys perspective. All other classes always face directly toward the viewer.<br />
<br />
== CExploSpikeProjectile ==<br />
<br />
*length (float)<br />
*width (float)<br />
*alpha (float)<br />
*alphaDecay (float)<br />
*lengthGrowth (float)<br />
*dir (float3)<br />
*color (float3)<br />
<br />
Suggested Use:<br />
*Anything glowy.<br />
*For large, slow missiles, you can try using this as an extended engine flame. Set the width to something fairly large.<br />
<br />
== CHeatCloudProjectile ==<br />
<br />
*heat (float)<br />
*maxheat (float)<br />
*heatFalloff (float)<br />
*size (float)<br />
*sizeGrowth (float)<br />
*sizemod (float)<br />
*sizemodmod (float)<br />
*texture (string)<br />
<br />
Suggested Use:<br />
*As the main background to an explosion.<br />
<br />
== CSimpleParticleSystem ==<br />
<br />
*emitVector (float3)<br />
*emitMul (float3)<br />
*gravity (float3)<br />
*colorMap (string)<br />
*texture (string)<br />
*airdrag (float)<br />
*particleLife (float)<br />
*particleLifeSpread (float)<br />
*numParticles (int)<br />
*particleSpeed (float)<br />
*particleSpeedSpread (float)<br />
*particleSize (float)<br />
*particleSizeSpread (float)<br />
*emitRot (float)<br />
*emitRotSpread (float)<br />
*directional (bool)<br />
*sizeGrowth (float)<br />
*sizeMod (float)<br />
<br />
Suggested Use:<br />
*This is probably the most versatile class.<br />
*Anything moving.<br />
<br />
== CSpherePartSpawner ==<br />
<br />
Draws an expanding sphere.<br />
<br />
Properties:<br />
*alpha (float)<br />
*ttl (int)<br />
*expansionSpeed (float)<br />
*color (float3)<br />
<br />
Suggested Use:<br />
*Looks like a shockwave.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG-Format&diff=3794CEG-Format2008-12-31T20:57:48Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles<br />
<br />
== Overall Format ==<br />
<br />
A CEG file contains one or more CEGs. Each CEG follows this format:<br />
<br />
<code><br />
[ceg_name] {<br />
useDefaultExplosions = 0;<br />
[spawner_name_0] {<br />
class=CClassName;<br />
[properties] {<br />
property0 = value0;<br />
property1 = value1;<br />
//and so on...<br />
}<br />
condition0 = 1;<br />
condition1 = 0;<br />
count = 1;<br />
}<br />
<br />
[spawner_name_1] {<br />
//each spawner follows that format<br />
}<br />
<br />
[groundflash] {<br />
//groundflash is a special name; it always generates a groundflash<br />
flashsize=16;<br />
flashalpha=1;<br />
circlegrowth=1;<br />
circlealpha=0;<br />
ttl=8;<br />
color=1,1,1;<br />
}<br />
}<br />
</code><br />
<br />
=== useDefaultExplosions ===<br />
If this is set, the CEG will use the default explosion (based on damage and area of effect) in addition to any spawners you define.<br />
<br />
=== Spawners ===<br />
A CEG can contain any number of spawners. The name of the spawners don't really matter, as long as it's not "groundflash", which has a special meaning. You can think of each spawner as being one component of the overall explosion.<br />
<br />
==== Class ====<br />
Each spawner has a class that determines what kind of graphical effect it creates. Spring has a number of standard classes that you can choose from. See [[CEG_Classes]] for details.<br />
<br />
==== Properties ====<br />
Depending on what class a spawner is, it will have a set of properties that allow you to fine-tune what the spawner displays. Again, see [[CEG_Classes]] for details.<br />
<br />
==== Conditions ====<br />
These determine under what conditions the spawner will run. The available conditions are "air" (at least 20 elmos above ground/sea level), "water", "ground", "unit" (hits a unit), and "nounit" (doesn't hit a unit). There is an "underwater" condition, but it doesn't actually work at time of writing. If you set the condition to true (e.g., "water = 1;"), the spawner will run if the explosion takes place under that condition. If you set more than one condition, the spawner will run if ''any'' of them are true. If you want a spawner to run only if two or more conditions are ''all'' true, you have to do a little trick with the CExpGenSpawner class.<br />
<br />
==== Count ====<br />
The count determines the number of times the spawner will run.<br />
<br />
=== groundflash ===<br />
If you name a spawner "groundflash," it will always generate a groundflash. A groundflash has the following properties:<br />
<br />
*flashsize (float): The radius of the groundflash.<br />
*flashalpha (float in [0, 1]): How transparent the groundflash is. Generally, the higher, the brighter.<br />
*circlegrowth (float): A groundflash can have an additional circle that expands outwards. This controls how fast the circle grows.<br />
*circlealpha (float in [0, 1]): How transparent the circle is.<br />
*ttl (int): How long the groundflash lasts.<br />
*color (float3): The color of the groundflash.<br />
<br />
Suggested Use: A short groundflash (~8 frames) is good for any explosion that gives off light. You can also use a longer groundflash to suggest the ground is glowing from heat.<br />
<br />
=== Data Types ===<br />
CEGs use the following data types:<br />
<br />
*float: Most properties are floats.<br />
*int: Used for counts and ttls.<br />
*bool: Use for conditions, and some properties.<br />
*float3: Used for vectors and colors. The components are floats, separated by commas. You can also use the keyword <code>dir</code>, which represents the direction fed to the CEG.<br />
*string: Used for colormaps and texture names. In .lua you delimit a string by quotes; in .tdf you do not. Color maps consist of 2 or more groups of 4 numbers, each group representing a RGBA color. Textures are the names you define in gamedata/resources.tdf or gamedata/resources.lua.<br />
<br />
You can use [[CEG_Operators]] to define floats that are not fixed.<br />
<br />
=== Units ===<br />
<br />
All distances are in elmos; all time is in frames.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG-Classes&diff=3763CEG-Classes2008-12-31T20:53:45Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/<br />
<br />
https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/Unsynced/<br />
<br />
== Common Properties ==<br />
All classes have the following properties, although not all of them use them:<br />
<br />
*pos (float3): The initial position of the spawner.<br />
*useAirLos (bool): Whether the spawner uses air LoS to determine if it is visible. This may allow the spawner to be seen from a further distance than normal.<br />
*alwaysVisible (bool): If true, the spawner is always visible, ignoring LoS.<br />
*speed (float3): The initial speed of the spawner.<br />
<br />
== CExpGenSpawner ==<br />
This is the closest thing CEG has to a function call. Instead of creating a graphical effect on its own, it creates another ceg.<br />
<br />
Properties:<br />
<br />
*delay (int): How long to wait before spawning the CEG.<br />
*dir (float3): The CEG will be called with this direction.<br />
*damage (float): The CEG will be called with this damage. The CEG doesn't actually deal any damage, but you can use this as a parameter and read it using the 'd' operator.<br />
*explosionGenerator (string): The name of the CEG you want to spawn.<br />
<br />
Suggested Use: <br />
*If you use a spawner a lot of times, you may want to make it a separate CEG to avoid having to copy-paste many times.<br />
*This is the only way to truly delay a graphical effect.<br />
*The spawned CEG still checks conditions, so if you want to, say, spawn an effect only if it is in water ''and'' doesn't hit a unit, you can give the CExpGenSpawner <code>nounit = 1;</code> and the spawned <code>CEG water = 1;</code>.<br />
*This allows you to give a set of spawners the same (and possibly random) direction.<br />
<br />
== CBitmapMuzzleFlame ==<br />
This creates three rectangular textures at right angles to each other. The <code>frontTexture</code> has <code>dir</code> as its normal.<br />
<br />
Properties: <br />
*sideTexture (string)<br />
*frontTexture (string)<br />
*dir (float3)<br />
*colorMap (string)<br />
*size (float)<br />
*length (float)<br />
*sizeGrowth (float)<br />
*ttl (int)<br />
*frontOffset (float)<br />
<br />
Suggested Use:<br />
*Muzzle flames, obviously.<br />
*You can use an upward-pointing CBitmapMuzzleFlame as a simple splash of water or dirt.<br />
*Railgun trails.<br />
<br />
<br />
== CExploSpikeProjectile ==<br />
<br />
*length (float)<br />
*width (float)<br />
*alpha (float)<br />
*alphaDecay (float)<br />
*lengthGrowth (float)<br />
*dir (float3)<br />
*color (float3)<br />
<br />
Suggested Use:<br />
*Anything glowy.<br />
*For large, slow missiles, you can try using this as an extended engine flame. Set the width to something fairly large.<br />
<br />
== CHeatCloudProjectile ==<br />
<br />
*heat (float)<br />
*maxheat (float)<br />
*heatFalloff (float)<br />
*size (float)<br />
*sizeGrowth (float)<br />
*sizemod (float)<br />
*sizemodmod (float)<br />
*texture (string)<br />
<br />
Suggested Use:<br />
*As the main background to an explosion.<br />
<br />
== CSimpleParticleSystem ==<br />
<br />
*emitVector (float3)<br />
*emitMul (float3)<br />
*gravity (float3)<br />
*colorMap (string)<br />
*texture (string)<br />
*airdrag (float)<br />
*particleLife (float)<br />
*particleLifeSpread (float)<br />
*numParticles (int)<br />
*particleSpeed (float)<br />
*particleSpeedSpread (float)<br />
*particleSize (float)<br />
*particleSizeSpread (float)<br />
*emitRot (float)<br />
*emitRotSpread (float)<br />
*directional (bool)<br />
*sizeGrowth (float)<br />
*sizeMod (float)<br />
<br />
Suggested Use:<br />
*This is probably the most versatile class.<br />
*Anything moving.<br />
<br />
== CSpherePartSpawner ==<br />
<br />
Draws an expanding sphere.<br />
<br />
Properties:<br />
*alpha (float)<br />
*ttl (int)<br />
*expansionSpeed (float)<br />
*color (float3)<br />
<br />
Suggested Use:<br />
*Looks like a shockwave.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG-Classes&diff=3762CEG-Classes2008-12-31T20:49:43Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/<br />
<br />
https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/Unsynced/<br />
<br />
== Common Properties ==<br />
All classes have the following properties, although not all of them use them:<br />
<br />
*pos (float3): The initial position of the spawner.<br />
*useAirLos (bool): Whether the spawner uses air LoS to determine if it is visible. This may allow the spawner to be seen from a further distance than normal.<br />
*alwaysVisible (bool): If true, the spawner is always visible, ignoring LoS.<br />
*speed (float3): The initial speed of the spawner.<br />
<br />
== CExpGenSpawner ==<br />
This is the closest thing CEG has to a function call. Instead of creating a graphical effect on its own, it creates another ceg.<br />
<br />
Properties:<br />
<br />
*delay (int): How long to wait before spawning the CEG.<br />
*dir (float3): The CEG will be called with this direction.<br />
*damage (float): The CEG will be called with this damage. The CEG doesn't actually deal any damage, but you can use this as a parameter and read it using the 'd' operator.<br />
*explosionGenerator (string): The name of the CEG you want to spawn.<br />
<br />
Suggested Use: <br />
*If you use a spawner a lot of times, you may want to make it a separate CEG to avoid having to copy-paste many times.<br />
*This is the only way to truly delay a graphical effect.<br />
*The spawned CEG still checks conditions, so if you want to, say, spawn an effect only if it is in water ''and'' doesn't hit a unit, you can give the CExpGenSpawner <code>nounit = 1;</code> and the spawned <code>CEG water = 1;</code>.<br />
*This allows you to give a set of spawners the same (and possibly random) direction.<br />
<br />
== CBitmapMuzzleFlame ==<br />
This creates three rectangular textures at right angles to each other. The <code>frontTexture</code> has <code>dir</code> as its normal.<br />
<br />
Properties: <br />
*sideTexture (string)<br />
*frontTexture (string)<br />
*dir (float3)<br />
*colorMap (string)<br />
*size (float)<br />
*length (float)<br />
*sizeGrowth (float)<br />
*ttl (int)<br />
*frontOffset (float)<br />
<br />
Suggested Use:<br />
*Muzzle flames, obviously.<br />
*You can use an upward-pointing CBitmapMuzzleFlame as a simple splash of water or dirt.<br />
*Railgun trails.<br />
<br />
<br />
== CExploSpikeProjectile ==<br />
<br />
*length<br />
*width<br />
*alpha<br />
*alphaDecay<br />
*lengthGrowth<br />
*dir<br />
*color<br />
<br />
Suggested Use:<br />
*Anything glowy.<br />
*For large, slow missiles, you can try using this as an extended engine flame. Set the width to something fairly large.<br />
<br />
== CHeatCloudProjectile ==<br />
<br />
*heat<br />
*maxheat<br />
*heatFalloff<br />
*size<br />
*sizeGrowth<br />
*sizemod<br />
*sizemodmod<br />
*texture<br />
<br />
Suggested Use:<br />
*As the main background to an explosion.<br />
<br />
== CSimpleParticleSystem ==<br />
<br />
*emitVector<br />
*emitMul<br />
*gravity<br />
*colorMap<br />
*texture<br />
*airdrag<br />
*particleLife<br />
*particleLifeSpread<br />
*numParticles<br />
*particleSpeed<br />
*particleSpeedSpread<br />
*particleSize<br />
*particleSizeSpread<br />
*emitRot<br />
*emitRotSpread<br />
*directional<br />
*sizeGrowth<br />
*sizeMod<br />
<br />
Suggested Use:<br />
*This is probably the most versatile class.<br />
*Anything moving.<br />
<br />
== CSpherePartSpawner ==<br />
<br />
Draws an expanding sphere.<br />
<br />
Properties:<br />
*alpha (float in [0, 1])<br />
*ttl (int)<br />
*expansionSpeed (float)<br />
*color (float3)<br />
<br />
Suggested Use:<br />
*Looks like a shockwave.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG-Classes&diff=3761CEG-Classes2008-12-30T08:34:31Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/<br />
<br />
https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/Unsynced/<br />
<br />
== Common Properties ==<br />
All classes have the following properties, although not all of them use them:<br />
<br />
*pos (float3): The initial position of the spawner.<br />
*useAirLos (bool): Whether the spawner uses air LoS to determine if it is visible. This may allow the spawner to be seen from a further distance than normal.<br />
*alwaysVisible (bool): If true, the spawner is always visible, ignoring LoS.<br />
*speed (float3): The initial speed of the spawner.<br />
<br />
== CExpGenSpawner ==<br />
This is the closest thing CEG has to a function call. Instead of creating a graphical effect on its own, it creates another ceg.<br />
<br />
Properties:<br />
<br />
*delay (int): How long to wait before spawning the CEG.<br />
*dir (float3): The CEG will be called with this direction.<br />
*damage (float): The CEG will be called with this damage. The CEG doesn't actually deal any damage, but you can use this as a parameter and read it using the 'd' operator.<br />
*explosionGenerator (string): The name of the CEG you want to spawn.<br />
<br />
Suggested Use: <br />
*If you use a spawner a lot of times, you may want to make it a separate CEG to avoid having to copy-paste many times.<br />
*This is the only way to truly delay a graphical effect.<br />
*The spawned CEG still checks conditions, so if you want to, say, spawn an effect only if it is in water ''and'' doesn't hit a unit, you can give the CExpGenSpawner <code>nounit = 1;</code> and the spawned <code>CEG water = 1;</code>.<br />
*This allows you to give a set of spawners the same (and possibly random) direction.<br />
<br />
== CBitmapMuzzleFlame ==<br />
This creates three rectangular textures at right angles to each other. The <code>frontTexture</code> has <code>dir</code> as its normal.<br />
<br />
Properties: <br />
*sideTexture (string)<br />
*frontTexture (string)<br />
*dir (float3)<br />
*colorMap (string)<br />
*size (float)<br />
*length (float)<br />
*sizeGrowth (float)<br />
*ttl (int)<br />
*frontOffset (float)<br />
<br />
Suggested Use:<br />
*Muzzle flames, obviously.<br />
*You can use an upward-pointing CBitmapMuzzleFlame as a simple splash of water or dirt.<br />
*Railgun trails.<br />
<br />
<br />
== CExploSpikeProjectile ==<br />
<br />
Suggested Use:<br />
*Anything glowy.<br />
*For large, slow missiles, you can try using this as an extended engine flame. Set the width to something fairly large.<br />
<br />
== CHeatCloudProjectile ==<br />
<br />
Suggested Use:<br />
*As the main background to an explosion.<br />
<br />
== CSimpleParticleSystem ==<br />
<br />
Suggested Use:<br />
*Anything undergoing motion that is at all complex.<br />
<br />
== CSpherePartSpawner ==<br />
<br />
Draws an expanding sphere.<br />
<br />
Properties:<br />
*alpha (float in [0, 1])<br />
*ttl (int)<br />
*expansionSpeed (float)<br />
*color (float3)<br />
<br />
Suggested Use:<br />
*Looks like a shockwave.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG-Classes&diff=3760CEG-Classes2008-12-30T08:23:39Z<p>Evil4zerggin: </p>
<hr />
<div>== Common Properties ==<br />
All classes have the following properties, although not all of them use them:<br />
<br />
*pos (float3): The initial position of the spawner.<br />
*useAirLos (bool): Whether the spawner uses air LoS to determine if it is visible. This may allow the spawner to be seen from a further distance than normal.<br />
*alwaysVisible (bool): If true, the spawner is always visible, ignoring LoS.<br />
*speed (float3): The initial speed of the spawner.<br />
<br />
== CExpGenSpawner ==<br />
This is the closest thing CEG has to a function call. Instead of creating a graphical effect on its own, it creates another ceg.<br />
<br />
Properties:<br />
<br />
*delay (int): How long to wait before spawning the CEG.<br />
*dir (float3): The CEG will be called with this direction.<br />
*damage (float): The CEG will be called with this damage. The CEG doesn't actually deal any damage, but you can use this as a parameter and read it using the 'd' operator.<br />
*explosionGenerator (string): The name of the CEG you want to spawn.<br />
<br />
Suggested Use: <br />
*If you use a spawner a lot of times, you may want to make it a separate CEG to avoid having to copy-paste many times.<br />
*This is the only way to truly delay a graphical effect.<br />
*The spawned CEG still checks conditions, so if you want to, say, spawn an effect only if it is in water ''and'' doesn't hit a unit, you can give the CExpGenSpawner <code>nounit = 1;</code> and the spawned <code>CEG water = 1;</code>.<br />
*This allows you to give a set of spawners the same (and possibly random) direction.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG-Classes&diff=3759CEG-Classes2008-12-30T08:16:31Z<p>Evil4zerggin: New page: == Common Properties == All classes have the following properties, although not all of them use them: *pos (float3): The initial position of the spawner. *useAirLos (bool): Whether the sp...</p>
<hr />
<div>== Common Properties ==<br />
All classes have the following properties, although not all of them use them:<br />
<br />
*pos (float3): The initial position of the spawner.<br />
*useAirLos (bool): Whether the spawner uses air LoS to determine if it is visible. This may allow the spawner to be seen from a further distance than normal.<br />
*alwaysVisible (bool): If true, the spawner is always visible, ignoring LoS.<br />
*speed (float3): The initial speed of the spawner.<br />
<br />
== CExpGenSpawner ==</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG-Format&diff=3793CEG-Format2008-12-30T08:10:45Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles<br />
<br />
== Overall Format ==<br />
<br />
A CEG file contains one or more CEGs. Each CEG follows this format:<br />
<br />
<code><br />
[ceg_name] {<br />
useDefaultExplosions = 0;<br />
[spawner_name_0] {<br />
class=CClassName;<br />
[properties] {<br />
property0 = value0;<br />
property1 = value1;<br />
//and so on...<br />
}<br />
condition0 = 1;<br />
condition1 = 0;<br />
count = 1;<br />
}<br />
<br />
[spawner_name_1] {<br />
//each spawner follows that format<br />
}<br />
<br />
[groundflash] {<br />
//groundflash is a special name; it always generates a groundflash<br />
flashsize=16;<br />
flashalpha=1;<br />
circlegrowth=1;<br />
circlealpha=0;<br />
ttl=8;<br />
color=1,1,1;<br />
}<br />
}<br />
</code><br />
<br />
=== useDefaultExplosions ===<br />
If this is set, the CEG will use the default explosion (based on damage and area of effect) in addition to any spawners you define.<br />
<br />
=== Spawners ===<br />
A CEG can contain any number of spawners. The name of the spawners don't really matter, as long as it's not "groundflash", which has a special meaning. You can think of each spawner as being one component of the overall explosion.<br />
<br />
==== Class ====<br />
Each spawner has a class that determines what kind of graphical effect it creates. Spring has a number of standard classes that you can choose from. See [[CEG_Classes]] for details.<br />
<br />
==== Properties ====<br />
Depending on what class a spawner is, it will have a set of properties that allow you to fine-tune what the spawner displays. Again, see [[CEG_Classes]] for details.<br />
<br />
==== Conditions ====<br />
These determine under what conditions the spawner will run. The available conditions are "air" (at least 20 elmos above ground/sea level), "water", "ground", "unit" (hits a unit), and "nounit" (doesn't hit a unit). There is an "underwater" condition, but it doesn't actually work at time of writing. If you set the condition to true (e.g., "water = 1;"), the spawner will run if the explosion takes place under that condition. If you set more than one condition, the spawner will run if ''any'' of them are true. If you want a spawner to run only if two or more conditions are ''all'' true, you have to do a little trick with the CExpGenSpawner class.<br />
<br />
==== Count ====<br />
The count determines the number of times the spawner will run.<br />
<br />
=== groundflash ===<br />
If you name a spawner "groundflash," it will always generate a groundflash. A groundflash has the following properties:<br />
<br />
*flashsize (float): The radius of the groundflash.<br />
*flashalpha (float in [0, 1]): How transparent the groundflash is. Generally, the higher, the brighter.<br />
*circlegrowth (float): A groundflash can have an additional circle that expands outwards. This controls how fast the circle grows.<br />
*circlealpha (float in [0, 1]): How transparent the circle is.<br />
*ttl (int): How long the groundflash lasts.<br />
*color (float3): The color of the groundflash.<br />
<br />
Suggested Use: A short groundflash (~8 frames) is good for any explosion that gives off light. You can also use a longer groundflash to suggest the ground is glowing from heat.<br />
<br />
=== Data Types ===<br />
CEGs use the following data types:<br />
<br />
*float: Most properties are floats.<br />
*int: Used for counts and ttls.<br />
*bool: Use for conditions, and some properties.<br />
*float3: Used for vectors and colors. The components are floats, separated by commas. You can also use the keyword <code>dir</code>, which represents the direction fed to the CEG.<br />
*string: Used for colormaps and texture names.<br />
<br />
You can use [[CEG_Operators]] to define floats that are not fixed.<br />
<br />
=== Units ===<br />
<br />
All distances are in elmos; all time is in frames.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG:Calls&diff=3846CEG:Calls2008-12-30T08:09:41Z<p>Evil4zerggin: </p>
<hr />
<div>== Overview ==<br />
There are three places where you can call a CEG: weapons, COB, and Lua.<br />
<br />
== Weapon CEGs ==<br />
<br />
There are three weapon tags that can spawn CEGs:<br />
<br />
*cegtag: Spawns the CEG every frame at the weapon projectile's position and direction.<br />
*explosionGenerator: Spawns the CEG when the weapon hits its target.<br />
*bounceExplosionGenerator: For bouncing weapons only. Spawns the CEG when the weapon bounces.<br />
<br />
You need to set these tags equal to custom:ExplosionGeneratorName. For example, in a .tdf,<br />
<code>explosionGenerator=custom:ExplosionGeneratorName;</code><br />
<br />
== COB CEGs ==<br />
<br />
Calling a CEG from COB requires two steps. First, in the unit's definition, you need to put<br />
<br />
<code><br />
[sfxtypes] {<br />
explosiongenerator0 = custom:ExplosionGeneratorName0;<br />
explosiongenerator1 = custom:ExplosionGeneratorName1;<br />
//and so on...<br />
}<br />
</code><br />
<br />
for a .fbi, or<br />
<br />
<code><br />
sfxtypes = {<br />
explosiongenerators = {<br />
"custom:ExplosionGeneratorName0",<br />
"custom:ExplosionGeneratorName1",<br />
--and so on...<br />
},<br />
},<br />
</code><br />
<br />
To actually generate the explosion, you need to <code>emit-sfx</code> 1024 plus the number of the explosion generator in the unit definition (the first one is 0, the next is 1, and so on). The CEG will have the position and direction of the piece you emit it from.<br />
<br />
== Lua CEGs ==<br />
See [[Lua_SyncedCtrl]].</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG:Calls&diff=3845CEG:Calls2008-12-30T08:08:36Z<p>Evil4zerggin: New page: == Overview == There are three places where you can call a CEG: weapons, COB, and Lua. == Weapon CEGs == There are three weapon tags that can spawn CEGs: *cegtag: Spawns the CEG every f...</p>
<hr />
<div>== Overview ==<br />
There are three places where you can call a CEG: weapons, COB, and Lua.<br />
<br />
== Weapon CEGs ==<br />
<br />
There are three weapon tags that can spawn CEGs:<br />
<br />
*cegtag: Spawns the CEG every frame at the weapon projectile's position and direction.<br />
*explosionGenerator: Spawns the CEG when the weapon hits its target.<br />
*bounceExplosionGenerator: For bouncing weapons only. Spawns the CEG when the weapon bounces.<br />
<br />
You need to set these tags equal to custom:ExplosionGeneratorName. For example, in a .tdf,<br />
<code>explosionGenerator=custom:ExplosionGeneratorName;</code><br />
<br />
== COB CEGs ==<br />
<br />
Calling a CEG from COB requires two steps. First, in the unit's definition, you need to put<br />
<br />
<code><br />
[sfxtypes] {<br />
explosiongenerator0 = custom:ExplosionGeneratorName0;<br />
explosiongenerator1 = custom:ExplosionGeneratorName1;<br />
//and so on...<br />
}<br />
</code><br />
<br />
for a .fbi, or<br />
<br />
<code><br />
sfxtypes = {<br />
explosiongenerators = {<br />
"custom:ExplosionGeneratorName0",<br />
"custom:ExplosionGeneratorName1",<br />
--and so on...<br />
},<br />
},<br />
</code><br />
<br />
To actually generate the explosion, you need to <code>emit-sfx</code> 1024 plus the number of the explosion generator in the unit definition (the first one is 0, the next is 1, and so on). The CEG will have the position and direction of the piece you emit it from.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG-Format&diff=3792CEG-Format2008-12-30T08:00:59Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles<br />
<br />
== Overall Format ==<br />
<br />
A CEG file contains one or more CEGs. Each CEG follows this format:<br />
<br />
<code><br />
[ceg_name] {<br />
useDefaultExplosions = 0;<br />
[spawner_name_0] {<br />
class=CClassName;<br />
[properties] {<br />
property0 = value0;<br />
property1 = value1;<br />
//and so on...<br />
}<br />
condition0 = 1;<br />
condition1 = 0;<br />
count = 1;<br />
}<br />
<br />
[spawner_name_1] {<br />
//each spawner follows that format<br />
}<br />
<br />
[groundflash] {<br />
//groundflash is a special name; it always generates a groundflash<br />
flashsize=16;<br />
flashalpha=1;<br />
circlegrowth=1;<br />
circlealpha=0;<br />
ttl=8;<br />
color=1,1,1;<br />
}<br />
}<br />
</code><br />
<br />
=== useDefaultExplosions ===<br />
If this is set, the CEG will use the default explosion (based on damage and area of effect) in addition to any spawners you define.<br />
<br />
=== Spawners ===<br />
A CEG can contain any number of spawners. The name of the spawners don't really matter, as long as it's not "groundflash", which has a special meaning. You can think of each spawner as being one component of the overall explosion.<br />
<br />
==== Class ====<br />
Each spawner has a class that determines what kind of graphical effect it creates. Spring has a number of standard classes that you can choose from. See [[CEG_Classes]] for details.<br />
<br />
==== Properties ====<br />
Depending on what class a spawner is, it will have a set of properties that allow you to fine-tune what the spawner displays. Again, see [[CEG_Classes]] for details.<br />
<br />
==== Conditions ====<br />
These determine under what conditions the spawner will run. The available conditions are "air" (at least 20 elmos above ground/sea level), "water", "ground", "unit" (hits a unit), and "nounit" (doesn't hit a unit). There is an "underwater" condition, but it doesn't actually work at time of writing. If you set the condition to true (e.g., "water = 1;"), the spawner will run if the explosion takes place under that condition. If you set more than one condition, the spawner will run if any of them are true. If you want a spawner to run only if two or more conditions are ''all'' true, you have to do a little trick with the CExpGenSpawner class.<br />
<br />
==== Count ====<br />
The count determines the number of times the spawner will run.<br />
<br />
=== groundflash ===<br />
If you name a spawner "groundflash," it will always generate a groundflash. A groundflash has the following properties:<br />
<br />
*flashsize (float): The radius of the groundflash.<br />
*flashalpha (float in [0, 1]): How transparent the groundflash is. Generally, the higher, the brighter.<br />
*circlegrowth (float): A groundflash can have an additional circle that expands outwards. This controls how fast the circle grows.<br />
*circlealpha (float in [0, 1]): How transparent the circle is.<br />
*ttl (int): How long the groundflash lasts.<br />
*color (float3): The color of the groundflash.<br />
<br />
Suggested Use: A short groundflash (~8 frames) is good for any explosion that gives off light. You can also use a longer groundflash to suggest the ground is glowing from heat.<br />
<br />
=== Data Types ===<br />
CEGs use the following data types:<br />
<br />
*float: Most properties are floats.<br />
*int: Used for counts and ttls.<br />
*bool: Use for conditions, and some properties.<br />
*float3: Used for vectors and colors. The components are floats, separated by commas. You can also use the keyword <code>dir</code>, which represents the direction fed to the CEG.<br />
*string: Used for colormaps and texture names.<br />
<br />
You can use [[CEG_Operators]] to define floats that are not fixed.<br />
<br />
=== Units ===<br />
<br />
All distances are in elmos; all time is in frames.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG:Main&diff=3893CEG:Main2008-12-30T07:58:43Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles<br />
<br />
== Introduction ==<br />
CEG stands for Custom Explosion Generator, a scripting language for creating graphical effects. These are most commonly used to draw a graphical effect when a weapon hits a target, but can also be called from COB and Lua .<br />
<br />
== Files Needed ==<br />
The actual CEGs are defined in .tdf or .lua files in gamedata/explosions/. You will also need a resources.tdf or .lua in gamedata/ to define textures, as well as the actual textures in bitmaps/. Finally, you need the weapon, unit, COB, and or Lua files that you are calling the CEGs from.<br />
<br />
== What Can Call a CEG? ==<br />
*A weapon, through cegtag, explosiongenerator, bounceexplosiongenerator.<br />
*A COB script, though emit-sfx 1024 + X.<br />
*A Lua script, through Spring.SpawnCEG.<br />
<br />
See [[CEG_Calls]] for details.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG:Main&diff=3892CEG:Main2008-12-30T07:57:19Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles<br />
<br />
== Introduction ==<br />
CEG stands for Custom Explosion Generator, a scripting language for creating graphical effects. These are most commonly used to draw a graphical effect when a weapon hits a target, but can also be called from COB and Lua .<br />
<br />
== Files Needed ==<br />
The actual CEGs are defined in .tdf or .lua files in gamedata/explosions/. You will also need a resources.tdf or .lua in gamedata/ to define textures, as well as the actual textures in bitmaps/. Finally, you need the weapon, unit, COB, and or Lua files that you are calling the CEGs from.<br />
<br />
== What Can Call a CEG? ==<br />
*A weapon, through cegtag or explosiongenerator.<br />
*A COB script, though emit-sfx 1024 + X.<br />
*A Lua script, through Spring.SpawnCEG.<br />
<br />
See [[CEG_Calls]] for details.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG-Format&diff=3791CEG-Format2008-12-30T07:56:28Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles<br />
<br />
== Overall Format ==<br />
<br />
A CEG file contains one or more CEGs. Each CEG follows this format:<br />
<br />
<pre><br />
[ceg_name] {<br />
useDefaultExplosions = 0;<br />
[spawner_name_0] {<br />
class=CClassName;<br />
[properties] {<br />
property0 = value0;<br />
property1 = value1;<br />
//and so on...<br />
}<br />
condition0 = 1;<br />
condition1 = 0;<br />
count = 1;<br />
}<br />
<br />
[spawner_name_1] {<br />
//each spawner follows that format<br />
}<br />
<br />
[groundflash] {<br />
//groundflash is a special name; it always generates a groundflash<br />
flashsize=16;<br />
flashalpha=1;<br />
circlegrowth=1;<br />
circlealpha=0;<br />
ttl=8;<br />
color=1,1,1;<br />
}<br />
}<br />
</pre><br />
<br />
=== useDefaultExplosions ===<br />
If this is set, the CEG will use the default explosion (based on damage and area of effect) in addition to any spawners you define.<br />
<br />
=== Spawners ===<br />
A CEG can contain any number of spawners. The name of the spawners don't really matter, as long as it's not "groundflash", which has a special meaning. You can think of each spawner as being one component of the overall explosion.<br />
<br />
==== Class ====<br />
Each spawner has a class that determines what kind of graphical effect it creates. Spring has a number of standard classes that you can choose from. See [[CEG_Classes]] for details.<br />
<br />
==== Properties ====<br />
Depending on what class a spawner is, it will have a set of properties that allow you to fine-tune what the spawner displays. Again, see [[CEG_Classes]] for details.<br />
<br />
==== Conditions ====<br />
These determine under what conditions the spawner will run. The available conditions are "air" (at least 20 elmos above ground/sea level), "water", "ground", "unit" (hits a unit), and "nounit" (doesn't hit a unit). There is an "underwater" condition, but it doesn't actually work at time of writing. If you set the condition to true (e.g., "water = 1;"), the spawner will run if the explosion takes place under that condition. If you set more than one condition, the spawner will run if any of them are true. If you want a spawner to run only if two or more conditions are ''all'' true, you have to do a little trick with the CExpGenSpawner class.<br />
<br />
==== Count ====<br />
The count determines the number of times the spawner will run.<br />
<br />
=== groundflash ===<br />
If you name a spawner "groundflash," it will always generate a groundflash. A groundflash has the following properties:<br />
<br />
*flashsize (float): The radius of the groundflash.<br />
*flashalpha (float in [0, 1]): How transparent the groundflash is. Generally, the higher, the brighter.<br />
*circlegrowth (float): A groundflash can have an additional circle that expands outwards. This controls how fast the circle grows.<br />
*circlealpha (float in [0, 1]): How transparent the circle is.<br />
*ttl (int): How long the groundflash lasts.<br />
*color (float3): The color of the groundflash.<br />
<br />
Suggested Use: A short groundflash (~8 frames) is good for any explosion that gives off light. You can also use a longer groundflash to suggest the ground is glowing from heat.<br />
<br />
=== Data Types ===<br />
CEGs use the following data types:<br />
<br />
*float: Most properties are floats.<br />
*int: Used for counts and ttls.<br />
*bool: Use for conditions, and some properties.<br />
*float3: Used for vectors and colors. The components are floats, separated by commas.<br />
*string: Used for colormaps and texture names.<br />
<br />
You can use [[CEG_Operators]] to define floats that are not fixed.<br />
<br />
=== Units ===<br />
<br />
All distances are in elmos; all time is in frames.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG-Format&diff=3790CEG-Format2008-12-30T07:56:03Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles<br />
<br />
== Overall Format ==<br />
<br />
A CEG file contains one or more CEGs. Each CEG follows this format:<br />
<br />
<pre><br />
[ceg_name] {<br />
useDefaultExplosions = 0;<br />
[spawner_name_0] {<br />
class=CClassName;<br />
[properties] {<br />
property0 = value0;<br />
property1 = value1;<br />
//and so on...<br />
}<br />
condition0 = 1;<br />
condition1 = 0;<br />
count = 1;<br />
}<br />
<br />
[spawner_name_1] {<br />
//each spawner follows that format<br />
}<br />
<br />
[groundflash] {<br />
//groundflash is a special name; it always generates a groundflash<br />
flashsize=16;<br />
flashalpha=1;<br />
circlegrowth=1;<br />
circlealpha=0;<br />
ttl=8;<br />
color=1,1,1;<br />
}<br />
}<br />
</pre><br />
<br />
=== useDefaultExplosions ===<br />
If this is set, the CEG will use the default explosion (based on damage and area of effect) in addition to any spawners you define.<br />
<br />
=== Spawners ===<br />
A CEG can contain any number of spawners. The name of the spawners don't really matter, as long as it's not "groundflash", which has a special meaning. You can think of each spawner as being one component of the overall explosion.<br />
<br />
==== Class ====<br />
Each spawner has a class that determines what kind of graphical effect it creates. Spring has a number of standard classes that you can choose from. See [[CEG_Classes]] for details.<br />
<br />
==== Properties ====<br />
Depending on what class a spawner is, it will have a set of properties that allow you to fine-tune what the spawner displays. Again, see [[CEG_Classes]] for details.<br />
<br />
==== Conditions ====<br />
These determine under what conditions the spawner will run. The available conditions are "air" (at least 20 elmos above ground/sea level), "water", "ground", "unit" (hits a unit), and "nounit" (doesn't hit a unit). There is an "underwater" condition, but it doesn't actually work at time of writing. If you set the condition to true (e.g., "water = 1;"), the spawner will run if the explosion takes place under that condition. If you set more than one condition, the spawner will run if any of them are true. If you want a spawner to run only if two or more conditions are ''all'' true, you have to do a little trick with the CExpGenSpawner class.<br />
<br />
==== Count ====<br />
The count determines the number of times the spawner will run.<br />
<br />
=== groundflash ===<br />
If you name a spawner "groundflash," it will always generate a groundflash. A groundflash has the following properties:<br />
<br />
*flashsize (float): The radius of the groundflash.<br />
*flashalpha (float in [0, 1]): How transparent the groundflash is. Generally, the higher, the brighter.<br />
*circlegrowth (float): A groundflash can have an additional circle that expands outwards. This controls how fast the circle grows.<br />
*circlealpha (float in [0, 1]): How transparent the circle is.<br />
*ttl (int): How long the groundflash lasts.<br />
*color (float3): The color of the groundflash.<br />
<br />
Good for: A short groundflash (~8 frames) is good for any explosion that gives off light. You can also use a longer groundflash to suggest the ground is glowing from heat.<br />
<br />
=== Data Types ===<br />
CEGs use the following data types:<br />
<br />
*float: Most properties are floats.<br />
*int: Used for counts and ttls.<br />
*bool: Use for conditions, and some properties.<br />
*float3: Used for vectors and colors. The components are floats, separated by commas.<br />
*string: Used for colormaps and texture names.<br />
<br />
You can use [[CEG_Operators]] to define floats that are not fixed.<br />
<br />
=== Units ===<br />
<br />
All distances are in elmos; all time is in frames.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG-Format&diff=3789CEG-Format2008-12-30T07:54:40Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles<br />
<br />
== Overall Format ==<br />
<br />
A CEG file contains one or more CEGs. Each CEG follows this format:<br />
<br />
<pre><br />
[ceg_name] {<br />
useDefaultExplosions = 0;<br />
[spawner_name_0] {<br />
class=CClassName;<br />
[properties] {<br />
property0 = value0;<br />
property1 = value1;<br />
//and so on...<br />
}<br />
condition0 = 1;<br />
condition1 = 0;<br />
count = 1;<br />
}<br />
<br />
[spawner_name_1] {<br />
//each spawner follows that format<br />
}<br />
<br />
[groundflash] {<br />
//groundflash is a special name; it always generates a groundflash<br />
flashsize=16;<br />
flashalpha=1;<br />
circlegrowth=1;<br />
circlealpha=0;<br />
ttl=8;<br />
color=1,1,1;<br />
}<br />
}<br />
</pre><br />
<br />
=== useDefaultExplosions ===<br />
If this is set, the CEG will use the default explosion (based on damage and area of effect) in addition to any spawners you define.<br />
<br />
=== Spawners ===<br />
A CEG can contain any number of spawners. The name of the spawners don't really matter, as long as it's not "groundflash", which has a special meaning. You can think of each spawner as being one component of the overall explosion.<br />
<br />
==== Class ====<br />
Each spawner has a class that determines what kind of graphical effect it creates. Spring has a number of standard classes that you can choose from. See [[CEG_Classes]] for details.<br />
<br />
==== Properties ====<br />
Depending on what class a spawner is, it will have a set of properties that allow you to fine-tune what the spawner displays. Again, see [[CEG_Classes]] for details.<br />
<br />
==== Conditions ====<br />
These determine under what conditions the spawner will run. The available conditions are "air" (at least 20 elmos above ground/sea level), "water", "ground", "unit" (hits a unit), and "nounit" (doesn't hit a unit). There is an "underwater" condition, but it doesn't actually work at time of writing. If you set the condition to true (e.g., "water = 1;"), the spawner will run if the explosion takes place under that condition. If you set more than one condition, the spawner will run if any of them are true. If you want a spawner to run only if two or more conditions are ''all'' true, you have to do a little trick with the CExpGenSpawner class.<br />
<br />
==== Count ====<br />
The count determines the number of times the spawner will run.<br />
<br />
=== groundflash ===<br />
If you name a spawner "groundflash," it will always generate a groundflash. A groundflash has the following properties:<br />
<br />
*flashsize (float): The radius of the groundflash.<br />
*flashalpha (float in [0, 1]): How transparent the groundflash is. Generally, the higher, the brighter.<br />
*circlegrowth (float): A groundflash can have an additional circle that expands outwards. This controls how fast the circle grows.<br />
*circlealpha (float in [0, 1]): How transparent the circle is.<br />
*ttl (int): How long the groundflash lasts.<br />
*color (float3): The color of the groundflash.<br />
<br />
=== Data Types ===<br />
CEGs use the following data types:<br />
<br />
*float: Most properties are floats.<br />
*int: Used for counts and ttls.<br />
*bool: Use for conditions, and some properties.<br />
*float3: Used for vectors and colors. The components are floats, separated by commas.<br />
*string: Used for colormaps and texture names.<br />
<br />
You can use [[CEG_Operators]] to define floats that are not fixed.<br />
<br />
=== Units ===<br />
<br />
All distances are in elmos; all time is in frames.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=Game_and_Unit_development&diff=7961Game and Unit development2008-12-30T07:47:25Z<p>Evil4zerggin: </p>
<hr />
<div>=Mod development=<br />
Mods, next to Maps, is the content used in Spring.<br><br />
A mod is simply a combined file containing a small structure of files and directories holding all the data required.<br><br />
<br />
[[Mod_Development | Mod Development]] wiki is a starting page, linking to very useful information on the files included in a mod, their hierarchy and more.<br />
<br><br />
<br />
Almost the entire mod developing is the creation of units. Which isn't an easy job.<br><br />
Information about the creation of units are everywere, but not combined.<br><br />
This is a gathered list of all Tutorials and helpfull forums threads I could find:<br><br />
<br />
==General==<br />
*[[Mod Development]]<br />
*[[Mod specification]]<br><br />
*[http://spring.clan-sy.com/phpbb/viewtopic.php?t=6015 What do I need to create a mod]<br />
*[[Simple Mod Tutorial]]<br />
*[[Freely available and reusable content|Freely available and reusable content/games/mods]]<br />
<br />
==Unit Development==<br />
====Automated Mod Creation====<br />
* [[TA2Spring]] - Automatically adds and converts Total Annihilation unit packs (.ufo files, etc..) into Spring mods (requires a base modification for the game rules, XTA is recommended)<br />
====Models - s3o Files====<br />
*[http://user.supradigital.org/jcnossen/UpspringInstaller-1.54-EulerAngles.exe UpSpring, our second-gen import / export / rigging / animation tool.]<br />
* [http://lassie.student.utwente.nl/vliet/springtut.pdf Maestro's tutorial of Upspring and textures].<br />
* [[Basic s3o unit making guide]]<br />
* [[Simple Mod Tutorial]]<br />
* [[Units:CreateModel|UV Mapping in Wings3D]]<br />
* [http://spring.clan-sy.com/phpbb/viewtopic.php?t=10612 Wings UV Mapping Tutorial]<br />
* [http://spring.clan-sy.com/phpbb/viewtopic.php?f=9&t=12354 Saving polygons in Wings3d Tutorial]<br />
* [http://spring.clan-sy.com/phpbb/viewtopic.php?t=10947 Greeble Tutorial 1]<br />
* [http://spring.clan-sy.com/phpbb/viewtopic.php?f=9&t=12356 Greeble Tutorial 2]<br />
* [http://spring.clan-sy.com/phpbb/viewtopic.php?p=75495 various things about unit making. (Also contains an illustrated alpha-channel tut)]<br />
* [http://spring.clan-sy.com/phpbb/viewtopic.php?t=10503 Runecrafter's 3DS Max UV Mapping Tutorial]<br />
* [http://spring.clan-sy.com/phpbb/viewtopic.php?f=9&t=15106 Argh's UpSpring Easy Workflow Guide]<br />
* [[Trouble-shooting s3o units]]<br />
<br />
====Models - 3do Files====<br />
outdated model format used by OTA<br><br />
(Note: UpSpring has some problems with empty objects and groundplates)<br />
*use [http://spring.clan-sy.com/phpbb/viewtopic.php?f=12&t=7208&p=126129&hilit=upspring#p126129 UpSpring] and [http://www.fileuniverse.com/?p=show&a=it&id=305 3doBuilder] to edit those files<br />
<br />
====Scripting and Animation - COB/BOS Files====<br />
*[[Units0:.bos ]] some examples<br />
*[[COB_Overview]]<br />
*[[COB_Animation]]<br />
*[[COB_Callins]]<br />
*[[COB_Constants]]<br />
*[[COB_Threads]]<br />
*[[COB_HitByWeaponID]]<br />
*[http://www.planetannihilation.com/tadc/tut_unit_01_1.asp PlanetAnnihilation] has a nice tutorial<br />
*[[Units:LuaCOB]] - how to interface COB with LUA<br />
*[[CEG_For_Units|Mod Development:Calling basic CEGs from COB]]<br />
* [http://spring.clan-sy.com/phpbb/viewtopic.php?p=132943#132943 GPL-compliant sourcecode, scripting code examples, and other things.]<br />
<br />
====Units - FBI Files====<br />
*[[Units:FBI]]<br />
*[[All_FBI-variable_values:_min,_max,_default,_type|Units:FBI (variable datatype list)]]<br />
*[[Unit_Categories]]<br />
<br />
====Weapons - TDF Files====<br />
*[[Weapon Variables]] : This is the most up to date<br />
*[[Units:WeaponMainDir]]<br />
*[[Units:Weapons]] : Various informations about the weapontypes (uncompleted)<br />
*[[All_Weapons_variable_values:_min%2C_max%2C_default%2C_type|Weapon datatype list]] : All weapon variables min/max/default values and datatypes listed.<br />
*[[Weapons:Antinukes]]: All about antinukes.<br />
<br />
====Explosions====<br />
*[[CEG_Overview]]<br />
*[[CEG_Calls]]<br />
*[[CEG_Format]]<br />
*[[CEG_Classes]]<br />
*[[CEG_Operators]]<br />
*[[CustomExplosionGenerators|Old CEG page]]<br />
<br />
====Misc====<br />
*[[Units:Design]]<br />
*[[Units:Textures]]<br />
*[[Units:Buildpics]]<br />
*[[Units:SideData TDF]]<br />
*[[Units:Download TDF]] <br />
*[[Units:FlankingBonus]]<br />
*[[Mod Development:Armor]]<br />
*[[Mod Development:Cursors]]<br />
*[[Mod Development:Archives]]<br />
*[[Mod Development:Sidepics]]<br />
*[[CustomUnitIcons|Mod Development:Custom unit icons]]</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG-Format&diff=3788CEG-Format2008-12-30T07:46:58Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles<br />
<br />
== Overall Format ==<br />
<br />
A CEG file contains one or more CEGs. Each CEG follows this format:<br />
<br />
<pre><br />
[ceg_name] {<br />
useDefaultExplosions = 0;<br />
[spawner_name_0] {<br />
class=CClassName;<br />
[properties] {<br />
property0 = value0;<br />
property1 = value1;<br />
//and so on...<br />
}<br />
condition0 = 1;<br />
condition1 = 0;<br />
count = 1;<br />
}<br />
<br />
[spawner_name_1] {<br />
//each spawner follows that format<br />
}<br />
<br />
[groundflash] {<br />
//groundflash is a special name; it always generates a groundflash<br />
flashsize=16;<br />
flashalpha=1;<br />
circlegrowth=1;<br />
circlealpha=0;<br />
ttl=8;<br />
color=1,1,1;<br />
}<br />
}<br />
</pre><br />
<br />
=== useDefaultExplosions ===<br />
If this is set, the CEG will use the default explosion (based on damage and area of effect) in addition to any spawners you define.<br />
<br />
=== Spawners ===<br />
A CEG can contain any number of spawners. The name of the spawners don't really matter, as long as it's not "groundflash", which has a special meaning. You can think of each spawner as being one component of the overall explosion.<br />
<br />
==== Class ====<br />
Each spawner has a class that determines what kind of graphical effect it creates. Spring has a number of standard classes that you can choose from. See [[CEG_Classes]] for details.<br />
<br />
==== Properties ====<br />
Depending on what class a spawner is, it will have a set of properties that allow you to fine-tune what the spawner displays. Again, see [[CEG_Classes]] for details.<br />
<br />
==== Conditions ====<br />
These determine under what conditions the spawner will run. The available conditions are "air" (at least 20 elmos above ground/sea level), "water", "ground", "unit" (hits a unit), and "nounit" (doesn't hit a unit). There is an "underwater" condition, but it doesn't actually work at time of writing. If you set the condition to true (e.g., "water = 1;"), the spawner will run if the explosion takes place under that condition. If you set more than one condition, the spawner will run if any of them are true. If you want a spawner to run only if two or more conditions are ''all'' true, you have to do a little trick with the CExpGenSpawner class.<br />
<br />
==== Count ====<br />
The count determines the number of times the spawner will run.<br />
<br />
=== groundflash ===</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG-Format&diff=3787CEG-Format2008-12-30T07:34:57Z<p>Evil4zerggin: New page: == Overall Format == A CEG file contains one or more CEGs. Each CEG follows this format: <pre> [ceg_name] { [spawner_name_0] { class=CClassName; [properties] { propert...</p>
<hr />
<div>== Overall Format ==<br />
<br />
A CEG file contains one or more CEGs. Each CEG follows this format:<br />
<br />
<pre><br />
[ceg_name] {<br />
[spawner_name_0] {<br />
class=CClassName;<br />
[properties] {<br />
property0 = value;<br />
property1 = value;<br />
//and so on...<br />
}<br />
condition0 = 1;<br />
condition1 = 0;<br />
count = 1;<br />
}<br />
<br />
[spawner_name_1] {<br />
//each spawner follows that format<br />
}<br />
<br />
[groundflash] {<br />
//groundflash is a special name; it always generates a groundflash<br />
flashsize=16;<br />
flashalpha=1;<br />
circlegrowth=1;<br />
circlealpha=0;<br />
ttl=8;<br />
color=1,1,1;<br />
}<br />
}<br />
</pre></div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=Game_and_Unit_development&diff=7960Game and Unit development2008-12-30T07:29:51Z<p>Evil4zerggin: </p>
<hr />
<div>=Mod development=<br />
Mods, next to Maps, is the content used in Spring.<br><br />
A mod is simply a combined file containing a small structure of files and directories holding all the data required.<br><br />
<br />
[[Mod_Development | Mod Development]] wiki is a starting page, linking to very useful information on the files included in a mod, their hierarchy and more.<br />
<br><br />
<br />
Almost the entire mod developing is the creation of units. Which isn't an easy job.<br><br />
Information about the creation of units are everywere, but not combined.<br><br />
This is a gathered list of all Tutorials and helpfull forums threads I could find:<br><br />
<br />
==General==<br />
*[[Mod Development]]<br />
*[[Mod specification]]<br><br />
*[http://spring.clan-sy.com/phpbb/viewtopic.php?t=6015 What do I need to create a mod]<br />
*[[Simple Mod Tutorial]]<br />
*[[Freely available and reusable content|Freely available and reusable content/games/mods]]<br />
<br />
==Unit Development==<br />
====Automated Mod Creation====<br />
* [[TA2Spring]] - Automatically adds and converts Total Annihilation unit packs (.ufo files, etc..) into Spring mods (requires a base modification for the game rules, XTA is recommended)<br />
====Models - s3o Files====<br />
*[http://user.supradigital.org/jcnossen/UpspringInstaller-1.54-EulerAngles.exe UpSpring, our second-gen import / export / rigging / animation tool.]<br />
* [http://lassie.student.utwente.nl/vliet/springtut.pdf Maestro's tutorial of Upspring and textures].<br />
* [[Basic s3o unit making guide]]<br />
* [[Simple Mod Tutorial]]<br />
* [[Units:CreateModel|UV Mapping in Wings3D]]<br />
* [http://spring.clan-sy.com/phpbb/viewtopic.php?t=10612 Wings UV Mapping Tutorial]<br />
* [http://spring.clan-sy.com/phpbb/viewtopic.php?f=9&t=12354 Saving polygons in Wings3d Tutorial]<br />
* [http://spring.clan-sy.com/phpbb/viewtopic.php?t=10947 Greeble Tutorial 1]<br />
* [http://spring.clan-sy.com/phpbb/viewtopic.php?f=9&t=12356 Greeble Tutorial 2]<br />
* [http://spring.clan-sy.com/phpbb/viewtopic.php?p=75495 various things about unit making. (Also contains an illustrated alpha-channel tut)]<br />
* [http://spring.clan-sy.com/phpbb/viewtopic.php?t=10503 Runecrafter's 3DS Max UV Mapping Tutorial]<br />
* [http://spring.clan-sy.com/phpbb/viewtopic.php?f=9&t=15106 Argh's UpSpring Easy Workflow Guide]<br />
* [[Trouble-shooting s3o units]]<br />
<br />
====Models - 3do Files====<br />
outdated model format used by OTA<br><br />
(Note: UpSpring has some problems with empty objects and groundplates)<br />
*use [http://spring.clan-sy.com/phpbb/viewtopic.php?f=12&t=7208&p=126129&hilit=upspring#p126129 UpSpring] and [http://www.fileuniverse.com/?p=show&a=it&id=305 3doBuilder] to edit those files<br />
<br />
====Scripting and Animation - COB/BOS Files====<br />
*[[Units0:.bos ]] some examples<br />
*[[COB_Overview]]<br />
*[[COB_Animation]]<br />
*[[COB_Callins]]<br />
*[[COB_Constants]]<br />
*[[COB_Threads]]<br />
*[[COB_HitByWeaponID]]<br />
*[http://www.planetannihilation.com/tadc/tut_unit_01_1.asp PlanetAnnihilation] has a nice tutorial<br />
*[[Units:LuaCOB]] - how to interface COB with LUA<br />
*[[CEG_For_Units|Mod Development:Calling basic CEGs from COB]]<br />
* [http://spring.clan-sy.com/phpbb/viewtopic.php?p=132943#132943 GPL-compliant sourcecode, scripting code examples, and other things.]<br />
<br />
====Units - FBI Files====<br />
*[[Units:FBI]]<br />
*[[All_FBI-variable_values:_min,_max,_default,_type|Units:FBI (variable datatype list)]]<br />
*[[Unit_Categories]]<br />
<br />
====Weapons - TDF Files====<br />
*[[Weapon Variables]] : This is the most up to date<br />
*[[Units:WeaponMainDir]]<br />
*[[Units:Weapons]] : Various informations about the weapontypes (uncompleted)<br />
*[[All_Weapons_variable_values:_min%2C_max%2C_default%2C_type|Weapon datatype list]] : All weapon variables min/max/default values and datatypes listed.<br />
*[[Weapons:Antinukes]]: All about antinukes.<br />
<br />
====Explosions====<br />
*[[CEG_Overview]]<br />
*[[CEG_Format]]<br />
*[[CEG_Classes]]<br />
*[[CEG_Operators]]<br />
*[[CustomExplosionGenerators|Old CEG page]]<br />
<br />
====Misc====<br />
*[[Units:Design]]<br />
*[[Units:Textures]]<br />
*[[Units:Buildpics]]<br />
*[[Units:SideData TDF]]<br />
*[[Units:Download TDF]] <br />
*[[Units:FlankingBonus]]<br />
*[[Mod Development:Armor]]<br />
*[[Mod Development:Cursors]]<br />
*[[Mod Development:Archives]]<br />
*[[Mod Development:Sidepics]]<br />
*[[CustomUnitIcons|Mod Development:Custom unit icons]]</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG:Operators&diff=3920CEG:Operators2008-12-29T23:39:58Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/ExplosionGenerator.cpp<br />
<br />
== Introduction ==<br />
You are not limited to using fixed numbers in CEGs for positions, speeds, and so forth. Instead, you can use operators to change the CEG based on a variety of things.<br />
<br />
== Syntax ==<br />
Operators are read left to right. The operand is always to the right of the operator. Spaces are ignored, except to separate numbers. A number with no operator defaults to addition.<br />
<br />
== The Buffer ==<br />
CEG provides you with a buffer in which you can store numbers using the yank ('y') operator. This buffer can store 16 values, numbered 0 to 15.<br />
<br />
== Operators ==<br />
These are listed in the format "Operator Name (operator)".<br />
<br />
=== Index ('i') ===<br />
Multiplies the operand by the current count index. This index starts at 0 and increments every time the spawn is run, until the spawn has run a number of times equal to its count.<br />
<br />
Suggested use: Spawning things in a line.<br />
<br />
=== Rand ('r') ===<br />
Multiplies the operand by a random float between 0 and 1.<br />
<br />
Suggested use: Keeping explosions from looking too "perfect", making explosions look different every time.<br />
<br />
=== Damage ('d') ===<br />
Multiplies the operand by damage.<br />
<br />
=== Sawtooth ('m') ===<br />
Calculates the floating-point remainder of the operand.<br />
<br />
=== Discrete ('k') ===<br />
Calculates the floor of the operand.<br />
<br />
=== Sine ('s') ===<br />
Calculates the sine of the operand.<br />
<br />
=== Yank ('y') ===<br />
Saves the running result into buffer[operand], and resets the running result to zero.<br />
<br />
=== Multiply ('x') ===<br />
Multiplies the running result by buffer[operand].<br />
<br />
=== Add Buffer ('a') ===<br />
Adds buffer[operand] to the running result.<br />
<br />
=== Power ('p') ===<br />
Raises the running result to the operandth power<br />
<br />
=== Power Buffer ('q') ===<br />
Raises the running result to the buffer[operand]th power.<br />
<br />
=== Add (default) ===<br />
Adds the operand to the running result. This operator is used if no other operator is given.<br />
<br />
== Example ==<br />
<pre><br />
i0.03125y0 -0.2x0x0<br />
</pre><br />
<br />
This multiplies the index by 0.03125 and saves it to buffer[0]. It then multiplies -0.2 by buffer[0] twice. The result is then -0.2 (i * 0.03125)^2.</div>Evil4zergginhttps://springrts-wiki.p2004a.com/mediawiki/index.php?title=CEG:Operators&diff=3919CEG:Operators2008-12-29T23:39:45Z<p>Evil4zerggin: </p>
<hr />
<div>'''Source:''' https://spring.clan-sy.com/svn/spring/trunk/rts/Sim/Projectiles/ExplosionGenerator.cpp<br />
<br />
== Introduction ==<br />
You are not limited to using fixed numbers in CEGs for positions, speeds, and so forth. Instead, you can use operators to change the CEG based on a variety of things.<br />
<br />
== Syntax ==<br />
Operators are read left to right. The operand is always to the right of the operator. Spaces are ignored, except to separate numbers. A number with no operator defaults to addition.<br />
<br />
== The Buffer ==<br />
CEG provides you with a buffer in which you can store numbers using the yank ('y') operator. This buffer can store 16 values, numbered 0 to 15.<br />
<br />
== Operators ==<br />
These are listed in the format "Operator Name (operator)".<br />
<br />
=== Index (i) ===<br />
Multiplies the operand by the current count index. This index starts at 0 and increments every time the spawn is run, until the spawn has run a number of times equal to its count.<br />
<br />
Suggested use: Spawning things in a line.<br />
<br />
=== Rand (r) ===<br />
Multiplies the operand by a random float between 0 and 1.<br />
<br />
Suggested use: Keeping explosions from looking too "perfect", making explosions look different every time.<br />
<br />
=== Damage ('d') ===<br />
Multiplies the operand by damage.<br />
<br />
=== Sawtooth ('m') ===<br />
Calculates the floating-point remainder of the operand.<br />
<br />
=== Discrete ('k') ===<br />
Calculates the floor of the operand.<br />
<br />
=== Sine ('s') ===<br />
Calculates the sine of the operand.<br />
<br />
=== Yank ('y') ===<br />
Saves the running result into buffer[operand], and resets the running result to zero.<br />
<br />
=== Multiply ('x') ===<br />
Multiplies the running result by buffer[operand].<br />
<br />
=== Add Buffer ('a') ===<br />
Adds buffer[operand] to the running result.<br />
<br />
=== Power ('p') ===<br />
Raises the running result to the operandth power<br />
<br />
=== Power Buffer ('q') ===<br />
Raises the running result to the buffer[operand]th power.<br />
<br />
=== Add (default) ===<br />
Adds the operand to the running result. This operator is used if no other operator is given.<br />
<br />
== Example ==<br />
<pre><br />
i0.03125y0 -0.2x0x0<br />
</pre><br />
<br />
This multiplies the index by 0.03125 and saves it to buffer[0]. It then multiplies -0.2 by buffer[0] twice. The result is then -0.2 (i * 0.03125)^2.</div>Evil4zerggin