From: 2weiEmu Date: Tue, 3 Feb 2026 00:14:30 +0000 (+0100) Subject: added a lot more nebulous notes, and started doing some more proactive research X-Git-Url: https://git.saalbach.dev/?a=commitdiff_plain;h=19ddb95b0389649dbefaf8688831d6b2af06df49;p=research-obsidian.git added a lot more nebulous notes, and started doing some more proactive research --- diff --git a/.obsidian/app.json b/.obsidian/app.json index 299bb40..43721a7 100644 --- a/.obsidian/app.json +++ b/.obsidian/app.json @@ -10,5 +10,6 @@ "downscalePercent": 80 }, "promptDelete": false, - "openBehavior": "file:List of things to do" + "openBehavior": "file:List of things to do", + "readableLineLength": false } \ No newline at end of file diff --git a/.obsidian/workspace.json b/.obsidian/workspace.json index 5589dea..48ce2f2 100644 --- a/.obsidian/workspace.json +++ b/.obsidian/workspace.json @@ -177,6 +177,9 @@ }, "active": "04094233c3d02ad2", "lastOpenFiles": [ + "Nebulous Command/calc.py~", + "Nebulous Command/calc.py", + "Nebulous Command/Notes on Mechanics.md~", "List of things to do.md", "Nebulous Command/Notes on Mechanics.md", "Nebulous Command/ANS/My Fleets/ANS Dedicated/Battle Report 1.md", @@ -209,10 +212,8 @@ "University/Algorithm Design/Full Notes - Run 2.md", "Pasted image 20251207164533.png", "Daily/16-01-2025.md", - "Dead Poet's Society/Some Notes.md", "Bundesverfassungsgericht/Urteil_des_Ersten_Senats_vom_5_November_2019.pdf", "Poems that I like", - "Robert's Opsec Policy", "Pasted image 20251106230015.png", "Pasted image 20251106225651.png", "Pasted image 20251106225645.png", @@ -221,7 +222,6 @@ "Pasted image 20251106224445.png", "Pasted image 20251106224411.png", "Pasted image 20251106224329.png", - "Pasted image 20251106223635.png", - "Diary and thoughts" + "Pasted image 20251106223635.png" ] } \ No newline at end of file diff --git a/Nebulous Command/Notes on Mechanics.md b/Nebulous Command/Notes on Mechanics.md index e69de29..db021b1 100644 --- a/Nebulous Command/Notes on Mechanics.md +++ b/Nebulous Command/Notes on Mechanics.md @@ -0,0 +1,102 @@ +Why does this document exist? Basically I just wanna explore what is the best way to build a solid _combat_ fleet in Nebulous. I.e. capable of winning fair 3000 point on 3000 point 1v1s, and perhapsperforming supporting roles in a match. + + +for all of this, btw, i am using the "hoodedhorse" version of the wiki, at least for the initial research + +# E-War + +the first thing that I want to deal with is ewar, as in Nebulous the concept of seeing first, or being seen first can do a lot to make a difference in a battle. At what range your missiles are detected, or can be intercepted. +If the person is able to find the launch platform, providing intel for your carriers, all that kinda stuff and as far as I am aware the two main mechanics on this are _comms_ and _radar_. + +## Cross-sections +The cross sections of different ships +| Ship | Cross Section (m^2) | -10% | -25% | -35% | +| -------------------- | ------------------- | -------- | -------- | -------- | +| Sprinter (Corvette) | 2890 | 2601 | 2167.5 | 1878.5 | +| Raines (FF) | 3783 | 3404.7 | 2837.25 | 2458.95 | +| Keystone (DD) | 6281 | 5652.9 | 4710.75 | 4082.65 | +| Vauxhall (CL) | 11727 | 10554.30 | 8795.25 | 7622.55 | +| Axford (HC) | 14332 | 12898.80 | 10749.00 | 9315.80 | +| Solomon (BB) | 27876 | 25088.40 | 20907.00 | 18119.40 | +| Ferryman (Corvette) | 2890 | 2601 | 2167.5 | 1878.5 | +| Draugr (FF) | 4685 | 4216.50 | 3513.75 | 3045.25 | +| Flathead (DD) | 9869 | 8882.10 | 7401.75 | 6414.85 | +| Ocello (HC) | 15745 | 14170.50 | 11808.75 | 10234.25 | +| Marauder (BB) | 15745 | 14170.50 | 11808.75 | 10234.25 | +| Moorline (BB) | 15745 | 14170.50 | 11808.75 | 10234.25 | + + +Turning off the radar: -25% signature +Turning comms to RECEIVE: -10% signature +(in the table Im assuming that this basically results in a total 35% reduction, if both are combined) + +Radars have factors: + +Radiated Power $P_t$ +Gain $G$ +Aperture Size $A$ +Sensitivitry $S$ +Noise Filtering $v$ +and for fire control radars: minimum signal-to-noise, $SNR$ + + +(there is a weird note at the top of the document, it reads: "The units are omitted here; use the values as you see them in-game, except divide the radar signature (cross-section) by 10) - check this, this may be outdated. + +Given the Radar Cross Section (RCS) of a ship $\sigma$ at distance $d$, the reutrned power density $P_r$ is calculated using + +$$P_r = \frac{\left ( \frac{P_tG\sigma A}{4\pi d^2}\right )G}{4\pi d^2}=\frac{P_tG^2\sigma A}{16\pi^2d^4}$$ +Burn through: $P_t$ = $P_t * \text{Burn-Through Power Multiplier}$ +Check every frame for new targets. Update and Recalc. every 0.25 seconds. + +also is according to the formula P_r in kWdB? weird unit but aight. probably works into noise calculations or something + +i also assume here that distances is in meters (see the code I guess for why this is semi importa,t but that is the main way the units cancel out like that which would also make sense to me) + +Some stats for the relevant radars on these things: + +| Radar | Radiated Power (kW) | Gain (dB) | Aperture Size (m^2) | Sensitivity (dBm) | Noise Filtering (dB) | Min. Signal to Noise | BRN Multiplier | Max. Range (km) | +| --------------- | ------------------- | --------- | ------------------- | ----------------- | -------------------- | -------------------- | -------------- | --------------- | +| RF101 | 1500 | 80 | 20 | - | 0 | - | - | 9 | +| RM50 | 4100 | 50 | 30 | -38.5 | 0 | - | 12 | 9.5 | +| RS35 | 3500 | 40 | 25 | -36 | 0 | - | 8 | 8 | +| RS41 | 4500 | 60 | 40 | -38.5 | 0 | - | - | 11.5 | +| R400 LRT | 5000 | 70 | 100 | -38 | 0 | - | - | 14 | +| R550 EWR | 3500 | 50 | 250 | -36 | 0 | - | - | 18 | +| RF44 | 1500 | 60 | 40 | - | 0 | - | - | 6.5 | +| Bulwak Huntress | 4000 | 40 | 60 | -38 | 0 | - | 4 | 10 | +| Ithaca | 3100 | 40 | 60 | -34 | 0 | - | - | 8.5 | +(do note that not all radars can lock targets) + +Make sure not to forget the existence of the neb calculator in this folder + +## noise + +Effective radar range is often limited by noise. Wow. +Return power vs. Background noise: +Background noise 1 x 10^-7 +if the return power is less than that, the target is not seen. Noise filtering doesn't reduce this. + +It also has to be able to distinguish real signals from jamming + +the noise this adds to the radar (at the effective jamming power at that distance for the ship + for every jammer added up - we call that $J$ here.) +the felt noise is: +$$N=(1\times10^{-7}+JG)\times10^{v/10}$$ + +Search Radars need higher return power than the felt noise $P_r > N$ to see targets. If the return signal from the target also beats signal loss, the target is seen and a track appears. + +Fire Control Radars (FCRs) require a higher siganl return power than noise ratio (SNR) than the min. required SNR to lock $$10\log_{10}\left(\frac{P_r}{N}\right)>SNR$$ +FCRs are not restricted by background noise floors so noise filtering will reduce background noise for locking and increase range. Wow. + +## signal loss +search radarsalso need enough sensitivity (S) to distinguish targets and beat signal loss in order to see them +Signal loss is calculated from return power +$$S_L=10\log_{10}\left(\frac{P_r}{0.001}\right)$$ +If the sensitivty is less than signal loss $S < S_L$ then the target is seen. + +therefore max benefit is at -40dB, as at that point background noise becomes the limiting factor. +FCR has no sensitivity stat, therefore not affected by signal loss. Cool. + +you can lock multiple missiles if you have multiple fcrs. locks function mostlyl ike regular traacks. Can only lock max. 1 ship though. + + + diff --git a/Nebulous Command/calc.py b/Nebulous Command/calc.py new file mode 100644 index 0000000..2a1d071 --- /dev/null +++ b/Nebulous Command/calc.py @@ -0,0 +1,166 @@ +from dataclasses import dataclass +import math +# Data / Data-Sheets basically +# --- ships --- + +padding = 16 + + +@dataclass +class Ship: + name: str + rcs_m2: float + + +ships = [ + Ship("Sprinter", 2601), + Ship("Raines", 3783), + Ship("Keystone", 6281), + Ship("Vauxhall", 11727), + Ship("Axford", 14332), + Ship("Solomon", 27876), + Ship("Ferryman", 2601), + Ship("Draugr", 4685), + Ship("Flathead", 9869), + Ship("Ocello", 15745), + Ship("Marauder", 15745), + Ship("Moorline", 15745) +] + + +@dataclass +class Radar: + name: str + radiated_power_kw: int + gain_db: int + aperture_size_m2: int + sensitivity_dBm: float + noise_filtering_dB: int + burnthrough_multiplier: int + max_range_km: float + + +# for Return Power Density Calculations +radars = [ + Radar("RF101", 1500, 80, 20, 0, 0, 0, 9), + Radar("RM50", 4100, 50, 30, -38.5, 0, 12, 9.5), + Radar("RS35", 3500, 40, 25, -36, 0, 8, 8), + Radar("RS41", 4500, 60, 40, -38.5, 0, 0, 11.5), + Radar("R400", 5000, 70, 100, -38, 0, 0, 14), + Radar("R550", 3500, 50, 250, -36, 0, 0, 18), + Radar("RF44", 1500, 60, 40, 0, 0, 0, 6.5), + Radar("Bulwark Huntress", 4000, 40, 60, -38, 0, 4, 10), + Radar("Ithaca", 3100, 40, 60, -34, 0, 4, 8.5), +] + + +def select_ship() -> Ship: + print("Select the index of the ship you want") + for i, ship in enumerate(ships): + print(f"{i+1}: {ship.name}") + i = int(input(":")) + return ships[i - 1] + + +def select_radar() -> Radar: + print("Select the index of the radar you want") + for i, radar in enumerate(radars): + print(f"{i+1}: {radar.name}") + i = int(input(":")) + return radars[i - 1] + + +def calculate_raw_return_power( + radiated_power, gain, rcs, aperture_size, distance): + top_half = radiated_power * (gain ** 2) * (rcs / 10) * aperture_size + bottom_half = 16 * (math.pi ** 2) * (distance ** 4) + + return top_half / bottom_half + + +def calc_rpd(): + default_distances = [500, 2000, 5000, 8000, 10000] + s = select_ship() + r = select_radar() + + d = int(input("Select a specific distance you want to calculate for: ")) + + # the formula for the return power density: + # will be dividing rcs by 10, according to the one note + print(f"Return power at distances for {s.name} using {r.name}") + for distance in default_distances: + print(f"""{str(calculate_raw_return_power( + r.radiated_power_kw, r.gain_db, s.rcs_m2, + r.aperture_size_m2, distance + )).ljust(padding)} | {distance}""") + + print(f"""{str(calculate_raw_return_power( + r.radiated_power_kw, r.gain_db, s.rcs_m2, + r.aperture_size_m2, d + )).ljust(padding)} | {d}""") + + +def calculate_distance_noise_floor_radar(radiated_power, gain, rcs, aperture_size): + top_half = radiated_power * (gain ** 2) * (rcs / 10) * aperture_size + bottom_half = (1 * (10 ** -7) * 16 * (math.pi ** 2)) + return ((top_half / bottom_half) ** 0.25) + + +def calculate_distance_signal_loss_floor_radar(radiated_power, gain, rcs, aperture_size, sensitivity): + if sensitivity == 0: + return 0 + + alpha = (10 ** (sensitivity / 10)) / 1000 + + top_half = radiated_power * (gain ** 2) * (rcs / 10) * aperture_size + bottom_half = 16 * (math.pi ** 2) * alpha + return (top_half / bottom_half) ** 0.25 + + +def calculate_distance_hidden(): + # we want to calculate the distance at which + # we will be hidden from an enemy ships + # that is using a certain radar. Assuming no jamming and no burn throughs. + s = select_ship() + r = select_radar() + + rcs_modifiers = [1, 0.9, 0.75, 0.65] + + print(f"The noise floor distance for {s.name} using {r.name}") + for m in rcs_modifiers: + print(f"""{ + calculate_distance_noise_floor_radar( + r.radiated_power_kw, r.gain_db, s.rcs_m2 * m, + r.aperture_size_m2 + ):.2f}m with rcs modifier: {m}""") + + print(f"The sensitivity distance floor for {s.name} using {r.name}") + for m in rcs_modifiers: + print(f"""{ + calculate_distance_signal_loss_floor_radar( + r.radiated_power_kw, r.gain_db, s.rcs_m2 * m, + r.aperture_size_m2, r.sensitivity_dBm + ):.2f}m with rcs modifier: {m}""") + + +def print_options(): + for i, o in enumerate(options): + print(f"{i+1}: {o[0]}") + + +options = [ + ["Calculate Return Power Density for Ship and Radar", calc_rpd], + ["Calculate the distance at which the ship should be hidden", + calculate_distance_hidden] +] + + +def main(): + # find out what the person wants to calculate, then call that + print_options() + i = int(input(":")) + options[i - 1][1]() + + +if __name__ == "__main__": + main()