arcadesynth 1.0.1__tar.gz

arcadesynth-1.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 C. Martin Richardson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

arcadesynth-1.0.1/MANIFEST.in

@@ -0,0 +1,3 @@
+# MANIFEST.in
+
+include src/arcadesynth/*.toml

arcadesynth-1.0.1/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: arcadesynth
+Version: 1.0.1
+Summary: Programmatically synthesize retro arcade sound effects
+Author-email: "C. Martin Richardson" <c.mart.richardson@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 C. Martin Richardson
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/martianmr/arcadesynth
+Keywords: arcade,synth,retro
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: scipy>=1.17.1
+Requires-Dist: tomli; python_version < "3.11"
+Provides-Extra: dev
+Requires-Dist: pygame; extra == "dev"
+Requires-Dist: bumpver; extra == "dev"
+Dynamic: license-file
+
+# arcadesynth 1.0.1
+
+Programmatically synthesize retro arcade sound effects with arcadesynth
+
+This utility can be used to generate your own custom sound effects in code as an alternative to using sound assets. It also provides some hand-crafted sounds from the Golden age of arcade video games.
+
+The idea was inspired by sound generation on 1980s 8-bit microcomputers which sometimes had fairly sophisticated synthesizer chips which could be programmed at a low level with a bit of know-how. The algorithms are kept fairly simple but are capable of approximating early arcade, console and computer game sounds that are generated with specialized chips or custom electronics.
+
+## Installation
+
+arcadesynth can be installed via pip
+
+```bash
+pip install arcadesynth
+```
+
+## Modules
+
+- synth - functions to build your own effects
+- synth_sample - some simple basic sounds
+- synth_example - some generic retro sound effects
+- synth_asteroids - sounds from the 1979 Atari game Asteroids
+- synth_spaceinvaders - sounds from the 1978 Taito game Asteroids
+
+## Synth
+
+This module can be used to create custom sound effects by generating waves or white noise and then manipulating the signal with envelopes, filters and more.
+
+E.g. synthesize a retro gunshot sound in pygame.
+
+```python
+import pygame
+from arcadesynth import synth
+
+pygame.init()
+pygame.mixer.init()
+ms = 500 # Length of buffer will be 500 milliseconds
+buf = synth.make_white(ms, 1.0) # Fill buffer with white noise
+buf = synth.lowpass_filter(buf, 1200.0, order=4) # Apply a filter to remove higher frequencies
+synth.noisalise(buf, gain=0.5) # Even out the amplitude of the noise
+synth.envelope(buf, 20, 30, 0.2, ms - 10) # Apply an envelope with a short attack and release and then fade off from 20% amplitude
+sound = pygame.mixer.Sound(synth.tobytes(buf))
+sound.play()
+```
+
+## Space Invaders
+
+There are some built-in hand-crafted synthesized sounds including those from the 1978 classic Space Invaders by Taito. Sounds in the arcade machine are produced on a Texas Instruments SN76477 'complex sound generator' chip supported by custom electronics. 
+
+E.g. synthesize the sound made by the flying saucer blowing up in Space Invaders.
+
+```python
+import pygame
+from arcadesynth import synth_spaceinvaders as si
+
+pygame.init()
+pygame.mixer.init()
+sound = pygame.mixer.Sound(si.si_ufodie())
+sound.play()
+```
+
+## LICENSE
+
+MIT License — See the [LICENSE](LICENSE) file for details.

arcadesynth-1.0.1/README.md

@@ -0,0 +1,64 @@
+# arcadesynth 1.0.1
+
+Programmatically synthesize retro arcade sound effects with arcadesynth
+
+This utility can be used to generate your own custom sound effects in code as an alternative to using sound assets. It also provides some hand-crafted sounds from the Golden age of arcade video games.
+
+The idea was inspired by sound generation on 1980s 8-bit microcomputers which sometimes had fairly sophisticated synthesizer chips which could be programmed at a low level with a bit of know-how. The algorithms are kept fairly simple but are capable of approximating early arcade, console and computer game sounds that are generated with specialized chips or custom electronics.
+
+## Installation
+
+arcadesynth can be installed via pip
+
+```bash
+pip install arcadesynth
+```
+
+## Modules
+
+- synth - functions to build your own effects
+- synth_sample - some simple basic sounds
+- synth_example - some generic retro sound effects
+- synth_asteroids - sounds from the 1979 Atari game Asteroids
+- synth_spaceinvaders - sounds from the 1978 Taito game Asteroids
+
+## Synth
+
+This module can be used to create custom sound effects by generating waves or white noise and then manipulating the signal with envelopes, filters and more.
+
+E.g. synthesize a retro gunshot sound in pygame.
+
+```python
+import pygame
+from arcadesynth import synth
+
+pygame.init()
+pygame.mixer.init()
+ms = 500 # Length of buffer will be 500 milliseconds
+buf = synth.make_white(ms, 1.0) # Fill buffer with white noise
+buf = synth.lowpass_filter(buf, 1200.0, order=4) # Apply a filter to remove higher frequencies
+synth.noisalise(buf, gain=0.5) # Even out the amplitude of the noise
+synth.envelope(buf, 20, 30, 0.2, ms - 10) # Apply an envelope with a short attack and release and then fade off from 20% amplitude
+sound = pygame.mixer.Sound(synth.tobytes(buf))
+sound.play()
+```
+
+## Space Invaders
+
+There are some built-in hand-crafted synthesized sounds including those from the 1978 classic Space Invaders by Taito. Sounds in the arcade machine are produced on a Texas Instruments SN76477 'complex sound generator' chip supported by custom electronics. 
+
+E.g. synthesize the sound made by the flying saucer blowing up in Space Invaders.
+
+```python
+import pygame
+from arcadesynth import synth_spaceinvaders as si
+
+pygame.init()
+pygame.mixer.init()
+sound = pygame.mixer.Sound(si.si_ufodie())
+sound.play()
+```
+
+## LICENSE
+
+MIT License — See the [LICENSE](LICENSE) file for details.

arcadesynth-1.0.1/pyproject.toml

@@ -0,0 +1,56 @@
+# pyproject.toml
+
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "arcadesynth"
+version = "1.0.1"
+description = "Programmatically synthesize retro arcade sound effects"
+readme = "README.md"
+authors = [{ name = "C. Martin Richardson", email = "c.mart.richardson@gmail.com" }]
+license = { file = "LICENSE" }
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+]
+keywords = ["arcade", "synth", "retro"]
+dependencies = [
+    "scipy >= 1.17.1",
+    'tomli; python_version < "3.11"',
+]
+requires-python = ">=3.9"
+
+[project.optional-dependencies]
+dev = ["pygame", "bumpver"]
+
+[project.urls]
+Homepage = "https://github.com/martianmr/arcadesynth"
+
+[tool.bumpver]
+current_version = "1.0.1"
+version_pattern = "MAJOR.MINOR.PATCH"
+commit_message = "bump version {old_version} -> {new_version}"
+tag_message = "{new_version}"
+tag_scope = "default"
+pre_commit_hook = ""
+post_commit_hook = ""
+commit = true
+tag = true
+push = true
+allowed_branches = "main,develop,release*"
+
+[tool.bumpver.file_patterns]
+"pyproject.toml" = [
+    'current_version = "{version}"',
+    'version = "{version}"',
+]
+"README.md" = [
+    "{version}",
+]
+"src/arcadesynth/__init__.py" = [
+    "{version}"
+]
+

arcadesynth-1.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

arcadesynth-1.0.1/src/arcadesynth/__init__.py

@@ -0,0 +1,6 @@
+# __init__.py
+
+from importlib import resources
+
+# Version of the arcadesynth package
+__version__ = "1.0.1"

arcadesynth-1.0.1/src/arcadesynth/config.toml

@@ -0,0 +1 @@
+# config.toml

arcadesynth-1.0.1/src/arcadesynth/synth.py

@@ -0,0 +1,327 @@
+"""synth - programmatically synthesize retro arcade sound effects
+"""
+
+import array
+import math
+import random
+import numpy as np
+from scipy.signal import butter, filtfilt, medfilt
+
+DEFAULT_FREQUENCY = 44100
+DEFAULT_CHANNELS = 2
+MAX_LEN = 3600000
+SAMPLE_RATE = DEFAULT_FREQUENCY * DEFAULT_CHANNELS
+
+# ---------------------------------------------------------------------------
+# Internal functions
+# ---------------------------------------------------------------------------
+
+
+def _limit(d, limit = 1.0, llimit = None):
+    """Force value to a limit"""
+    return min(max(d, (-limit if llimit is None else llimit)), limit)
+
+
+def _butterworth_filter(buf, cutoff, type='lowpass', order=2):
+    """A butterworth filter to reduce unwanted frequencies, order 1 is lowest effect, 6 is more dramatic"""
+    nyq = 0.5 * SAMPLE_RATE
+    normal_cutoff = cutoff / nyq
+    b, a = butter(order, normal_cutoff, btype=type)
+    buf = array.array("d", filtfilt(b, a, buf))
+    return buf
+
+
+def _samplept(func, i, f, harmonics=0, p=[], special=None):
+    """Calculate amplitude of a sample for a buffer position
+
+    Given a function to calculate amplitude of a wave (func) for a buffer position (i)
+    and frequency (f) calculate and return the amplitude.
+    If harmonics is not zero also add in the amplitude of the given order of harmonics.
+    If frequency is not constant throughout the buffer, track the current phase during the
+    building process and pass the current phase of the primary and any harmonics through 
+    the list (p), otherwise phase can be calculated on the fly.
+    """
+    amp = 0.0
+    scaling = math.pow(2, harmonics) / (math.pow(2, harmonics + 1) - 1)
+    for h in range(harmonics + 1):
+        freq = f * (h + 1)
+        vol = (1.0 / (h + 1)) * scaling
+        dp = 2 * math.pi * freq / SAMPLE_RATE
+        if len(p) == 0:
+            phase = dp * i
+        else:
+            phase = p[h] = p[h] + dp
+        a = func(phase, special)
+        amp += a * vol
+    return amp if len(p) == 0 else (amp, p)
+
+
+# ---------------------------------------------------------------------------
+# Functions to calculate amplitude depending on phase
+# ---------------------------------------------------------------------------
+
+
+def sawtooth(phase, special = None):
+    """Calculate amplitude for a sawtooth wave at the given phase"""
+    return (2.0 / math.pi) * ((phase / 2.0) % math.pi) - 1.0
+
+
+def triangle(phase, special = None):
+    """Calculate amplitude for a triangle wave at the given phase"""
+    return ((2.0 / math.pi) * (math.pi - abs(phase % (2.0 * math.pi) - math.pi)) - 1.0)
+
+
+def square(phase, special = None):
+    """Calculate amplitude for a square wave at the given phase"""
+    cutoff = 0.0 if special is None else special
+    return 1.0 if math.sin(phase) > cutoff else -1.0
+
+
+def sin(phase, special = None):
+    """Calculate amplitude for a sine wave at the given phase"""
+    return math.sin(phase)
+
+
+# ---------------------------------------------------------------------------
+# Functions to manipulate buffers and return a new buffer
+# ---------------------------------------------------------------------------
+
+
+def init(frequency=DEFAULT_FREQUENCY, channels=DEFAULT_CHANNELS):
+    """Set up sample rate, do this first to avoid using defaults
+
+    E.g. get these values from pygame with 'frequency, _, channels = pygame.mixer.get_init()'
+    """
+    global SAMPLE_RATE
+    SAMPLE_RATE = frequency * channels
+    return
+
+
+def get_init():
+    return SAMPLE_RATE
+
+
+def tobytes(buf):
+    """Convert buffer with range -1.0 to 1.0 to short signed integers then output as a byte stream
+
+    Use this to convert a sound held in internal format to a byte list for external processing, e.g. by
+    pygame.
+    """
+    a = array.array("h")
+    for i in range(len(buf)):
+        a.append(int(_limit(buf[i]) * 32767))
+    return a.tobytes()
+
+
+def boost(buf, gain):
+    """Apply gain to buffer"""
+    nparray = np.array(buf)
+    npnew = nparray * gain
+    buf = array.array("d", npnew)
+    return buf
+
+
+def reverse(buf):
+    """Return backwards copy of the buffer"""
+    nparray = np.array(buf)
+    npnew = np.flip(nparray)
+    buf = array.array("d", npnew)
+    return buf
+
+def combine(buf1, buf2):
+    """Combine 2 buffers giving average amplitude for each sample
+    
+    N.b. buffers must be of identical length"""
+    nparray1 = np.array(buf1)
+    nparray2 = np.array(buf2)
+    npsummed = nparray1 + nparray2 / 2
+    buf = array.array("d", npsummed)
+    return buf
+
+
+def constrain(buf, lower, upper):
+    """Clip a buffer to an upper and lower constraint"""
+    nparray = np.array(buf)
+    np.clip(nparray, lower, upper, nparray)
+    buf = array.array("d", nparray)
+    return buf
+
+
+def vmove(buf, amount):
+    """Shift samples in the Y axis"""
+    nparray = np.array(buf)
+    nparray += amount
+    buf = array.array("d", nparray)
+    return buf
+
+
+def fade(buf, a1, a2):
+    """Change start and end amplitude and scale smoothly between"""
+    buf = boost(buf, a1)
+    ms = (len(buf) / SAMPLE_RATE) * 1000.0
+    envelope(buf, 0, ms, a2 / a1, 0)
+    return buf
+
+
+def noisalise(buf, vol = 1.0, gain = 1.0):
+    """Apply gain to buffer proportional to mean amplitude, useful for restoring a constant RMS after processing noise"""
+    data = np.array(buf)
+    av = (data[data > 0].mean() + -data[data < 0].mean()) / 2.0
+    r = gain / (av / 2.0)
+    for i in range(len(buf)):
+        buf[i] = _limit(buf[i], limit=vol / gain) * r * vol
+    return
+
+
+def slice(buf, start, end):
+    """Extract a section of a buffer with start and end times in ms"""
+    s = int(SAMPLE_RATE * start / 1000.0)
+    e = min(len(buf), int(SAMPLE_RATE * end / 1000.0))
+    return buf[s:e]
+
+
+def median_filter(buf):
+    """Perform a median filter"""
+    return array.array("d", medfilt(buf, kernel_size=5))
+
+
+def lowpass_filter(buf, cutoff, order=6):
+    """Apply a filter that progressively removes frequencies above the cutoff"""
+    return _butterworth_filter(buf, cutoff, type='lowpass', order=order)
+
+
+def highpass_filter(buf, cutoff, order=6):
+    """Apply a filter that progressively removes frequencies below the cutoff"""
+    return _butterworth_filter(buf, cutoff, type='highpass', order=order)
+
+
+# ---------------------------------------------------------------------------
+# Functions to create new buffers
+# ---------------------------------------------------------------------------
+
+
+def make_sawtooth(ms, vol=0.2, freq=140.0):
+    """Make a sawtooth wave"""
+    n = int(SAMPLE_RATE * ms / 1000.0)
+    buf = array.array("d")
+    for i in range(n):
+        buf.append(_samplept(sawtooth, i, freq) * vol)
+    return buf
+
+
+def make_triangle(ms, vol=0.2, freq=140.0):
+    """Make a triangle wave"""
+    n = int(SAMPLE_RATE * ms / 1000.0)
+    buf = array.array("d")
+    for i in range(n):
+        buf.append(_samplept(triangle, i, freq) * vol)
+    return buf
+
+
+def make_square(ms, vol=0.2, freq=140.0):
+    """Make a square wave"""
+    n = int(SAMPLE_RATE * ms / 1000.0)
+    buf = array.array("d")
+    for i in range(n):
+        buf.append(_samplept(square, i, freq) * vol)
+    return buf
+
+
+def make_sin(ms=600, vol=0.4, freq=50.0, harmonics=0):
+    """Make a sine wave"""
+    n = int(SAMPLE_RATE * ms / 1000.0)
+    buf = array.array("d")
+    for i in range(n):
+        a = _samplept(sin, i, freq, harmonics)
+        buf.append(a * vol)
+    return buf
+
+
+def make_white(ms=600, vol=0.4, smooth=False):
+    """Fill a buffer with random amplitudes to produce white noise
+
+    If smooth is False use values of 1.0 or -1.0 randomly to produce white noise similar to the SN76477 Complex Sound Generator chip,
+    otherwise generate purely random amplitudes which gives a more natural noise.
+    """
+    n = int(SAMPLE_RATE * ms / 1000.0)
+    buf = array.array("d")
+    random.seed(0)
+    rng = random.Random()
+    for _ in range(n):
+        r = rng.uniform(-1.0, 1.0) * vol
+        buf.append(r if smooth else 1.0 if r > 0.0 else -1.0)
+    return buf
+
+
+def make_brown(ms=600, vol=0.1, freq=150.0, order=1):
+    """Apply a lowpass filter to white noise to produce brown noise"""
+    buf = make_white(ms, vol)
+    buf = lowpass_filter(buf, freq, order)
+    return buf
+
+
+def make_sweep(ms=80, startf=1500.0, endf=400.0, shape=triangle, vol=1.0, repeat=0, harmonics=0, special=None):
+    """Create a buffer that starts at frequency startf and ends at endf
+
+    If repeat is not zero the cycle goes from startf to endf and back to startf in repeat milliseconds and
+    continues to cycle until ms milliseconds have been filled.
+    """
+    n = int(SAMPLE_RATE * ms / 1000.0)
+    loop = n * 2 if repeat == 0 else int(SAMPLE_RATE * repeat / 1000.0)
+    period = loop // 2
+    buf = array.array("d")
+    phase = [0.0 for _ in range(harmonics + 1)]
+    for i in range(n):
+        x = i % loop
+        if x > period:
+            x = loop - x
+        else:
+            pass
+        f = (startf - ((startf - endf) * (x / period) ))
+        a, phase = _samplept(shape, i, f, harmonics, phase, special)
+        buf.append(a * vol)
+    return buf
+
+
+# ---------------------------------------------------------------------------
+# Functions to manipulate buffers in place
+# ---------------------------------------------------------------------------
+
+
+def tremolo(buf, freq, intensity, shape=sin):
+    """Modify a buffer in place so that amplitude increases and decreases according to shape and intensity"""
+    for i in range(len(buf)):
+        phase = i * math.pi * freq / SAMPLE_RATE
+        buf[i] *= (1.0 - intensity) + abs(((shape(phase) + 1.0) / 2.0) * intensity)
+    return
+
+
+def envelope(buf, attack, decay, sustain, release, start=0, end=MAX_LEN):
+    """Modify a buffer in place with an ADSR envelope"""
+    attack_start = int(SAMPLE_RATE * start / 1000.0)
+    attack_end = min(len(buf), int(SAMPLE_RATE * (start + attack) / 1000.0))
+    decay_end = min(len(buf), int(SAMPLE_RATE * decay / 1000.0) + attack_end)
+    release_end = min(len(buf), int(SAMPLE_RATE * end / 1000.0))
+    sustain_end = min(len(buf), release_end - int(SAMPLE_RATE * release / 1000.0))
+    if attack != 0.0:
+        for i in range(attack_start, attack_end):
+            buf[i] *= (i - attack_start) / (attack_end - attack_start)
+    for i in range(attack_end, decay_end):
+        buf[i] *= ((decay_end - i) / (decay_end - attack_end)) * (1.0 - sustain) + sustain
+    for i in range(decay_end, sustain_end):
+        buf[i] *= sustain
+    for i in range(sustain_end, release_end):
+        buf[i] *= ((release_end - i) / (release_end - sustain_end)) * sustain
+    return
+
+
+def echo(buf, ms, vol):
+    """Modify buffer in place to add a short delay to the sound"""
+    delay = int(SAMPLE_RATE * ms / 1000.0)
+    for _ in range(delay):
+        buf.append(0.0)
+    for i in range(len(buf)):
+        buf[i] *= 1 - vol
+        if i >= delay:
+            buf[i] += buf[i - delay] * vol
+    return

arcadesynth-1.0.1/src/arcadesynth/synth_asteroids.py

@@ -0,0 +1,75 @@
+"""Asteroids sound effects"""
+from .synth import *
+
+
+def as_playerfire():
+    """Asteroids player firing sound"""
+    ms = 260
+    buf = make_sweep(ms, 820, 100, square, 1.0, 0, special=-0.8)
+    envelope(buf, 0, ms, 0.2, 0)
+    envelope(buf, 0, 100, 0.5, 0, 0, 100)
+    envelope(buf, 0, 0, 0.5, 0, 100, ms)
+    return tobytes(buf)
+
+
+def as_ufofire():
+    """Asteroids flying saucer firing sound"""
+    ms = 260
+    buf = make_sweep(ms, 820, 650, square, 1.0, 0, special=-0.8)
+    return tobytes(buf)
+
+
+def as_bump(freq = 81.516):
+    """Asteroids periodic heartbeat bump
+    
+    Expected frequencies in Hz, 81.516, 87.500
+    """
+    buf = make_square(50, 1.0, freq)
+    return tobytes(buf)
+
+
+def as_explode(freq = 200.0):
+    """Asteroids things blowing up
+    
+    Estimated frequencies:
+    Large rock   170 Hz
+    Medium Rock  220 Hz
+    Small Rock   270 Hz
+    
+    """
+    ms = 1000
+    buf = make_white(ms, 1.0)
+    buf = lowpass_filter(buf, freq, order=1)
+    noisalise(buf, gain=0.1)
+    envelope(buf, 20, 0, 1.0, ms)
+    return tobytes(buf)
+
+
+def as_ufo(ms, low, high):
+    """Asteroids flying saucer on screen noise
+    
+    Large 180, 600, 1400
+    Small 120, 800, 1600
+    """
+    buf = make_sweep(ms, low, high, triangle, 0.5, ms)
+    return tobytes(buf)
+
+
+def as_thrust():
+    """Asteroids player ship thrusting"""
+    buf = make_brown(1000, 0.5, 30, 1)
+    noisalise(buf, gain=0.12)
+    buf = median_filter(buf)
+    reversebuf = reverse(buf)
+    buf = buf + reversebuf
+    return tobytes(buf)
+
+
+def as_extralife():
+    """Asteroids extra life notification"""
+    buf = make_sin(1300, 0.5, 2940)
+    tremolo(buf, 16.8, 1.0, square)
+    return tobytes(buf)
+
+
+

arcadesynth-1.0.1/src/arcadesynth/synth_example.py

@@ -0,0 +1,30 @@
+"""Generic retro sound effects"""
+from .synth import *
+
+
+def eg_gunshot():
+    """Retro gunshot sound"""
+    ms = 500
+    buf = make_white(ms, 1.0)
+    buf = lowpass_filter(buf, 1200.0, order=4)
+    noisalise(buf, gain=0.5)
+    envelope(buf, 20, 30, 0.2, ms - 10)
+    return tobytes(buf)
+
+
+def eg_boom():
+    """A booming explosion"""
+    ms = 1500
+    buf = make_white(ms, 1.0)
+    buf = lowpass_filter(buf, 500.0, order=4)
+    noisalise(buf, gain=0.5)
+    envelope(buf, 20, 30, 0.2, ms - 10)
+    return tobytes(buf)
+
+
+def eg_zap():
+    """The sound of a Kill-o-Zap gun, probably"""
+    ms = 200
+    buf = make_sweep(ms, 1000, 200, triangle, 1.0, 0)
+    envelope(buf, 20, 30, 0.2, ms - 10)
+    return tobytes(buf)

arcadesynth-1.0.1/src/arcadesynth/synth_sample.py

@@ -0,0 +1,58 @@
+"""Basic sample sounds"""
+from .synth import *
+
+
+def sawtooth_wave(ms=1600, vol=1.0, freq=150.0):
+    """Return bytes representing a simple sawtooth wave"""
+    buf = make_sawtooth(ms, vol, freq)
+    return tobytes(buf)
+
+
+def triangle_wave(ms=1600, vol=1.0, freq=150.0):
+    """Return bytes representing a simple triangle wave"""
+    buf = make_triangle(ms, vol, freq)
+    return tobytes(buf)
+
+
+def sine_wave(ms=600, vol=1.0, freq=150.0):
+    """Return bytes representing a simple sine wave"""
+    buf = make_sin(ms, vol, freq)
+    return tobytes(buf)
+
+
+def square_wave(ms=90, vol=0.4, freq=144.0):
+    """Return bytes representing a simple square wave"""
+    buf = make_square(ms, vol, freq)
+    return tobytes(buf)
+
+
+def brown_noise(ms=600, vol=0.4, freq=150.0):
+    """Return bytes representing brown noise"""
+    buf = make_brown(ms, vol, freq)
+    return tobytes(buf)
+
+
+def white_noise(ms=600, vol=0.4, smooth=False):
+    """Return bytes representing white noise"""
+    buf = make_white(ms, vol, smooth)
+    return tobytes(buf)
+
+
+def sweep(ms=80, startf=1500.0, endf=100.0, shape=sin, vol=1.0, repeat=0):
+    """Return bytes representing a frequency sweep from startf to endf"""
+    buf = make_sweep(ms, startf, endf, shape, vol, repeat)
+    return tobytes(buf)
+
+
+def chord(ms=600, vol=0.4, f1=261.6256, f2=329.6276):
+    """Return bytes representing a 2 note chord"""
+    buf1 = make_square(ms, vol, freq=f1)
+    buf2 = make_square(ms, vol, freq=f2)
+    buf1 = combine(buf1, buf2)
+    return tobytes(buf1)
+
+
+def fadeup(ms=999, a1=0.2, a2=0.8):
+    buf = make_triangle(ms, 1.0, 261.6256)
+    buf = fade(buf, a1, a2)
+    return tobytes(buf)

arcadesynth-1.0.1/src/arcadesynth/synth_spaceinvaders.py

@@ -0,0 +1,120 @@
+"""Space Invaders sound effects"""
+from .synth import *
+
+
+def si_extralife():
+    """Space Invaders extra life notification"""
+    ms = 1360
+    buf1 = make_triangle(ms, 1.0, 490)
+    buf2 = make_sawtooth(ms, 1.0, 490)
+    buf = combine(buf1, buf2)
+    tremolo(buf, 120.0, 0.9, shape=triangle)
+    buf = boost(buf, 5.0)
+    envelope(buf, 20, 0, 1.0, 20, end=200)
+    for i in range(8):
+        s = i * 145 + 200
+        e = s + 135
+        mute = e + 10
+        envelope(buf, 30, 0, 0.9, 30, start=s, end=e)
+        envelope(buf, 0, 0, 0.0, 0, start=e, end=mute)
+    echo(buf, 30, 0.4)
+    return tobytes(buf)
+
+
+def si_ufodie():
+    """Space Invaders UFO exploding sound"""
+    low = 150.0
+    high = 1320.0
+    buf = make_sweep(2210, low, high, triangle, 0.5, 170)
+    envelope(buf, 10, 0, 1.0, 350)
+    echo(buf, 20, 0.3)
+    return tobytes(buf)
+
+
+def si_ufo():
+    """Space Invaders UFO on screen sound"""
+    low = 400.0
+    high = 1550.0
+    buf = make_sweep(170, low, high, square, 0.4, 170)
+    return tobytes(buf)
+
+
+def si_aliendie():
+    """Space Invaders enemy exploding sound"""
+    buf = array.array("d")
+    params = {
+        "amplitude" : (0.7, 0.7, 0.4, 0.3, 0.25),
+        "length" : (80, 80, 80, 100, 120)
+    }
+    for i in range(len(params["amplitude"])):
+        s = 1500.0 if i < len(params["amplitude"]) - 1 else 1900.0
+        f = 200.0 if 1 < len(params["amplitude"]) - 1 else 1100.0
+        tempbuf = make_sweep(params["length"][i], s, f, triangle, params["amplitude"][i], 0)
+        envelope(tempbuf, 5, 0, 1.0, 5)
+        buf += tempbuf
+    envelope(buf, 5, 0, 1.0, 300)
+    echo(buf, 20, 0.3)
+    return tobytes(buf)
+
+
+def si_explosion():
+    """Space Invaders player exploding sound"""
+    ms = 1600
+    buf = make_white(ms, 1.0)
+    buf = lowpass_filter(buf, 350.0, order=1)
+    noisalise(buf, gain=0.35)
+    buf = lowpass_filter(buf, 2600.0)
+    buf = median_filter(buf)
+    buf = lowpass_filter(buf, 2600.0)
+    envelope(buf, 20, 0, 1.0, 20, start=0, end=100)
+    envelope(buf, 20, 0, 1.0, 20, start=100, end=180)
+    envelope(buf, 5, 0, 0.1, 5, start=180, end=200)
+    envelope(buf, 20, 0, 1.0, 20, start=200, end=250)
+    envelope(buf, 20, 0, 1.0, 20, start=250, end=300)
+    envelope(buf, 20, 0, 0.6, 20, start=300, end=400)
+    envelope(buf, 20, 0, 1.0, 20, start=400, end=450)
+    envelope(buf, 20, 0, 1.0, 20, start=450, end=500)
+    envelope(buf, 20, 20, 0.6, 500, start=500)
+    echo(buf, 80, 0.5)
+    return tobytes(buf)
+
+
+def si_playerfire():
+    """Space Invaders player firing sound"""
+    ms = 400
+    freq = 2490.0
+    buf = make_white(ms, 1.0)
+    start = slice(buf, 0, 300)
+    for _ in range(5):
+        start = lowpass_filter(start, freq, order=6)
+        start = highpass_filter(start, freq, order=6)
+    mid = slice(buf, 300, 350)
+    for _ in range(5):
+        mid = lowpass_filter(mid, freq - 75, order=6)
+        mid = highpass_filter(mid, freq - 75, order=6)
+    end = slice(buf, 350, 400)
+    for _ in range(5):
+        end = lowpass_filter(end, freq - 150, order=6)
+        end = highpass_filter(end, freq - 150, order=6)
+    buf = start + mid + end
+    noisalise(buf, gain=0.15)
+    envelope(buf, 10, 0, 1.0, 100)
+    echo(buf, 40, 0.4)
+    return tobytes(buf)
+
+
+def si_march(freq=53.650):
+    """Space Invaders low-frequency marching sound
+
+    Expected frequencies in Hz, 53.650, 50.114, 46.178, 62.465
+    """
+    ms = 80
+    buf = make_sin(ms, 1.0, freq)
+    buf = constrain(buf, 0.5, 1.0)
+    buf = vmove(buf, -0.6)
+    buf = median_filter(buf)
+    envelope(buf, 5, 0, 1.0, 5)
+    echo(buf, 20, 0.3)
+    return tobytes(buf)
+
+

arcadesynth-1.0.1/src/arcadesynth.egg-info/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: arcadesynth
+Version: 1.0.1
+Summary: Programmatically synthesize retro arcade sound effects
+Author-email: "C. Martin Richardson" <c.mart.richardson@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 C. Martin Richardson
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/martianmr/arcadesynth
+Keywords: arcade,synth,retro
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: scipy>=1.17.1
+Requires-Dist: tomli; python_version < "3.11"
+Provides-Extra: dev
+Requires-Dist: pygame; extra == "dev"
+Requires-Dist: bumpver; extra == "dev"
+Dynamic: license-file
+
+# arcadesynth 1.0.1
+
+Programmatically synthesize retro arcade sound effects with arcadesynth
+
+This utility can be used to generate your own custom sound effects in code as an alternative to using sound assets. It also provides some hand-crafted sounds from the Golden age of arcade video games.
+
+The idea was inspired by sound generation on 1980s 8-bit microcomputers which sometimes had fairly sophisticated synthesizer chips which could be programmed at a low level with a bit of know-how. The algorithms are kept fairly simple but are capable of approximating early arcade, console and computer game sounds that are generated with specialized chips or custom electronics.
+
+## Installation
+
+arcadesynth can be installed via pip
+
+```bash
+pip install arcadesynth
+```
+
+## Modules
+
+- synth - functions to build your own effects
+- synth_sample - some simple basic sounds
+- synth_example - some generic retro sound effects
+- synth_asteroids - sounds from the 1979 Atari game Asteroids
+- synth_spaceinvaders - sounds from the 1978 Taito game Asteroids
+
+## Synth
+
+This module can be used to create custom sound effects by generating waves or white noise and then manipulating the signal with envelopes, filters and more.
+
+E.g. synthesize a retro gunshot sound in pygame.
+
+```python
+import pygame
+from arcadesynth import synth
+
+pygame.init()
+pygame.mixer.init()
+ms = 500 # Length of buffer will be 500 milliseconds
+buf = synth.make_white(ms, 1.0) # Fill buffer with white noise
+buf = synth.lowpass_filter(buf, 1200.0, order=4) # Apply a filter to remove higher frequencies
+synth.noisalise(buf, gain=0.5) # Even out the amplitude of the noise
+synth.envelope(buf, 20, 30, 0.2, ms - 10) # Apply an envelope with a short attack and release and then fade off from 20% amplitude
+sound = pygame.mixer.Sound(synth.tobytes(buf))
+sound.play()
+```
+
+## Space Invaders
+
+There are some built-in hand-crafted synthesized sounds including those from the 1978 classic Space Invaders by Taito. Sounds in the arcade machine are produced on a Texas Instruments SN76477 'complex sound generator' chip supported by custom electronics. 
+
+E.g. synthesize the sound made by the flying saucer blowing up in Space Invaders.
+
+```python
+import pygame
+from arcadesynth import synth_spaceinvaders as si
+
+pygame.init()
+pygame.mixer.init()
+sound = pygame.mixer.Sound(si.si_ufodie())
+sound.play()
+```
+
+## LICENSE
+
+MIT License — See the [LICENSE](LICENSE) file for details.

arcadesynth-1.0.1/src/arcadesynth.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+src/arcadesynth/__init__.py
+src/arcadesynth/config.toml
+src/arcadesynth/synth.py
+src/arcadesynth/synth_asteroids.py
+src/arcadesynth/synth_example.py
+src/arcadesynth/synth_sample.py
+src/arcadesynth/synth_spaceinvaders.py
+src/arcadesynth.egg-info/PKG-INFO
+src/arcadesynth.egg-info/SOURCES.txt
+src/arcadesynth.egg-info/dependency_links.txt
+src/arcadesynth.egg-info/requires.txt
+src/arcadesynth.egg-info/top_level.txt

arcadesynth-1.0.1/src/arcadesynth.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

arcadesynth-1.0.1/src/arcadesynth.egg-info/requires.txt

@@ -0,0 +1,8 @@
+scipy>=1.17.1
+
+[:python_version < "3.11"]
+tomli
+
+[dev]
+pygame
+bumpver

arcadesynth-1.0.1/src/arcadesynth.egg-info/top_level.txt

@@ -0,0 +1 @@
+arcadesynth