cyberpresidentvanellope/Bubberstation
1
0
Fork 0
mirror of https://github.com/Bubberstation/Bubberstation.git synced 2026-07-11 16:14:08 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
mayfools
Bubberstation/code/datums/components/damage_aura.dm
T
Joshua Kidder 7a3ad79506 All camelCase (Brute|Burn|Fire|Tox|Oxy|Organ|Stamina)(Loss) procs now use snake_case. UNDERSCORES RULE! (#94111) 
## About The Pull Request
It's just a partial cleanup of
anti-[STYLE](https://github.com/tgstation/tgstation/blob/master/.github/guides/STYLE.md)
code from /tg/'s ancient history. I compiled & tested with my helpful
assistant and damage is still working.

<img width="1920" height="1040" alt="image"
src="https://github.com/user-attachments/assets/26dabc17-088f-4008-b299-3ff4c27142c3"
/>


I'll upload the .cs script I used to do it shortly.

## Why It's Good For The Game
Just minor code cleanup.

Script used is located at https://metek.tech/camelTo-Snake.7z

EDIT 11/23/25: Updated the script to use multithreading and sequential
scan so it works a hell of a lot faster
```
/*
//
Copyright 2025 Joshua 'Joan Metekillot' Kidder

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
//
*/
using System.Text.RegularExpressions;
class Program
{
    static async Task Main(string[] args)
    {
        var readFile = new FileStreamOptions
        {
            Access = FileAccess.Read,
            Share = FileShare.ReadWrite,
            Options = FileOptions.Asynchronous | FileOptions.SequentialScan
        };
        FileStreamOptions writeFile = new FileStreamOptions
        {
            Share = FileShare.ReadWrite,
            Access = FileAccess.ReadWrite,
            Mode = FileMode.Truncate,
            Options = FileOptions.Asynchronous
        };
        RegexOptions regexOptions = RegexOptions.Multiline | RegexOptions.Compiled;
        Dictionary<string, int> changedProcs = new();
        string regexPattern = @"(?<=\P{L})([a-z]+)([A-Z]{1,2}[a-z]+)*(Brute|Burn|Fire|Tox|Oxy|Organ|Stamina)(Loss)([A-Z]{1,2}[a-z]+)*";
        Regex camelCaseProcRegex = new(regexPattern, regexOptions);

        string snakeify(Match matchingRegex)
        {
            var vals =
            matchingRegex.Groups.Cast<Group>().SelectMany(_ => _.Captures).Select(_ => _.Value).ToArray();
            var newVal = string.Join("_", vals.Skip(1).ToArray()).ToLower();
            string logString = $"{vals[0]} => {newVal}";
            if (changedProcs.TryGetValue(logString, out int value))
            {
                changedProcs[logString] = value + 1;
            }
            else
            {
                changedProcs.Add(logString, 1);
            }
            return newVal;
        }
        var dmFiles = Directory.EnumerateFiles(".", "*.dm", SearchOption.AllDirectories).ToAsyncEnumerable<string>();

        // uses default ParallelOptions
        // https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.paralleloptions?view=net-10.0#main
        await Parallel.ForEachAsync(dmFiles, async (filePath, UnusedCancellationToken) =>
        {
            var reader = new StreamReader(filePath, readFile);
            string oldContent = await reader.ReadToEndAsync();
            string newContent = camelCaseProcRegex.Replace(oldContent, new MatchEvaluator((Func<Match, string>)snakeify));
            if (oldContent != newContent)
            {
                var writer = new StreamWriter(filePath, writeFile);
                await writer.WriteAsync(newContent);
                await writer.DisposeAsync();
            }
            reader.Dispose();
        });
        var logToList = changedProcs.Cast<KeyValuePair<string, int>>().ToList();
        foreach (var pair in logToList)
        {
            Console.WriteLine($"{pair.Key}: {pair.Value} locations");
        }
    }
}

```

## Changelog
🆑 Bisar
code: All (Brute|Burn|Fire|Tox|Oxy|Organ|Stamina)(Loss) procs now use
snake_case, in-line with the STYLE guide. Underscores rule!
/🆑
2025-11-27 15:50:23 -05:00

160 lines
5.4 KiB
Plaintext
Raw Permalink Blame History

#define DAMAGE_EFFECT_COOLDOWN (1 SECONDS)
/// Applies a status effect and deals damage to people in the area.
/// Will deal more damage the more people are present.
/datum/component/damage_aura
/// The range of which to damage
var/range = 5
/// Whether or not you must be a visible object of the parent
var/requires_visibility = TRUE
/// Brute damage to damage over a second
var/brute_damage = 0
/// Burn damage to damage over a second
var/burn_damage = 0
/// Toxin damage to damage over a second
var/toxin_damage = 0
/// Suffocation damage to damage over a second
var/suffocation_damage = 0
/// Stamina damage to damage over a second
var/stamina_damage = 0
/// Amount of blood to damage over a second
var/blood_damage = 0
/// Map of organ (such as ORGAN_SLOT_BRAIN) to damage damage over a second
var/list/organ_damage = null
/// Amount of damage to damage on simple mobs over a second
var/simple_damage = 0
/// Which factions are immune to the damage aura
var/list/immune_factions = null
/// If set, gives a message when damaged
var/damage_message = null
/// Probability for above.
var/message_probability = 0
/// Sets a special set of conditions for the owner
var/datum/weakref/current_owner = null
/// Declares the cooldown timer for the damage aura effect to take place
COOLDOWN_DECLARE(last_damage_effect_time)
/datum/component/damage_aura/Initialize(
range = 5,
requires_visibility = TRUE,
brute_damage = 0,
burn_damage = 0,
toxin_damage = 0,
suffocation_damage = 0,
stamina_damage = 0,
blood_damage = 0,
organ_damage = null,
simple_damage = 0,
immune_factions = null,
damage_message = null,
message_probability = 0,
mob/living/current_owner = null,
)
if (!isatom(parent))
return COMPONENT_INCOMPATIBLE
START_PROCESSING(SSaura, src)
src.range = range
src.requires_visibility = requires_visibility
src.brute_damage = brute_damage
src.burn_damage = burn_damage
src.toxin_damage = toxin_damage
src.suffocation_damage = suffocation_damage
src.stamina_damage = stamina_damage
src.blood_damage = blood_damage
src.organ_damage = organ_damage
src.simple_damage = simple_damage
src.immune_factions = immune_factions
src.damage_message = damage_message
src.message_probability = message_probability
src.current_owner = WEAKREF(current_owner)
/datum/component/damage_aura/Destroy(force)
STOP_PROCESSING(SSaura, src)
return ..()
/// The requirements for the mob to be effected by the damage aura.
/datum/component/damage_aura/proc/check_requirements(mob/living/target_mob)
if(target_mob.stat == DEAD || faction_check(target_mob.faction, immune_factions))
return TRUE
return FALSE
/// What effect the damage aura has if it has an owner.
/datum/component/damage_aura/proc/owner_effect(mob/living/owner_mob, seconds_per_tick)
var/need_mob_update = FALSE
need_mob_update += owner_mob.adjust_stamina_loss(-20 * seconds_per_tick, updating_stamina = FALSE)
need_mob_update += owner_mob.adjust_brute_loss(-1 * seconds_per_tick, updating_health = FALSE)
need_mob_update += owner_mob.adjust_fire_loss(-1 * seconds_per_tick, updating_health = FALSE)
need_mob_update += owner_mob.adjust_tox_loss(-1 * seconds_per_tick, updating_health = FALSE, forced = TRUE)
need_mob_update += owner_mob.adjust_oxy_loss(-1 * seconds_per_tick, updating_health = FALSE)
owner_mob.adjust_blood_volume(2 * seconds_per_tick, maximum = BLOOD_VOLUME_NORMAL)
if(need_mob_update)
owner_mob.updatehealth()
/datum/component/damage_aura/process(seconds_per_tick)
var/should_show_effect = COOLDOWN_FINISHED(src, last_damage_effect_time)
if (should_show_effect)
COOLDOWN_START(src, last_damage_effect_time, DAMAGE_EFFECT_COOLDOWN)
var/list/to_damage = list()
if(requires_visibility)
for(var/mob/living/candidate in view(range, parent))
to_damage += candidate
else
for(var/mob/living/candidate in range(range, parent))
to_damage += candidate
for (var/mob/living/candidate as anything in to_damage)
var/mob/living/owner = current_owner?.resolve()
if (owner && owner == candidate)
owner_effect(owner, seconds_per_tick)
continue
if (check_requirements(candidate))
continue
if (candidate.health < candidate.maxHealth)
new /obj/effect/temp_visual/cosmic_gem(get_turf(candidate))
if(damage_message && prob(message_probability))
to_chat(candidate, damage_message)
if (iscarbon(candidate) || issilicon(candidate) || isbasicmob(candidate))
candidate.adjust_brute_loss(brute_damage * seconds_per_tick, updating_health = FALSE)
candidate.adjust_fire_loss(burn_damage * seconds_per_tick, updating_health = FALSE)
if (iscarbon(candidate))
candidate.adjust_tox_loss(toxin_damage * seconds_per_tick, updating_health = FALSE)
candidate.adjust_oxy_loss(suffocation_damage * seconds_per_tick, updating_health = FALSE)
candidate.adjust_stamina_loss(stamina_damage * seconds_per_tick, updating_stamina = FALSE)
for (var/organ in organ_damage)
candidate.adjust_organ_loss(organ, organ_damage[organ] * seconds_per_tick)
else if (isanimal(candidate))
var/mob/living/simple_animal/animal_candidate = candidate
animal_candidate.adjustHealth(simple_damage * seconds_per_tick, updating_health = FALSE)
else if (isbasicmob(candidate))
var/mob/living/basic/basic_candidate = candidate
basic_candidate.adjust_health(simple_damage * seconds_per_tick, updating_health = FALSE)
candidate.adjust_blood_volume(blood_damage * seconds_per_tick, minimum = BLOOD_VOLUME_SURVIVE)
candidate.updatehealth()
#undef DAMAGE_EFFECT_COOLDOWN
Reference in New Issue View Git Blame Copy Permalink