forked from metin-server/m2dev-server
139 lines
3.3 KiB
Python
139 lines
3.3 KiB
Python
import sys
|
|
sys.dont_write_bytecode = True
|
|
|
|
import os
|
|
import time
|
|
import json
|
|
import subprocess
|
|
import traceback
|
|
import channels
|
|
|
|
GAMEDIR = os.getcwd()
|
|
PIDS_FILE = os.path.join(GAMEDIR, "pids.json")
|
|
|
|
def print_green(text):
|
|
print("\033[1;32m" + text + "\033[0m")
|
|
|
|
def print_magenta_prompt():
|
|
print("\033[0;35m> ", end="", flush=True)
|
|
|
|
def start_process(exe):
|
|
if os.name == "nt":
|
|
exe += ".exe"
|
|
return subprocess.Popen([exe], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
|
|
|
|
def try_start(name, cd, exe, pids, key=None):
|
|
try:
|
|
os.chdir(cd)
|
|
proc = start_process(exe)
|
|
entry = {"name": name, "pid": proc.pid}
|
|
|
|
if key:
|
|
pids.setdefault(key, []).append(entry)
|
|
else:
|
|
pids[name] = entry
|
|
|
|
return True
|
|
except Exception as e:
|
|
print(f"> Failed to start {name}: {e}")
|
|
traceback.print_exc()
|
|
return False
|
|
|
|
def main():
|
|
if len(sys.argv) == 1:
|
|
print_green("> How many channels to start?")
|
|
print_magenta_prompt()
|
|
|
|
try:
|
|
user_input = int(input())
|
|
except ValueError:
|
|
print("> Invalid number.")
|
|
sys.exit(1)
|
|
else:
|
|
try:
|
|
user_input = int(sys.argv[1])
|
|
except ValueError:
|
|
print("> Invalid argument.")
|
|
sys.exit(1)
|
|
|
|
pids = {}
|
|
|
|
try:
|
|
print_green("> Starting database...")
|
|
try_start(
|
|
"db",
|
|
os.path.join(GAMEDIR, "channels", "db"),
|
|
"./db",
|
|
pids
|
|
)
|
|
time.sleep(1)
|
|
|
|
print_green("> Starting auth...")
|
|
try_start(
|
|
"auth",
|
|
os.path.join(GAMEDIR, "channels", "auth"),
|
|
"./game_auth",
|
|
pids
|
|
)
|
|
time.sleep(1)
|
|
|
|
# Start Channel cores
|
|
# 1. Create a dictionary of channel IDs guaranteed to be integers.
|
|
# This ensures that string keys (e.g., '99') are correctly treated as numbers.
|
|
int_channel_map = {int(k): v for k, v in channels.CHANNEL_MAP.items()}
|
|
|
|
# 2. Determine which channels to start based on user input
|
|
channels_to_start = set()
|
|
for channel_id in int_channel_map.keys():
|
|
|
|
# Add any channel that is within the user's limit (e.g., if user_input is 2, add 1 and 2)
|
|
if user_input and channel_id <= user_input:
|
|
channels_to_start.add(channel_id)
|
|
|
|
# If there is no user input limit, start ALL channels
|
|
elif not user_input:
|
|
channels_to_start.add(channel_id)
|
|
|
|
# 3. GUARANTEE Channel 99 is included, regardless of the input limit
|
|
if 99 in int_channel_map:
|
|
channels_to_start.add(99)
|
|
|
|
# 4. Sort the list to ensure correct startup order (1, 2, ..., 99)
|
|
final_start_order = sorted(list(channels_to_start))
|
|
|
|
# 5. Iterate through the final, clean list
|
|
for channel_id in final_start_order:
|
|
cores = int_channel_map[channel_id] # Retrieve cores using the integer ID
|
|
print_green(f"> Starting CH{channel_id}:")
|
|
for core_id, maps in cores.items():
|
|
name = f"channel{channel_id}_core{core_id}"
|
|
print_green(f"\t> {name}")
|
|
try_start(
|
|
name,
|
|
os.path.join(GAMEDIR, "channels", f"channel{channel_id}", f"core{core_id}"),
|
|
f"./{name}",
|
|
pids,
|
|
"channel"
|
|
)
|
|
time.sleep(1)
|
|
print()
|
|
|
|
print_green("> The server is running!")
|
|
|
|
except Exception as e:
|
|
print(f"> Unexpected error: {e}")
|
|
traceback.print_exc()
|
|
|
|
finally:
|
|
os.chdir(GAMEDIR)
|
|
try:
|
|
with open(PIDS_FILE, "w") as f:
|
|
json.dump(pids, f, indent=2)
|
|
print_green(f"> PID file written to {PIDS_FILE}")
|
|
|
|
except Exception as e:
|
|
print(f"> Failed to write PID file: {e}")
|
|
traceback.print_exc()
|
|
|
|
if __name__ == "__main__":
|
|
main() |