Drive toggle sprint/sneak as vanilla's key handlers do and compare
ToggleKeys holds the sneak, sprint, attack and use ToggleKeyMappings with the dispatch of KeyboardHandler.keyPress (releases always reach them; presses and SDL key repeats only without a screen), MouseHandler.onButton, Gui.setScreen (releaseAll / restoreToggleStatesOnScreenClosed) and LocalPlayer.respawn (resetToggleKeys, which Horizon lacked). Presses behind a screen no longer flip a toggled key. tools/test_toggle_keys_parity.py drives the real Options mappings through the real static KeyMapping functions (8,000 sequences). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,56 @@
|
||||
#![forbid(unsafe_code)]
|
||||
//! Runs tools/test_toggle_keys_parity.py's event sequences through
|
||||
//! `ToggleKeys`, the sneak/sprint/attack/use toggle mappings.
|
||||
use horizon_client::{
|
||||
Result,
|
||||
keymapping::{KeyAction, ToggleKeys},
|
||||
};
|
||||
use serde_json::Value;
|
||||
use std::{
|
||||
fs::File,
|
||||
io::{BufRead, BufReader, BufWriter, Write},
|
||||
};
|
||||
|
||||
fn main() -> Result<()> {
|
||||
let args: Vec<String> = std::env::args().collect();
|
||||
let input = BufReader::new(File::open(&args[1])?);
|
||||
let mut out = BufWriter::new(File::create(&args[2])?);
|
||||
for (n, line) in input.lines().enumerate() {
|
||||
let c: Value = serde_json::from_str(&line?)?;
|
||||
writeln!(out, "== {n}")?;
|
||||
let mut keys = ToggleKeys::default();
|
||||
let mut options = [false; 4];
|
||||
for op in c["ops"].as_array().unwrap() {
|
||||
let name = op[0].as_str().unwrap();
|
||||
let slot = || op[1].as_u64().unwrap() as usize;
|
||||
match name {
|
||||
"option" => options[slot()] = op[2].as_bool().unwrap(),
|
||||
"key" => {
|
||||
let action = match op[2].as_i64().unwrap() {
|
||||
0 => KeyAction::Release,
|
||||
1 => KeyAction::Press,
|
||||
_ => KeyAction::Repeat,
|
||||
};
|
||||
keys.key(slot(), action, op[3].as_bool().unwrap(), options[slot()]);
|
||||
}
|
||||
"button" => keys.button(
|
||||
slot(),
|
||||
op[2].as_bool().unwrap(),
|
||||
op[3].as_bool().unwrap(),
|
||||
options[slot()],
|
||||
),
|
||||
"open" => keys.screen_opened(options),
|
||||
"close" => keys.screen_closed(options),
|
||||
"respawn" => keys.respawn(),
|
||||
other => panic!("{other}"),
|
||||
}
|
||||
let mut line = name.to_string();
|
||||
for k in &keys.0 {
|
||||
line += &format!(" {} {}", k.is_down, k.pending_clicks());
|
||||
}
|
||||
writeln!(out, "{line}")?;
|
||||
}
|
||||
}
|
||||
out.flush()?;
|
||||
Ok(())
|
||||
}
|
||||
@@ -108,7 +108,7 @@ use horizon_client::{
|
||||
gfx::{Frame, Renderer},
|
||||
hud::{HudAtlas, HudBatch, rgba},
|
||||
items::{ItemStack, Items},
|
||||
keymapping::KeyState,
|
||||
keymapping::KeyAction,
|
||||
light::LightTables,
|
||||
mesher::{MeshTables, Vertex},
|
||||
mobs::{Mob, MobType, MobTypes},
|
||||
@@ -567,7 +567,7 @@ struct Game<'a> {
|
||||
/// `Options.smoothCamera` (cinematic camera), not persisted.
|
||||
smooth_camera: bool,
|
||||
/// Sneak, sprint, attack and use as ToggleKeyMappings.
|
||||
toggles: [KeyState; 4],
|
||||
toggles: horizon_client::keymapping::ToggleKeys,
|
||||
/// A world screen with the pointer captured was open last frame.
|
||||
was_playing: bool,
|
||||
/// Minecraft.pause: a single-player screen that pauses the game is open.
|
||||
@@ -2745,7 +2745,7 @@ impl Game<'_> {
|
||||
/// Keep the held-key state of toggled sneak and sprint in step with their mapping.
|
||||
fn sync_toggle(&mut self, slot: usize) {
|
||||
let key = [KeyCode::ShiftLeft, KeyCode::ControlLeft][slot];
|
||||
if self.toggles[slot].is_down {
|
||||
if self.toggles.is_down(slot) {
|
||||
self.keys.insert(key);
|
||||
} else {
|
||||
self.keys.remove(&key);
|
||||
@@ -2765,20 +2765,15 @@ impl Game<'_> {
|
||||
self.settings.toggle_attack,
|
||||
self.settings.toggle_use,
|
||||
];
|
||||
for (slot, option) in options.into_iter().enumerate() {
|
||||
if playing {
|
||||
if self.toggles[slot].should_restore_state_on_screen_closed(option) {
|
||||
self.toggles[slot].set_down(true, option);
|
||||
}
|
||||
} else {
|
||||
self.toggles[slot].release(option);
|
||||
}
|
||||
match slot {
|
||||
0 | 1 => self.sync_toggle(slot),
|
||||
2 => self.left = self.toggles[2].is_down,
|
||||
_ => self.right = self.toggles[3].is_down,
|
||||
}
|
||||
if playing {
|
||||
self.toggles.screen_closed(options);
|
||||
} else {
|
||||
self.toggles.screen_opened(options);
|
||||
}
|
||||
self.sync_toggle(0);
|
||||
self.sync_toggle(1);
|
||||
self.left = self.toggles.is_down(2);
|
||||
self.right = self.toggles.is_down(3);
|
||||
}
|
||||
/// `MouseHandler.handleAccumulatedMovement` and `Entity.turn`, once per frame.
|
||||
fn apply_mouse_look(&mut self) {
|
||||
@@ -7681,15 +7676,16 @@ impl Game<'_> {
|
||||
if pressed && self.attack() {
|
||||
return Ok(());
|
||||
}
|
||||
self.toggles[2].set_down(pressed, self.settings.toggle_attack);
|
||||
self.left = self.toggles[2].is_down;
|
||||
self.toggles
|
||||
.button(2, pressed, false, self.settings.toggle_attack);
|
||||
self.left = self.toggles.is_down(2);
|
||||
if pressed {
|
||||
self.destroy_delay = 0;
|
||||
}
|
||||
}
|
||||
MouseButton::Right => {
|
||||
self.toggles[3].set_down(pressed, self.settings.toggle_use);
|
||||
self.right = self.toggles[3].is_down;
|
||||
self.toggles.button(3, pressed, false, self.settings.toggle_use);
|
||||
self.right = self.toggles.is_down(3);
|
||||
if pressed {
|
||||
self.use_item()?;
|
||||
self.use_delay = 4;
|
||||
@@ -8141,18 +8137,23 @@ impl ApplicationHandler for Game<'_> {
|
||||
}
|
||||
None => return Ok(()),
|
||||
};
|
||||
// Sneak and sprint are ToggleKeyMappings: a press flips them when toggling.
|
||||
// Sneak and sprint are ToggleKeyMappings: a press (or a key
|
||||
// repeat) flips them when toggling; only releases reach them
|
||||
// behind a screen (KeyboardHandler.keyPress).
|
||||
let toggle = match key {
|
||||
KeyCode::ShiftLeft => Some((0, self.settings.toggle_crouch)),
|
||||
KeyCode::ControlLeft => Some((1, self.settings.toggle_sprint)),
|
||||
_ => None,
|
||||
};
|
||||
if let Some((slot, option)) = toggle {
|
||||
if !event.repeat {
|
||||
self.toggles[slot]
|
||||
.set_down(event.state == ElementState::Pressed, option);
|
||||
self.sync_toggle(slot);
|
||||
}
|
||||
let action = match (event.state, event.repeat) {
|
||||
(ElementState::Released, _) => KeyAction::Release,
|
||||
(_, false) => KeyAction::Press,
|
||||
(_, true) => KeyAction::Repeat,
|
||||
};
|
||||
let screen_open = self.screen != Screen::Playing || self.title.is_some();
|
||||
self.toggles.key(slot, action, screen_open, option);
|
||||
self.sync_toggle(slot);
|
||||
if event.state != ElementState::Pressed {
|
||||
return Ok(());
|
||||
}
|
||||
@@ -8460,12 +8461,7 @@ pub fn run() -> Result<()> {
|
||||
focused: true,
|
||||
mouse: MouseLook::default(),
|
||||
smooth_camera: false,
|
||||
toggles: [
|
||||
KeyState::toggle(true, true),
|
||||
KeyState::toggle(true, true),
|
||||
KeyState::toggle(true, false),
|
||||
KeyState::toggle(false, false),
|
||||
],
|
||||
toggles: Default::default(),
|
||||
was_playing: false,
|
||||
pause: false,
|
||||
debug: false,
|
||||
|
||||
@@ -213,9 +213,12 @@ impl Game<'_> {
|
||||
match hit {
|
||||
Some(0) if self.remote.is_some() => {
|
||||
self.ui.death_text = None;
|
||||
self.toggles.respawn();
|
||||
self.remote_respawn();
|
||||
}
|
||||
Some(0) => {
|
||||
// LocalPlayer.respawn: KeyMapping.resetToggleKeys.
|
||||
self.toggles.respawn();
|
||||
self.respawn_out_of_end()?;
|
||||
self.player = None;
|
||||
self.screen = Screen::Playing;
|
||||
|
||||
@@ -74,6 +74,10 @@ impl KeyState {
|
||||
pub fn reset(&mut self) {
|
||||
self.is_down = false;
|
||||
}
|
||||
/// Clicks not yet consumed.
|
||||
pub fn pending_clicks(&self) -> i32 {
|
||||
self.click_count
|
||||
}
|
||||
/// `shouldRestoreStateOnScreenClosed` (clears the remembered release).
|
||||
pub fn should_restore_state_on_screen_closed(&mut self, needs_toggle: bool) -> bool {
|
||||
let Some(restore) = self.toggle else {
|
||||
@@ -85,6 +89,90 @@ impl KeyState {
|
||||
}
|
||||
}
|
||||
|
||||
/// A keyboard event (`KeyEvent.Action`): SDL reports a held key's repeats
|
||||
/// as their own action.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum KeyAction {
|
||||
Release,
|
||||
Press,
|
||||
Repeat,
|
||||
}
|
||||
|
||||
/// Sneak.
|
||||
pub const SNEAK: usize = 0;
|
||||
/// Sprint.
|
||||
pub const SPRINT: usize = 1;
|
||||
/// Attack (mouse).
|
||||
pub const ATTACK: usize = 2;
|
||||
/// Use (mouse).
|
||||
pub const USE: usize = 3;
|
||||
|
||||
/// The `ToggleKeyMapping`s `Options` builds: sneak and sprint (keyboard,
|
||||
/// restored after a screen), attack (mouse, restored) and use (mouse, not
|
||||
/// restored), and the handlers that drive them. `needs_toggle` is each
|
||||
/// mapping's toggle option, read at every event as vanilla does.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct ToggleKeys(pub [KeyState; 4]);
|
||||
impl Default for ToggleKeys {
|
||||
fn default() -> Self {
|
||||
Self([
|
||||
KeyState::toggle(true, true),
|
||||
KeyState::toggle(true, true),
|
||||
KeyState::toggle(true, false),
|
||||
KeyState::toggle(false, false),
|
||||
])
|
||||
}
|
||||
}
|
||||
impl ToggleKeys {
|
||||
pub fn is_down(&self, slot: usize) -> bool {
|
||||
self.0[slot].is_down
|
||||
}
|
||||
/// `KeyboardHandler.keyPress` for a key bound to `slot`: a release sets
|
||||
/// the mapping up (`KeyMapping.set(key, false)`); a press or a repeat
|
||||
/// with no screen open sets it down and clicks it.
|
||||
pub fn key(&mut self, slot: usize, action: KeyAction, screen_open: bool, needs_toggle: bool) {
|
||||
match action {
|
||||
KeyAction::Release => self.0[slot].set_down(false, needs_toggle),
|
||||
KeyAction::Press | KeyAction::Repeat if !screen_open => {
|
||||
self.0[slot].set_down(true, needs_toggle);
|
||||
self.0[slot].click();
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
/// `MouseHandler.onButton` for a button bound to `slot`: only without a
|
||||
/// screen or overlay.
|
||||
pub fn button(&mut self, slot: usize, pressed: bool, screen_open: bool, needs_toggle: bool) {
|
||||
if !screen_open {
|
||||
self.0[slot].set_down(pressed, needs_toggle);
|
||||
if pressed {
|
||||
self.0[slot].click();
|
||||
}
|
||||
}
|
||||
}
|
||||
/// `Gui.setScreen` with a screen: `KeyMapping.releaseAll`.
|
||||
pub fn screen_opened(&mut self, needs_toggle: [bool; 4]) {
|
||||
for (key, option) in self.0.iter_mut().zip(needs_toggle) {
|
||||
key.release(option);
|
||||
}
|
||||
}
|
||||
/// `Gui.setScreen(null)` in a level:
|
||||
/// `KeyMapping.restoreToggleStatesOnScreenClosed`.
|
||||
pub fn screen_closed(&mut self, needs_toggle: [bool; 4]) {
|
||||
for (key, option) in self.0.iter_mut().zip(needs_toggle) {
|
||||
if key.should_restore_state_on_screen_closed(option) {
|
||||
key.set_down(true, option);
|
||||
}
|
||||
}
|
||||
}
|
||||
/// `LocalPlayer.respawn`: `KeyMapping.resetToggleKeys`.
|
||||
pub fn respawn(&mut self) {
|
||||
for key in &mut self.0 {
|
||||
key.reset();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
@@ -99,6 +187,19 @@ mod tests {
|
||||
assert!(!k.is_down);
|
||||
}
|
||||
#[test]
|
||||
fn screens_block_presses_but_not_releases() {
|
||||
let mut keys = ToggleKeys::default();
|
||||
keys.key(SNEAK, KeyAction::Press, true, false);
|
||||
assert!(!keys.is_down(SNEAK));
|
||||
keys.key(SNEAK, KeyAction::Press, false, false);
|
||||
assert!(keys.is_down(SNEAK));
|
||||
keys.key(SNEAK, KeyAction::Release, true, false);
|
||||
assert!(!keys.is_down(SNEAK));
|
||||
keys.key(SPRINT, KeyAction::Press, false, true);
|
||||
keys.respawn();
|
||||
assert!(!keys.is_down(SPRINT));
|
||||
}
|
||||
#[test]
|
||||
fn screen_release_restores_toggled_state() {
|
||||
let mut k = KeyState::toggle(true, true);
|
||||
k.set_down(true, true);
|
||||
|
||||
@@ -0,0 +1,102 @@
|
||||
package dev.horizonlab.parity;
|
||||
|
||||
import com.google.gson.*;
|
||||
import com.mojang.blaze3d.platform.InputConstants;
|
||||
import java.io.*;
|
||||
import java.lang.reflect.*;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.nio.file.*;
|
||||
import java.util.*;
|
||||
import net.minecraft.client.*;
|
||||
|
||||
/**
|
||||
* Drives the real Options key mappings (keyShift, keySprint, keyAttack and
|
||||
* keyUse are ToggleKeyMappings reading toggleCrouch/toggleSprint/toggleAttack/
|
||||
* toggleUse) through the real static KeyMapping.set/click, releaseAll,
|
||||
* restoreToggleStatesOnScreenClosed and resetToggleKeys, dispatched as
|
||||
* KeyboardHandler.keyPress, MouseHandler.onButton, Gui.setScreen and
|
||||
* LocalPlayer.respawn call them, and prints each mapping's down state and
|
||||
* pending clicks after every event.
|
||||
*/
|
||||
public final class VanillaToggleKeysOracle {
|
||||
static Field field(Class<?> type, String name) throws Exception {
|
||||
Field f = type.getDeclaredField(name);
|
||||
f.setAccessible(true);
|
||||
return f;
|
||||
}
|
||||
|
||||
public static void main(String[] args) throws Exception {
|
||||
net.minecraft.SharedConstants.tryDetectVersion();
|
||||
net.minecraft.server.Bootstrap.bootStrap();
|
||||
var u = Class.forName("sun.misc.Unsafe");
|
||||
var unsafe = field(u, "theUnsafe").get(null);
|
||||
Minecraft shell = (Minecraft) u.getMethod("allocateInstance", Class.class).invoke(unsafe, Minecraft.class);
|
||||
field(Minecraft.class, "fixerUpper").set(shell, net.minecraft.util.datafix.DataFixers.getDataFixer());
|
||||
field(Minecraft.class, "instance").set(null, shell);
|
||||
Options options = new Options(shell, Files.createTempDirectory("opts").toFile());
|
||||
KeyMapping[] mappings = {options.keyShift, options.keySprint, options.keyAttack, options.keyUse};
|
||||
List<OptionInstance<Boolean>> toggles = List.of(options.toggleCrouch(), options.toggleSprint(), options.toggleAttack(), options.toggleUse());
|
||||
Field keyField = field(KeyMapping.class, "key");
|
||||
Field clicks = field(KeyMapping.class, "clickCount");
|
||||
try (var out = new PrintWriter(Files.newBufferedWriter(Path.of(args[1]), StandardCharsets.UTF_8));
|
||||
var lines = Files.lines(Path.of(args[0]))) {
|
||||
int n = 0;
|
||||
for (var line : (Iterable<String>) lines::iterator) {
|
||||
var c = JsonParser.parseString(line).getAsJsonObject();
|
||||
out.println("== " + n++);
|
||||
// A fresh session: everything up, no pending clicks or remembered releases.
|
||||
for (int i = 0; i < 4; i++) {
|
||||
toggles.get(i).set(false);
|
||||
}
|
||||
KeyMapping.resetToggleKeys();
|
||||
KeyMapping.releaseAll();
|
||||
KeyMapping.restoreToggleStatesOnScreenClosed();
|
||||
for (var m : mappings) {
|
||||
while (m.consumeClick()) {
|
||||
}
|
||||
}
|
||||
for (var e : c.getAsJsonArray("ops")) {
|
||||
var op = e.getAsJsonArray();
|
||||
String name = op.get(0).getAsString();
|
||||
switch (name) {
|
||||
case "option" -> toggles.get(op.get(1).getAsInt()).set(op.get(2).getAsBoolean());
|
||||
case "key" -> {
|
||||
// KeyboardHandler.keyPress: action 0 releases; a press (1) or an SDL
|
||||
// repeat (-1) sets and clicks only with no screen open.
|
||||
var key = (InputConstants.Key) keyField.get(mappings[op.get(1).getAsInt()]);
|
||||
int action = op.get(2).getAsInt();
|
||||
boolean screen = op.get(3).getAsBoolean();
|
||||
if (action == 0) {
|
||||
KeyMapping.set(key, false);
|
||||
} else if (!screen) {
|
||||
KeyMapping.set(key, true);
|
||||
KeyMapping.click(key);
|
||||
}
|
||||
}
|
||||
case "button" -> {
|
||||
// MouseHandler.onButton: only with no screen or overlay.
|
||||
var key = (InputConstants.Key) keyField.get(mappings[op.get(1).getAsInt()]);
|
||||
boolean pressed = op.get(2).getAsBoolean();
|
||||
if (!op.get(3).getAsBoolean()) {
|
||||
KeyMapping.set(key, pressed);
|
||||
if (pressed) {
|
||||
KeyMapping.click(key);
|
||||
}
|
||||
}
|
||||
}
|
||||
case "open" -> KeyMapping.releaseAll();
|
||||
case "close" -> KeyMapping.restoreToggleStatesOnScreenClosed();
|
||||
case "respawn" -> KeyMapping.resetToggleKeys();
|
||||
default -> throw new IllegalArgumentException(name);
|
||||
}
|
||||
var sb = new StringBuilder(name);
|
||||
for (var m : mappings) {
|
||||
sb.append(' ').append(m.isDown()).append(' ').append(clicks.getInt(m));
|
||||
}
|
||||
out.println(sb);
|
||||
}
|
||||
}
|
||||
}
|
||||
System.exit(0);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,76 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Compare toggle sprint/sneak (and toggle attack/use) with the pinned client:
|
||||
the real Options ToggleKeyMappings driven by the real static KeyMapping
|
||||
functions as keyboard presses, SDL key repeats and releases, mouse buttons,
|
||||
screens opening and closing over the game (releaseAll and
|
||||
restoreToggleStatesOnScreenClosed), respawning (resetToggleKeys) and toggle
|
||||
options changing mid-sequence, event by event."""
|
||||
import json
|
||||
import random
|
||||
|
||||
try:
|
||||
from . import lab, oracle_harness as harness
|
||||
except ImportError:
|
||||
import lab, oracle_harness as harness
|
||||
|
||||
|
||||
def op(rng, screen):
|
||||
kind = rng.choice(['key', 'key', 'key', 'key', 'button', 'button', 'open', 'close', 'option', 'option', 'respawn'])
|
||||
if kind == 'key':
|
||||
return ['key', rng.choice([0, 1]), rng.choice([1, 1, 0, 0, -1]), screen]
|
||||
if kind == 'button':
|
||||
return ['button', rng.choice([2, 3]), rng.random() < 0.5, screen]
|
||||
if kind == 'option':
|
||||
return ['option', rng.randrange(4), rng.random() < 0.6]
|
||||
return [kind]
|
||||
|
||||
|
||||
def cases(rng):
|
||||
# Every short sequence of the main events for sneak with toggle off and on.
|
||||
events = [['key', 0, 1, False], ['key', 0, 0, False], ['key', 0, -1, False], ['key', 0, 1, True], ['key', 0, 0, True],
|
||||
['open'], ['close'], ['respawn'], ['option', 0, True], ['option', 0, False]]
|
||||
for a in events:
|
||||
for b in events:
|
||||
for c in events:
|
||||
for toggled in (False, True):
|
||||
yield dict(ops=[['option', 0, toggled], a, b, c, ['key', 0, 1, False], ['open'], ['close']])
|
||||
for _ in range(6000):
|
||||
screen = False
|
||||
ops = [['option', i, rng.random() < 0.5] for i in range(4)]
|
||||
for _ in range(rng.randrange(1, 60)):
|
||||
o = op(rng, screen)
|
||||
if o[0] == 'open':
|
||||
screen = True
|
||||
elif o[0] == 'close':
|
||||
screen = False
|
||||
elif o[0] in ('key', 'button'):
|
||||
o[3] = screen
|
||||
ops.append(o)
|
||||
yield dict(ops=ops)
|
||||
|
||||
|
||||
def make_cases(build):
|
||||
path = build / 'cases.jsonl'
|
||||
count = 0
|
||||
with path.open('w') as out:
|
||||
for case in cases(random.Random(0x544f474c)):
|
||||
out.write(json.dumps(case, separators=(',', ':')) + '\n')
|
||||
count += 1
|
||||
return path, count
|
||||
|
||||
|
||||
def main():
|
||||
scope = ('The real Options keyShift/keySprint/keyAttack/keyUse ToggleKeyMappings with their real toggle options and '
|
||||
'shouldRestore flags, driven through the real static KeyMapping.set/click (every mapping bound to the key), '
|
||||
'releaseAll, restoreToggleStatesOnScreenClosed and resetToggleKeys, dispatched as KeyboardHandler.keyPress '
|
||||
'(release always; press and SDL repeat only without a screen), MouseHandler.onButton (only without a screen), '
|
||||
'Gui.setScreen and LocalPlayer.respawn call them. Compares down state and pending clicks after every event. '
|
||||
'The screen-consumed keyPressed/keyReleased branches and KeyMapping.setAll (an InputQuirks platform quirk) are '
|
||||
'not exercised; KeyboardInput then reads isDown as the sprint and local input harnesses compare.')
|
||||
harness.differential(
|
||||
'rust-toggle-keys-parity', 'VanillaToggleKeysOracle', 'toggle_keys_probe', make_cases, scope,
|
||||
sources=[lab.ROOT / 'crates/horizon-client/src/keymapping.rs'])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
Reference in New Issue
Block a user