110 lines
4.5 KiB
Python
Executable File
110 lines
4.5 KiB
Python
Executable File
#! /usr/bin/env python3
|
|
import argparse
|
|
import subprocess
|
|
import time
|
|
|
|
def ydotool(key, delay=60, multiplier=1):
|
|
# This runs with a bit of a delay (by default, modulated by multiplier) because
|
|
# Patapon -- the game, not the emulator or the input layer -- will drop inputs
|
|
# if it's too low.
|
|
subprocess.run([
|
|
"ydotool",
|
|
"key",
|
|
str(key) + ":1",
|
|
str(key) + ":0",
|
|
"--key-delay",
|
|
str(100 / multiplier)
|
|
])
|
|
|
|
def main():
|
|
# A list of all possible songs, expressed as their cardinal directions
|
|
# We'll map these to keystrokes later
|
|
songs = [
|
|
# March of Mobility
|
|
"L-L-L-R-",
|
|
# Aria of Attack
|
|
"R-R-L-R-",
|
|
# Lament of Defense
|
|
"U-U-L-R-",
|
|
# Hold-Tight Hoe-Down/Concerto of Charge
|
|
"R-R-U-U-",
|
|
# Melody with a Bounce/Jingle of Jump
|
|
"D-D-U-U-",
|
|
# Ballad of 1999/Pizzicato of Party
|
|
"L-R-D-U-",
|
|
# Song of Miracles (Djinn)
|
|
"D-DD-DD-",
|
|
# Leisurely Lullaby
|
|
# Not sure why you'd want to cast this on repeat, but you can I guess
|
|
"L-R-L-R-",
|
|
# Step Back Strut
|
|
"U-L-U-L-"
|
|
]
|
|
# A mapping of characters in our encoded songs to keys to send to ydotool
|
|
# These should be the default bindings for PPSSPP
|
|
keymapping = {
|
|
"U": "31",
|
|
"D": "44",
|
|
"L": "30",
|
|
"R": "45"
|
|
}
|
|
drummapping = {
|
|
"U": '\033[32mCHAKA\033[0m',
|
|
"D": '\033[33mDON\033[0m',
|
|
"L": '\033[31mPATA\033[0m',
|
|
"R": '\033[34mPON\033[0m'
|
|
}
|
|
parser = argparse.ArgumentParser(
|
|
description="Play a sequence of Patapon commands on repeat"
|
|
)
|
|
parser.add_argument('song',default="R-R-L-R-",nargs="+",choices=songs,help="The song to play. Defaults to Aria of Attack. When expressing a song, use eighth notes, dashes, and cardinal directions to designate the drums. For example, party would be \"L-R-D-U-\", and djinn would be \"D-DD-DD-\"")
|
|
parser.add_argument('--bpm',type=float,default=1,help="Multiplier for the BPM. Change if you're running the game at a higher speed")
|
|
parser.add_argument('--iterations',type=int,default=10000,help="Number of iterations of the sequence to run. Defaults to 10,000")
|
|
parser.add_argument('--key-delay',type=int,default=60,help="Number of milliseconds to hold each key down for. Defaults to 100. Tune if you're getting dropped inputs or if the program can't keep up")
|
|
parser.add_argument('--startup-delay',type=int,default=0,help="Number of milliseconds by which we should \"start early\". Adjust this value if, despite syncing on-beat, the program is late. The program will never be early -- if it feels like it is, it's just WAY late")
|
|
args = parser.parse_args()
|
|
|
|
# Schedule out our beat interval
|
|
# 120.000 Naiive, does not work
|
|
# 119.905 Still fast
|
|
# 119.900 Still fast
|
|
# 119.890 Just baaaaarely too fast
|
|
# 119.880
|
|
# 119.000 Wicked slow, outpaces in like 4 measures
|
|
bpm_constant = 119.880
|
|
print(f"Game BPM: {bpm_constant} BPM * {args.bpm}")
|
|
beat_interval = 60 / (bpm_constant * args.bpm * 2)
|
|
print(f"Beat interval: {beat_interval * 1000}ms per eighth note")
|
|
# This sanity check of min() ensures that we'll never delay by more than a
|
|
# beat. Honestly, delaying by a beat makes no sense, but delaying by more
|
|
# than one makes even less.
|
|
startup_delay = min(beat_interval * 2, args.startup_delay / 1000)
|
|
print(f"Startup delay: {startup_delay * 1000}ms")
|
|
|
|
# Set up the environment
|
|
sequence='--------' + '--------'.join(args.song)
|
|
print(f"Song sequence: {sequence}")
|
|
remaining_iterations = args.iterations
|
|
lastbeat = 0
|
|
|
|
# Wait for user confirmation
|
|
input("Press enter on-beat to sync up with Patapon...")
|
|
synctime = time.perf_counter() + startup_delay
|
|
|
|
# Play da notes
|
|
while remaining_iterations > 0:
|
|
for i, key in enumerate(sequence):
|
|
while time.perf_counter() < synctime + lastbeat:
|
|
pass
|
|
lastbeat += beat_interval
|
|
button = keymapping.get(key, '-')
|
|
if button != '-':
|
|
ydotool(key=button, delay=args.key_delay, multiplier=args.bpm)
|
|
print(drummapping.get(key, '-'), end="", flush=True)
|
|
else:
|
|
print(" ", end="", flush=True)
|
|
remaining_iterations -= 1
|
|
print(f"~ ({remaining_iterations} remaining)")
|
|
|
|
main()
|