## About The Pull Request
I thought I fixed this a while back with changes to signals and such
(#76360), but I failed to handle machine to machine interaction and
autolinking properly which broke behavior. Mildly hard to test but it...
should? work better now. I don't think I've missed something but it is
possible.
[Unfucks telecomms_list, mild code quality
stuff](https://github.com/tgstation/tgstation/pull/90747/commits/cc8316d523b31a15d665a15def63e18318320e8f)
[cc8316d](https://github.com/tgstation/tgstation/pull/90747/commits/cc8316d523b31a15d665a15def63e18318320e8f)
GLOB.telecomms_list proported to hold just /telecomms machines but it
WASN'T, we stuffed message computers in there too to make references a
bit easier to clean.
This fixes that, handling them instead with a one to many pattern. I've
also renamed a few things (most prominently GLOB.telecomms_list ->
GLOB.telecomm_machines), and unindented an if check that was essentially
dead code. Also killed a really messy define and replaced it with a
proc.
## Why It's Good For The Game
Mapper asked for it, really should have done this years ago but we
didn't have a usecase for it.
## Changelog
🆑
fix: Tcomms machines will interoperate across z levels in the same
"stack" as expected now
/🆑
Introducing more weather types! And yes, you can now have rain be
reagent based!
<details>
<summary>Regular Rain</summary>
</details>
<details>
<summary>Blood Rain</summary>
</details>
<details>
<summary>Acid Rain</summary>
</details>
You can even make it rain ants, plasma, or drugs. All of their effects
get applied to turfs, objects, and mobs depending on the weather options
you select.
Did I mention... there is thunder?
<details>
<summary>Thunder Strikes</summary>
</details>
<details>
<summary>Sand Storms</summary>
</details>
Despite all this new stuff, none of it has been directly added to the
game but the code can be used in the future for:
- Wizard event - Similar to lava on floor, but this time make the
reagent random or picked from a list and give wizard immunity
- Chaplain ability - Maybe make this a benefit or ability once enough
favor has been obtained
- Admin events - I have added a BUNCH of admin tooling to run customized
weather events that let you control a lot of options
- New station maps/biomes for downstreams (Jungle Station, etc.)
- Change Ion storms to use the new weather system that triggers
EMP/thunder effects across the station
- IceBox could get plasma rain
- Lavaland could get thunder effects applied to ash storms
Relevant PRs that removed/added some of the weather stuff I used:
- #60303
- #25222
---
- Rain sprites were added via [novaepee](https://github.com/novaepee) in
https://github.com/tgstation/TerraGov-Marine-Corps/pull/9675
- Sand sprites were added via [TiviPlus](https://github.com/TiviPlus)
(who commissioned them from bimmer) in
https://github.com/tgstation/TerraGov-Marine-Corps/pull/4645
- Rain sounds [already existed on
tg](https://github.com/tgstation/tgstation/pull/25222#discussion_r106794579)
and were provided by provided by Cuboos, using Royalty Free sounds,
presumed under default tg sound license - Creative Commons 3.0 BY-SA
- Siren sound is from siren.wav by IFartInUrGeneralDirection --
[Freesound](https://freesound.org/s/46092/) -- License: Attribution 4.0
The original `siren.ogg` sound used on a lot of SS13 servers doesn't
seem to have any attribution that I could locate. The sound was added
about 15 years ago. So I just looked for a somewhat similar sounding
siren noise on Freesound.
More weather customization!
🆑
add: Added new weather types for rain and sandstorms. Rain now uses a
reagent that gets exposed to the turfs, mobs, and objects. There is also
a thunder strike setting you can apply to any weather.
add: Hydro trays and soil will now add reagents to their trays when
exposed to a chemical reaction. (weather, shower, chem spills, foam
grenades, etc.)
add: Weather temperature now affects weather reagents and mobs body
temperature.
bal: Snowstorm temperature calculations were tweaked to allow universal
weather temperature effects.
sound: Added weather sounds from TGMC for rain and sirens (attributed to
Cuboos and IFartInUrGeneralDirection )
image: Added weather images from TGMC for rain and sand storms
(attributed to Novaepee and Bimmer)
refactor: Refactored a lot of the weather code to be more robust
admin: Admins can now control more weather related options when running
weather events. The weather admin verbs have been moved to their own
"Weather" category under the Admin tab.
/🆑
---------
Co-authored-by: LemonInTheDark <58055496+LemonInTheDark@users.noreply.github.com>
Co-authored-by: Ghom <42542238+Ghommie@users.noreply.github.com>
## About The Pull Request
Partially a port of
https://github.com/DaedalusDock/daedalusdock/pull/1163 which is a port
of my own code from bitbus
Closes#88579
Instead of manually setting hud images and positioning we now can use
set_hud_image_state which also updates their position to ensure that
they scale with the owner atom. HUDs had RESET_COLOR and RESET_TRANSFORM
but no KEEP_APART, so they were stuck with mobs all this time. I
replaced RESET_TRANSFORM with PIXEL_SCALE (shouldn't be reserved to mob
huds only to be honest) and added KEEP_APART, so that HUDs still
scale/rotate with their owner but don't inherit their color. Also fixed
the dragon issue, that's where this PR actually started.
Closes https://github.com/tgstation/tgstation/issues/45411
## Why It's Good For The Game
I don't want my HUDs to be pretty pink when I make a barbie Clarke.
## Changelog
🆑
refactor: Rewrote some of HUD code so they're no longer colored in their
owner's color
fix: Space dragons no longer turn invisible when toggling seethrough
mode
/🆑
## About The Pull Request
~~Kept you waitin huh!~~
The projectile refactor is finally here, 4 years later. This PR (almost)
completely rewrites projectile logic to be more maintainable and
performant.
### Key changes:
* Instead of moving by a fixed amount of pixels, potentially skipping
tile corners and being performance-heavy, projectiles now use
raymarching in order to teleport through tiles and only visually animate
themselves. This allows us to do custom per-projectile animations and
makes the code much more reliable, sane and maintainable. You (did not)
serve us well, pixel_move.
* Speed variable now measures how many tiles (if SSprojectiles has
default values) a projectile passes in a tick instead of being a magical
Kevinz Unit™️ coefficient. pixel_speed_multiplier has been retired
because it never had a right to exist in the first place. __This means
that downstreams will need to set all of their custom projectiles' speed
values to ``pixel_speed_multiplier / speed``__ in order to prevent
projectiles from inverting their speed.
* Hitscans no longer operate with spartial vectors and instead only
store key points in which the projectile impacted something or changed
its angle. This should similarly make the code much easier to work with,
as well as fixing some visual jank due to incorrect calculations.
* Projectiles only delete themselves the ***next*** tick after impacting
something or reaching their maximum range. Doing so allows them to
finish their impact animation and hide themselves between ticks via
animation chains. This means that projectiles no longer disappear ~a
tile before hitting their target, and that we can finally make impact
markers be consistent with where the projectile actually landed instead
of being entirely random.
<details>
<summary>Here is an example of how this affects our slowest-moving
projectile: Magic Missiles.</summary>
Before:
https://github.com/user-attachments/assets/06b3a980-4701-4aeb-aa3e-e21cd056020e
After:
https://github.com/user-attachments/assets/abe8ed5c-4b81-4120-8d2f-cf16ff5be915
</details>
<details>
<summary>And here is a much faster, and currently jankier, disabler
SMG.</summary>
Before:
https://github.com/user-attachments/assets/2d84aef1-0c83-44ef-a698-8ec716587348
After:
https://github.com/user-attachments/assets/2e7c1336-f611-404f-b3ff-87433398d238
</details>
### But how will this affect the ~~trout population~~ gameplay?
Beyond improved visuals, smoother movement and a few minor bugfixes,
this should not have a major gameplay impact. If something changed its
behavior in an unexpected way or started looking odd, please make an
issue report.
Projectile impacts should now be consistent with their visual position,
so hitting and dodging shots should be slightly easier and more
intuitive.
This PR should be testmerged extensively due to the amount of changes it
brings and considerable difficulty in reviewing them. Please contact me
to ensure its good to merge.
Closes#71822Closes#78547Closes#78871Closes#83901Closes#87802Closes#88073
## Why It's Good For The Game
Our core projectile code is an ungodly abomination that nobody except
me, Kapu and Potato dared to poke in the past months (potentially
longer). It is laggy, overcomplicated and absolutely unmaintaineable -
while a lot of decisions made sense 4 years ago when we were attempting
to introduce pixel movement, nowadays they are only acting as major
roadblocks for any contributor who is attempting to make projectile
behavior that differs from normal in any way.
Huge thanks to Kapu and Potato (Lemon) on the discord for providing
insights, ideas and advice throughout the past months regarding
potential improvements to projectile code, almost all of which made it
in.
## Changelog
🆑
qol: Projectiles now visually impact their targets instead of
disappearing about a tile short of it.
fix: Fixed multiple minor issues with projectile behavior
refactor: Completely rewrote almost all of our projectile code - if
anything broke or started looking/behaving oddly, make an issue report!
/🆑
## About The Pull Request
`// Remove these once we have Byond implementation.`
Well guess what we have now?
Altho sadly we still lack a native `isfinite`, so we still use a define
for that.
## Why It's Good For The Game
Native BYOND impls have better performance usually, due to them
compiling down to instructions, avoiding proc overhead.
## Changelog
No user-facing changes.
## About The Pull Request
All usages of world.icon_size in code have been replaced with new
`ICONSIZE_X`, `ICONSIZE_Y` and `ICONSIZE_ALL` defines depending on
context
Replaces some "32" magic numbers with the defines
A few bits of code have been modified to split up x/y math as well
## Why It's Good For The Game
Magic number bad, code more readable, code more flexible and I'm told
there's an access cost to doing world.icon_size so minor performance
gains
## Changelog
🆑 tonty
code: made some code relating to the world's icon size more readable
/🆑
---------
Co-authored-by: Ghom <42542238+Ghommie@users.noreply.github.com>
## About The Pull Request
CHEAP_HYPOTENUSE() no longer absolutes the differences between the
coordinates.
## Why It's Good For The Game
It gets squared so it doesn't need to be done.
## About The Pull Request
Refactors a lot of the unused defines.
## Why It's Good For The Game
Refactors a lot of the unused defines.
## Changelog
Nothing player facing
---------
Co-authored-by: san7890 <the@san7890.com>
## About The Pull Request
See the title.
## Why It's Good For The Game
Mothblocks wanted map votes to not be simple winner take all and wanted
it to be randomly chosen based on votes.
## Changelog
🆑
add: Map Votes are now weighted random.
add: Custom Votes can now take advantage of Weighted Random winner
selection
del: Removed Herobrine from the game
/🆑
---------
Co-authored-by: Mothblocks <35135081+Mothblocks@users.noreply.github.com>
## About The Pull Request
Zap strength is now measured in joules. Scales everything to account for
this.
NT CIMS will now display the zap power transmission in watts, instead of
a modifier. This will allow you to actually see how much power the
supermatter is generating accurately, without knowledge of hidden
multipliers. NT CIMs will also show the internal energy gain from heat
in eV/K/s, so you can easily figure out how internal energy gain works,
and how much energy gain it actually gives. The internal energy
measurement will also adjust its prefix. Internal energy is now a
measure of internal energy, rather than internal energy density,
removing the "/cm^3".
Here is what it looked like:
This image was created on an earlier commit where the numbers were wrong
due to a hidden multiplier that got removed later, so keep that in mind.
Also fixes inactive supermatters unnecessarily scaling delta time. The
high energy (>5GeV) additional zaps now also scale with delta time.
The code in this PR is absolute garbage trash and there are some major
issues, so I'm drafting this for now.
## Why It's Good For The Game
Makes it more clear what the factors add, and also how much power the SM
is releasing. Zap strength being measured in joules will simplify a lot
of things, making power balance more clear rather than guessimating.
Adjusting the prefix for internal energy is just the natural thing to
do. The per cubic centimeter part of internal energy would imply it is
energy density, however it is functionally not. It would probably
confuse people thinking the volume of the turf or the size of the
supermatter actually matters for what the internal energy does, when it
does not (except for gas absorption I guess, which changes heating/mol
requirements, but nothing else), so I am removing that part.
## Changelog
🆑
qol: NT CIMs shows how much power the supermatter is releasing.
qol: NT CIMs internal energy will adjust its prefix.
qol: Energy displays (such as multitooling grid) will use the full range
of SI prefixes available, up to the peta prefix if you somehow managed
to reach that.
del: Removes the per cubic centimeter part of internal energy.
fix: Fix unnecessary delta time scaling on inactive supermatters.
fix: Fix high energy zaps not scaling with delta time.
fix: Fixes grounding rods lying about potential power you can generate.
code: Convert supermatter_zap() and tesla_zap() zap_str argument unit to
be in joules, and scales everything that uses that argument.
/🆑
## About The Pull Request
Several common 'household' reagents can be used as improvised medicine
treatment.
Drinking tea will help mend (non-bone) wounds over time.
Flour and corn starch may be splashed onto wounds to help dry them up,
though they'll have a negative effect on burn wounds.
Added a new reagent, saltwater, made by combining table salt with water.
Table salt and saltwater can be splashed onto wounds as well, reducing
bleeding and improving sanitization and disinfection significantly.
However, the coarse undiluted salt will irritate the wounds, reducing
clot rate and flesh healing, and both of the reagents will increase a
burn wound's infestation rate.
Altered Table Salt's recipe to just need sodium and chloride. Changed
the recipe of Pentetic Acid and Heparin to need table salt (sodium x
chloride) and thus slightly altered the total output of those reagents
(pentacid went from 5u per reaction to 4u, heparin 4u->3u)
Saline-Glucose Solution now needs 2u of saltwater and 1u of sugar,
meaning the overall recipe should be completely unchanged in practice.
Contact me on discord if any issues arise from these chemical changes!
First aid analyzers now give easy-to-understand direct information, with
the specific recommended treatments bolded in the analysis text. They
also have a 'unique' extra bit of info, telling you about improvised
ways to remedy your wound.
## Why It's Good For The Game
Wounds have a very poor amount of interaction with the rest of the game
and have not had much added to them post-merge, especially in
'improvised' ways to help Not Die to a wound while you crawl your way to
a emergency medkit or medbay. I researched info on this and found some
interesting ideas - some of them I'll have to leave for later because
this PR kept growing out of scope (Improvised bone gel, ice on wounds
which turned into wound temperature mechanics, crutches, a 'suture item'
component refactor...)
As for what this actually does to benefit the game, it allows more
dynamic wound Gameplay as people use first aid analyzers to get
information on treatment when medbay blows up, helps them stabilize by
splashing flour onto themselves before looking for some actual
treatment, helps traitors realize how they can self-treat many crippling
wounds (at risk, of course). It expands treatment options to things
beside medkits and medbay, but always does so in ways that have
downsides that make them not ideal as _treatment_, and more beneficial
as stabilizing before seeking true professional help. This thus
significantly increases the rather shallow depth of wounds as a system
to interact with.
> Several common 'household' reagents can be used as improvised medicine
treatment.
From what I could tell by looking at several sources for each
'realistic' treatment, these are indeed semi-reasonable things that are
done to wounds by some people as household treatment.
It goes without saying that you should **not do any of these things in
real life** without consulting a doctor unless your blood is also
spilling out by the gallon into the floor. All these 'realistic
treatments' have drastic downsides and are meant for the short-term
only. Except the tea.
> Drinking tea will help mend (non-bone) wounds over time.
Tea is healthy, we all know that.
> Flour and corn starch may be splashed onto wounds to help dry them up,
though they'll have a negative effect on burn wounds.
Flour and apparently starch dries wounds up but risks infection. That's
not a thing for blood wounds yet but oh well.
> Table salt and saltwater can be splashed onto wounds as well, reducing
bleeding and improving sanitization and disinfection significantly.
However, the coarse undiluted salt will irritate the wounds, reducing
clot rate and flesh healing, and both of the reagents will increase a
burn wound's infestation rate.
Salt kills bacteria via osmosis, but it also kills your own cells, and
some bacteria like salt.
> Added a new reagent, saltwater, made by combining table salt with
water.
> Altered Table Salt's recipe to just need sodium and chloride. Changed
the recipe of Pentetic Acid and Heparin to need table salt (sodium x
chloride) and thus slightly altered the total output of those reagents
(pentacid went from 5u per reaction to 4u, heparin 4u->3u)
> Saline-Glucose Solution now needs 2u of saltwater and 1u of sugar,
meaning the overall recipe should be completely unchanged in practice.
Contact me on discord if any issues arise from these chemical changes!
I wish I hadn't had to mess with reagents like this, but I needed to
because just adding mixing salt and water caused the saline glucose
recipe to basically split itself into half saltwater half glucose.
I removed the water requirement for table salt (Why did it even have
that, salt ain't wet bro?), made saline-glucose need 2u saltwater and 1u
sugar, and altered relevant recipes so they didn't also cause unwanted
table salt to react from their sodium and chloride ingredients.
A happy side-effect is that saline glucose solution is even easier to
make now as an improvised chem by mixing salt, water, and sugar, which
fits pretty perfectly (especially as a temporary blood substitute)
> First aid analyzers now give easy-to-understand direct information,
with the specific recommended treatments bolded in the analysis text.
They also have a 'unique' extra bit of info, telling you about
improvised ways to remedy your wound.
You might notice that as the wounds get more serious the text gets more
direct and concise and reluctantly hands out more and more improvised
treatment options, so that's fun. As for the improvised section itself,
it helps people be actually aware of these ways to help treat themselves
rather than delegating it to hyper-gamer knowledge.
The bolded treatment bit is pretty neat and means your eyes can
inmediately focus on what you can do to save yourself - very useful if
you have a weeping avulsion and no bandages.
## Changelog
🆑
add: Several common 'household' reagents can be used as improvised
medicine treatment.
add: Drinking tea will help mend (non-bone) wounds over time.
add: Flour and corn starch may be splashed onto wounds to help dry them
up, though they'll have a negative effect on burn wounds.
add: Added a new reagent, saltwater, made by combining table salt with
water.
add: Table salt and saltwater can be splashed onto wounds as well,
reducing bleeding and improving sanitization and disinfection
significantly. However, the coarse undiluted salt will irritate the
wounds, reducing clot rate and flesh healing, and both of the reagents
will increase a burn wound's infestation rate.
add: Altered Table Salt's recipe to just need sodium and chloride.
Changed the recipe of Pentetic Acid and Heparin to need table salt
(sodium x chloride) and thus slightly altered the total output of those
reagents (pentacid went from 5u per reaction to 4u, heparin 4u->3u)
add: Saline-Glucose Solution now needs 2u of saltwater and 1u of sugar,
meaning the overall recipe should be completely unchanged in practice.
Contact me on discord if any issues arise from these chemical changes!
qol: First aid analyzers now give easy-to-understand direct information,
with the specific recommended treatments bolded in the analysis text.
They also have a 'unique' extra bit of info, telling you about
improvised ways to remedy your wound.
/🆑
---------
Co-authored-by: san7890 <the@san7890.com>
Co-authored-by: MrMelbert <51863163+MrMelbert@users.noreply.github.com>
## About The Pull Request
Yeah, the built-in `arctan()` proc actually returns degrees rather than
radians so I had to revert the change to the macro. Also, I had to
revamp the whole formula once again because the old one was eh. The
random location of -0.5 to 0.5 meant it never went lower/higher than the
40-60% threat range, and the RNG deviation was crappy.
As a bonus, I slighly lowered the threat requirements for the wizard's
gun/magic/events rituals, since reaching a full 100 is a smidge less
likely now (previously the odds were one in ten if the threat score was
higher than 90%, now it's a 0.5% chance in total, as the threat is
rounded to intervals of 1).
## Why It's Good For The Game
This will fix#77726.
Here's the updated desmos graph:
https://www.desmos.com/calculator/fpc7gwtwla (the red curve is the one
without the deviation, the black one is with the deviation)
Gimme a few minutes to run one last test, tho. I cannot trust myself too
much.
## Changelog
🆑
fix: Fixed dynamic.
/🆑
Alternative Title: I'm bad at maths but thank goodness graphing
calculators exist.
## About The Pull Request
So, it was reported on #77329 that `dynamic/proc/lorentz_to_amount` is
kinda "jagged", as you can see in the issue report yourselves. There,
they also suggested a better version with the actual segments connected.
However, as I internally shouted "It's copypasting time!", My gears came
to a halt. I promptly realized, looking at the graph, how it looked like
an approximation of a comulative distribution.
Fuddled, I wondered if we could replace that switch() call and its
indented crude algebra with the actual macro of the lorentz cumulative
distribution, which I did, not without the use of softwares to alleviate
my incapacity at performing such complex mathematical functions off the
top of my head, and with some peculiarities and improvements attached to
this PR, such as, instead of clamping, multiplying the value of the
distribution by the maximum threat.
## Why It's Good For The Game
This will fix#77329. The formula was tested a graphing calculator,
though it may work differently than the original proc, a testmerge is
reccomended.
## Changelog
🆑
fix: Fixed some jank with the dynamic threat curve.
/🆑
---------
Co-authored-by: san7890 <the@san7890.com>
This tracks the seconds per tick of a subsystem, however note that it is
not completely accurate, as subsystems can be delayed, however it's
useful to have this number as a multiplier or ratio, so that if in
future someone changes the subsystem wait time code correctly adjusts
how fast it applies effects
regexes used
git grep --files-with-matches --name-only 'DT_PROB' | xargs -l sed -i
's/DT_PROB/SPT_PROB/g'
git grep --files-with-matches --name-only 'delta_time' | xargs -l sed -i
's/delta_time/seconds_per_tick/g'
## About The Pull Request
The netherworld mob refactor PR added a component called `damage_buffs`
which... was both kind of a little bit pointless and also didn't do what
the name said it did.
This adds a new component which actually does what that component
promised to do, and does it more reliably.
The previous system had sort of odd behaviour where a Migo would start
moving faster as it took damage but _only_ if it took damage with an
identifiable mob, so damage from the environment or lava or an explosion
or anything else which doesn't come with someone to blame wouldn't
update the mob, and neither would its health going back _up_... until
someone punched it at which point anything it should have been doing
before then would suddenly update.
This adds a new component which simply listens to
`COMSIG_LIVING_HEALTH_UPDATE` instead of `COMSIG_ATOM_WAS_ATTACKED` and
then interpolates the provided maximum and minimum values smoothly based
on how close you are to a maximum or minimum health threshold.
This is slightly different from the original behaviour which didn't
necessarily have those things change linearly and only did it in
increments of 25%... but this is cleaner.
## Why It's Good For The Game
Fixes some odd behaviour with these mobs.
Hopefully makes the code both cleaner and more reusable in the future.
## Changelog
🆑
refactor: Migos, Creatures, and Blank Bodies use a new shared component
to update their stats which scales smoothly as they take damage rather
than in stages.
fix: Migos, Creatures and Blank Bodies will all update their stats when
taking or losing damage regardless of it was from an identifiable enemy.
/🆑
Signed-off-by: GitHub <noreply@github.com>
## About The Pull Request
## Why It's Good For The Game
Resolves#72534
## Changelog
Signed-off-by: GitHub <noreply@github.com>
## About The Pull Request
Part of a prior PR that was closed (#72562). This version does not add
the check in CI.
## Why It's Good For The Game
The work is already done, so I figured why not.
## Changelog
N/A Nothing player facing
Co-authored-by: Jeremiah Snow <jlsnow301@pm.me>
Co-authored-by: Mothblocks <35135081+Mothblocks@users.noreply.github.com>
## About The Pull Request
We do two major things here.
First, instead of having every turf need to ask all the turfs in "front"
of it for its blast resistance, we have blast resistance carry back in a
cache, so they only need to ask the one directly in front of them.
Much faster, such wow
The other thing we do is totally remove the idea of "building" a turf's
explosion resistance. Instead, a turf's full resistance is stored on it
at all times.
We use an element to manage objects that want to block explosives, and
that's it simple as.
As an optimization, turfs handle block differently, using a system where
we imply that a turf's own block is just the initial of their
explosive_resistance, unless proven otherwise
This also saves a significant amount of time
To be honest with you, I did this mostly cause I wanted to well make
explosions faster
This doesn't really fufil that. They are faster, but not by much
The bulk of explosion cost comes from actually exploding things, rather
then figuring out what/how to delete.
This code is much faster for larger blastwave sizes, because calculating
protection is constant.
We save maybe 60% of propogate_blastwave, but unfortunately
propogate_blastwave for one maxcap on the top left of icebox's chapel is
only 28ms, so while 11ms is good, it's not everything I could want when
the cost of explosion/fire is 555ms.
I'm happy about it still tho, because doing things like this means I can
expand on how explosive blocking works without needing to make things
seriously expensive in here.
Also it's faster for meme admin explosions and mega burgers
## Why It's Good For The Game
Speeds up explosives slightly, opens the door to better blast resistance
projection
* Don't allow NAN into the reagent holders, and better reporting on add reagent and remove reagent
* Replace admin message with stack_trace and return and improve math defines to check for finite numbers
* Refactor things to use these new defines, attempts to fix unit tests by filtering out <= 0 amounts first
Co-authored-by: Aleksej Komarov <stylemistake@gmail.com>
This was causing issues with indexing icon slots (the main user of TOBITSHIFT). See BeeStation/BeeStation-Hornet#6842 for more details.
Probably fixes#66197 and fixes#65652. (In all my tests, I could never get anything to show in suit_storage, whereas those bugs are reporting intermittent issues.)
Originally made for BeeStation/BeeStation-Hornet#6842 (which also affects TG).
Have you ever noticed that the chemical smoke and chemical foam reactions are a lot less effective in confined spaces? This is because they currently attempt to spread to all tiles within n steps of their origin. If they can't expand onto a tile they get blocked and the expanding cloud/flood misses out on all the tiles that would be in range, but that can't be reached.
Obviously smoke and foam getting blocked by walls and the like makes intuitive sense, but it seemed a bit nonsensical that walls would basically delete a significant chunk of an expanding, amoebic mass. The solution I came up with is making smoke and foam expand until they cover a certain area, with a shared tracker for the target size and total size of the flood. The flood will simply expand as normal until it covers the desired target area. Blocked expansions just don't count and will be made up for with expansion elsewhere.
Attendant to these changes are a whole bunch of minor code improvement to smoke, foam, and one for wizard spells because I was already in the area and :pain:.
There have been some minor balance changes to the chemical smoke and foam reactions:
I converted them over to passing the desired area of the resulting smoke cloud/foam flood. The old equation for the resulting area was along the lines of 2sqrt(x)(sqrt(x) + 1) + 1 given reaction volume x and given unobstructed expansion. I've made them just pass around 2x instead. This is actually less than they used to try for, but now they're guaranteed to reach that unless the flood is fully contained. Not entirely certain if buff or nerf. Probably buff on the station.
Also, foam dilution is now based on covered area instead of target expansion range. Since this scales faster than it used to foam has been effectively nerfed at high volumes. To compensate for this I removed the jank 6/7 effect multiplier and increased the base reagent scaling a bit. Again, not certain if buff or nerf.
I initially kept it an exclusive check so funny things like division by inf doesnt get in, but I implemented more inf checks on the quadratic proc and the likes so it really shouldnt be necessary now. This should hopefully reduce cases when the target pressure hits the upper limit because the target gasmix has a miniscule amount of moles, having the result be rejected by the code, and triggering a runtime.
And some minor improvements to the code so it doesnt iterate through the gaslist multiple times.
Nicer code
Ever pump hot nob into a tank of oxygen, see the pressure rise to 8000 kpa for a few seconds and have that deafening explosion sound play right after? This attempts to eliminate those by making the pressure transfer proc thingy in gas_mixture account for resulting temperature. The old one is preserved if the temperature difference isn't too big because it's most definitely more performant. The minimum temperature difference of 5 is completely arbitrary and I won't mind changing if asked. Math is a bit messy by necessity but I hope the comment is adequate.
While I'm at it i also changed the return value of those procs to return a removed gasmix instead of directly merging. I sort of needed this for a clean implementation of assume_air in #62284. Will need more testing though. Found a better solution.
Writes a small unit test to check for this too.
Cuts down on one unintended cause of explosions.
* Adds a subsystem to handle automated directional movement, replaces all instances of walk_towards with it. Makes meteors and immovable rods not drift in space, and makes immovable rods more destructive. Note, I've opted not to use byond's method of moving towards something, which is effectively Move(src, get_step(src, get_dir(src, target))) as it's cringe and doesn't make a smooth line. I've replaced it with a autoupdating rise over run setup, read the code for more details
* woop forgot the subsystem
* Documentation, contributing.md entry, and some cleanup
* Makes the moveloop datum more oop friendly, sets us up for a lot of conversions
* Converts the curseblob and walk_away() to the subsystem
* Changes the default for override from FALSE to TRUE
* converts walk() over, still need to add a replacement proc for it, but we didn't actually have anything that used the raw proc
* converts the rest of walk_to() over, nearing the end now
* cleans up some errors
* Fully documents everything, fills in some missing movement types, uses the power of oop to make things cleaner, and typepaths longer
* Finishes the contributing.md stuff
* Done
* Fefaults -> Defaults, can you tell I wrote this at 1AM?
* resolves bubblegum issues
* Roh's suggestions
Co-authored-by: Rohesie <rohesie@gmail.com>
* Cleanup
* Hey lemon, did you know that Destroy() lives on datums? ahhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
* Converts over the discrepencies created in my absense
* HAHA FUCK YOU I PAY MY DUES
* Whoops lost some stuff in the merge
* Converts the system from seconds to deciseconds to make dealing with the api more sane
* Some stuff I missed
* Makes movement an inheritable subsystem type, splits the moveloop file into two, one for the subsystem, and one for the datums
* Makes a subsystem that handles directing movers out to other subsystems. It's a bit bad right now, but it's a
good first step. I think I'll move the move loop datum to a lazy var on mobs instead of an assoc list, don't
like lists.
Also makes the movement procs global, I'll move em to the /movement subsystem at some point or something like
that
* Converts the existing uses of the procs over to the new format
* Adds support for subsystem precedence, so a type of A can override type B.
General cleanup, still kinda in debug mode but it's getting better
* I'll admit I'm not too familiar with this, but I think it will work
* Adds starting logic so movement types "pausing" makes any sense
Redoes how waiting is handled to make it based on world.time directly. I don't remember why. I think it's better
this way.
Adds a drifting movement type, moves space drift over to it.
Needs severe work before it's ready, too much info stored and modified on the moving object, see comment
Starts work on making drifting smooth
* Moves almost all space drifting vars over to signals on the movement datum
Properly implements glide size stuff for both the subsystem and the loops. Space drift will be smoother now.
It's not perfect, but it'll work just fine for now
Adds a way to override a client'd mob's glide size mid move, uses it to make entering a spacedrift look right
Adds a way to delay a client move outside of just move_delay, meant to be used for long periods, and setup such
that it doesn't make inputs persist
Adds flags to movement loops, alongside MOVELOOP_OVERRIDE_CLIENT_CONTROL, which blocks client movements while
the loop is firing, and for it's visual delay after
This means you can't exit a space drift until you hit the actual wall. This feels a lot better
Some general logic stuff, move() will return true/false if it succeeded or failed
Adds a stop_loop() proc that's called when a move loop is no longer active
Suck my nuts
* Moves precedence to the loop instead of the subsystem
* Moves drifting into a component, this lets me explictly block input after the move loop ends, so people can't
move the moment they functionally move onto a new tile
This is a bit underdeveloped currently, but that's a problem for another day
Cleans up some uses of move procs, fixes runtimes in metoer and curseblob code
Adds signals for stopping/starting a move loop, sending one for destroy is redundant.
Moves existing event signals from the movable being acted on to the loop itself, makes more sense this way
Makes the move handler return the created loop up the chain so we can register to it
Fixes a logic error in loop contesting code that lead to loops never actually being removed from subsystems
because they didn't know they should be.
Properly changes lifetime from a time to stop, to functionally an amount of moves to complete before stopping
Adds some new signals for pre/post loop process. This is to better tie into components.
I decided I didn't like the idea of tying all functionality to the loops themselves
The loop decides functionally how to move, components or just tied in signals can decide when/when not to move
and can modify properties of the loop
Making a new loop for things like atmos drift, something I'm interested in tackling in the future, seemed silly
* Moves movement procs directly to the subsystem for better namespacing or whatever
* Moves movement packets onto /atom/movable, no longer need the debugging
I've decided to not just put their contents fully onto atom movable, since it makes debugging on live much
harder, can't sdql for them anymore.
Fixes a runtime in meteor code, properly this time
Fixes a logic error in stop_looping
Makes move manager NO_INIT, because well, it doesn't init
* Commits human sin, makes Recover() work properly for movement subsystems
* Fixes immovable rod orbits not always working, they were returning too early in moved and fucking up the var we use to track move count, and thus not sending a signal properly
* Reworks the curseblob to use signals more, and to not use override
* Missed this in the movement ss commit
* Removes override, makes having a higher or equal precedence take its place
* Updates documentation
* Cleans up some unused defines
* Nukes the unused flags option
* Whoops forgot to qdel check
* Removes an unused var I had for client move prevention before I started using a component
* Let's do this properly
* Modernizes meteor code to better match how explosions actually work currently
* Some more cleanup
* Cleans up effect code a little bit
Nukes the effect system's sleep loop, we use movement loops instead
As a part of that, instead of 1 timer per effect spawned, we react to loop failure and make it 1 timer per
effect system
This should reduce the amoumt of slowdown we see after mass lighting break
It's not everything, we're still making a timer per spark effect, but it cuts things down significantly
* Updates explosions to not sleep
* Adds support for modifying a loops delay post process, makes extinguisher code suck less then it does currently, nukes some more sleeps and timer loops
* Converts water tank resin over to move loops rather then sleeps, minor behavior change mind, the cooldown starts on fire rather then on land, but I think that makes more sense anyway
* compile and runtime fix
* Fixes some runtimes, cleans up some code, ensures feature parity when it comes to logging
* Prevents resin foam from space drifting
* Adds support for flags back into the system, I need it for reasons
* Updates move_towards to fix some bugs and resolve some inconsistent behavior, implements a flag that makes a loop's first move start instantly
* Fixes extinguishers not actually transfering any reagents
* Converts sprays to the new system. This does actually minorly change behavior, in that I've changed the order of spray actions from step -> sleep -> wash to step -> wash -> sleep, but I'm not terribly torn up about it because frankly I think it feels better
* Converts grav catapults over to the new system
* Converts trays over to moveloops
* Converts robot streaking to move loops, the other two coming soon
* Compile you won't. Also fixes a behavior issue with oil streaks
* Does directional step_to properly, cleans up the other two streaking types
* Converts step_trigger over, not that it's actually used anywhere. Changes how stoping a move works, you need to explicitly qdel, other the step is just considered to be ignored. This will make life easier later
* Adds a jps movement loop. It's a bit bloaty, id is stupid, but it'll work just fine
* Makes the system support passing in a datum that's just used as extra context for the move. The hope is this makes signalizing things less of an absolute headache
* Begins the conversion of ai movement datums to movement loops
* These two are reasonably simple, only weird thing I'm doing is A: Not allowing target hotswapping, which I hope none is doing, and B: passing the controller into the move loop as extra context so things work properly
* JPS is a bit more complex, partially because the old implementation was a bit weird. 2 major things. 1: I'm dropping what I think was a redundant behavior minimum distance check from the premove bit of logic, since I'm pretty sure it didn't do anything. 2, instead of just stoping the step in an error state like being pulled, we count it against our max move total
* Audit
* Moves most forced movement to the framework, adds some components to make things nicer
* Implements a flag that makes the loop always operate, regardless of precedence and without impacting any other loops
* Moves movement subsystems into the right folder
* Hey potato what if you had two procs that did the same thing and one called the other? Wow it's useless
* Merges slipping and force movement
* Converys conveyors over to the system. It's a bit fragile, but I think it's totally worth it to save the sleep loop
* Precedence -> Priority, cleans up some logic errors, makes priority highest to lowest instead of lowest to highest, straight cleans some code up
* Makes poly and bubbles ignore spacedrift, now that precedence actually functions properly. I'm likely missing cases of this, will deal with it later
* Depression, thy name is linter
* Fixes linter, and hopefully fixes the runtimes in ci too
* Wew
* Sets sprays and extinguishers back to legacy, since people do actually seem to have noticed
* Spelling errors my beloved
Co-authored-by: Kylerace <kylerlumpkin1@gmail.com>
* More detail, moves return descriptions
* Converts transit tubes to the system?
* Adds the glide size modifier. Not honestly sure that this should be default, considering how crummy it makes things look for normal walking, but it's useful as hell here
* Adds a force move in dir template, actual support for fast initial steps (wtf old me) and a helper proc for setting delay
* Cleans up displosal code a bit, I thought about adding it to the system but it would functionally be just 'disposal loops'. Maybe I'll make a template subtype? not sure how I want to handle stuff like this
* Cleans up mob movement a bit
* Let's use the controller's visual delay
* Makes the resin thrower nicer, cries
* Cleans up some comments, replaces an implicit world.icon_size with an explicit one, fixes up a typecheck
* typecache instead of double istype. Can't do much about the !atom/movable, list would be too big I feel
* hhh
* bro wtf
* Documents the why of SS_TICKER
* Puts SSmovement on SS_TICKER. Lets us support tick steps
* Cleans up the charge action. Makes it use moveloops
* Fixes CI? kinda worried that this just got dropped
* Converts disposal pipes to move loops. They stutter a bit more then usual as of now, hoping that's a me thing, if it's not I'ma look at uping the priority of the base subsystem
* Moves the move subsystems off background, puts some on ssticker
* Prevents some things that shouldn't move in space from moving in space
* Documents the general form and usage of the system
* Virgin one vs chad once
Co-authored-by: Kylerace <kylerlumpkin1@gmail.com>
* Removes unneeded check
* Moves appropriate movement subsystems into SS_BACKGROUND. Removes redundant SS_KEEP_TIMINGs
I do want the behavior of SS_TICKER, which at this point is tick based waits, and ignoring overtime when
calculating next fire.
Since honestly, these subsystems should ignore overtime in regards to next fire, the cost of moving A may be
nothing compared to the cost of moving B.
* Makes the MODULUS macro use floor. I knew our coders would never let me down, glad this exists, thanks ninja
Fixes teleporting caused by shitty round() behavior, adds a "you hit your target" case to homing loops
* Converts blood splatters to move loops, that'll do it
Co-authored-by: Rohesie <rohesie@gmail.com>
Co-authored-by: Kylerace <kylerlumpkin1@gmail.com>
a month or two ago i realized that on master the reason why get_hearers_in_view() overtimes so much (ie one of our highest overtiming procs at highpop) is because when you transmit a radio signal over the common channel, it can take ~20 MILLISECONDS, which isnt good when 1. player verbs and commands usually execute after SendMaps processes for that tick, meaning they can execute AFTER the tick was supposed to start if master is overloaded and theres a lot of maptick 2. each of our server ticks are only 50 ms, so i started on optimizing this.
the main optimization was SSspatial_grid which allows searching through 15x15 spatial_grid_cell datums (one set for each z level) far faster than iterating over movables in view() to look for what you want. now all hearing sensitive movables in the 5x5 areas associated with each spatial_grid_cell datum are stored in the datum (so are client mobs). when you search for one of the stored "types" (hearable or client mob) in a radius around a center, it just needs to
iterate over the cell datums in range
add the content type you want from the datums to a list
subtract contents that arent in range, then contents not in line of sight
return the list
from benchmarks, this makes short range searches like what is used with radio code (it goes over every radio connected to a radio channel that can hear the signal then calls get_hearers_in_view() to search in the radios canhear_range which is at most 3) about 3-10 times faster depending on workload. the line of sight algorithm scales well with range but not very well if it has to check LOS to > 100 objects, which seems incredibly rare for this workload, the largest range any radio in the game searches through is only 3 tiles
the second optimization is to enforce complex setter vars for radios that removes them from the global radio list if they couldnt actually receive any radio transmissions from a given frequency in the first place.
the third optimization i did was massively reduce the number of hearables on the station by making hologram projectors not hear if dont have an active call/anything that would make them need hearing. so one of hte most common non player hearables that require view iteration to find is crossed out.
also implements a variation of an idea oranges had on how to speed up get_hearers_in_view() now that ive realized that view() cant be replicated by a raycasting algorithm. it distributes pregenerated abstract /mob/oranges_ear instances to all hearables in range such that theres at max one per turf and then iterates through only those mobs to take advantage of type-specific view() optimizations and just adds up the references in each one to create the list of hearing atoms, then puts the oranges_ear mobs back into nullspace. this is about 2x as fast as the get_hearers_in_view() on master
holy FUCK its fast. like really fucking fast. the only costly part of the radio transmission pipeline i dont touch is mob/living/Hear() which takes ~100 microseconds on live but searching through every radio in the world with get_hearers_in_radio_ranges() -> get_hearers_in_view() is much faster, as well as the filtering radios step
the spatial grid searching proc is about 36 microseconds/call at 10 range and 16 microseconds at 3 range in the captains office (relatively many hearables in view), the new get_hearers_in_view() was 4.16 times faster than get_hearers_in_view_old() at 10 range and 4.59 times faster at 3 range
SSspatial_grid could be used for a lot more things other than just radio and say code, i just didnt implement it. for example since the cells are datums you could get all cells in a radius then register for new objects entering them then activate when a player enters your radius. this is something that would require either very expensive view() calls or iterating over every player in the global list and calling get_dist() on them which isnt that expensive but is still worse than it needs to be
on normal get_hearers_in_view cost the new version that uses /mob/oranges_ear instances is about 2x faster than the old version, especially since the number of hearing sensitive movables has been brought down dramatically.
with get_hearers_in_view_oranges_ear() being the benchmark proc that implements this system and get_hearers_in_view() being a slightly optimized version of the version we have on master, get_hearers_in_view_as() being a more optimized version of the one we have on master, and get_hearers_in_LOS() being the raycasting version currently only used for radios because it cant replicate view()'s behavior perfectly.
Implements the Modernizing radiation design document ( https://hackmd.io/@tgstation/rJNIyeBHt ) and replaces the current radiation sources with the new system, as well as replacing/removing a bunch of old consumers of radiation that either had no reason to exist, or could be replaced by something else.
Diverges from the doc in that items radiation don't go up like explained. I was going to, but items get irradiated so easily that it just feels pretty lame. Items still get irradiated, but it's mostly just so that radiation sources look cooler (wow, lots of stuff around going green), and for things like the geiger counter.
Instead of the complicated radiation_wave system, radiation now just checks everything between the radiation source and the potential target, losing power along the way based on the radiation insulation of whats in between. If this reaches too low a point (specified by radiation_pulse consumers), then the radiation will not pass. Otherwise, will roll a chance to irradiate. Uranium structures allow a delay before irradiating, so stay away!
Done using this command sed -Ei 's/(\s*\S+)\s*\t+/\1 /g' code/**/*.dm
We have countless examples in the codebase with this style gone wrong, and defines and such being on hideously different levels of indentation. Fixing this to keep the alignment involves tainting the blames of code your PR doesn't need to be touching at all. And ultimately, it's hideous.
There are some files that this sed makes uglier. I can fix these when they are pointed out, but I believe this is ultimately for the greater good of readability. I'm more concerned with if any strings relied on this.
Hi codeowners!
Co-authored-by: Jared-Fogle <35135081+Jared-Fogle@users.noreply.github.com>
This PR adds the backblast element, which when attached to a gun, creates giant plumes of fire when said gun is fired. The PM9 rocket launcher that nuke ops can buy kinda sucks and even a direct hit with the standard rockets loaded isn't enough to guarantee a one-hit crit on a direct hit against an armored opponent, which sucks for how much you pay for it. In that vein, I've also buffed the standard rockets a bit, they now do 50 brute up from 30 on a direct hit, and they create flames on their explosion.
Also makes a tweak to /proc/get_turf_in_angle(), since tile coordinates start at 1,1 instead of 0,0 that proc is now clamped to min 1,1 rather than 0,0
* In the jungle, the mighty jungle the lion sleeps tonight
* AHHHHHH
* fix on the define
* even better define
* changes
* better define measurements and use
* better define name
* Process procs now properly use deltatime when implementing rates, timers and probabilities
* Review fixes
* Geiger counters cleanup
Made hardsuit geiger code more similar to geiger counter code
Geiger counters are more responsive now
* Moved SS*_DT defines to subsystems.dm
* Rebase fix
* Redefined the SS*_DT defines to use the subsystem wait vars
* Implemented suggested changes by @AnturK
* Commented /datum/proc/process about the deltatime stuff
* Send delta_time as a process parameter instead of the defines
Also DTfied acid_processing
* Dtfied new acid component
About The Pull Request
Port the dynamic gamemode from /vg/.
(Really bad explanation of the mode incoming.)
The dynamic game mode generates a threat number which is used to "buy" rulesets (rulesets are basically your antagonists). This means you can have rounds with for example traitors and cult (you can have up to three roundstart rulesets depending on the pop and threat level), and then there are latejoin and midround rulesets which basically do what they say (latejoin ruleset assigns late joining player as an antagonists and midround assigns ghosts or a currently alive player as an antagonist)
Why It's Good For The Game
This increases the chances of people getting their important antagonist role and makes rounds more interesting (when cultists gets their hand on wizard's magic) when everything can happen at the same time (cult, wiz and traitor could happen on high threat level).
Changelog
cl
add: Ported dynamic mode from /vg/, originally made by DeityLink, Kurfursten and ShiftyRail
/cl
Adds spell cards. They're a wizard spell that shoots a burst of 5 semi-accurate homing cards.
Projectiles now have a homing framework, complete with some variant of simulated inaccuracy.
The said wizard spell will make use of a new mob component, that allows that mob to select targets by moving their cursor near them. It will give a visual and lock onto the nearest mob to the cursor, allowing the homing projectiles to target on the locked on mob/object.
Removes colliding variable from projectiles - We never used it after Bump was refactored to Collide.
Images soon when I get the lockon datum-components to work.
* Revert "all this wrapping and it's not even christmas (#33035)"
This reverts commit faaf151580.
* Revert "fuck me for forgetting to graph this one"
This reverts commit 45d7acea2f.
* Revert "defines math"
This reverts commit 2817a1737b.
