# -*- coding: utf-8 -*- """ XSayATC - lokalny asystent ATC dla X-Plane 12 (llama.cpp) Podlacza sie do lokalnego serwera llama.cpp (OpenAI-compat /v1/chat/completions), pobiera kontekst lotu z datarefow, wysyla Twoja wiadomosc (na razie tekstowa), i streamuje odpowiedz ATC do okna widocznego rowniez w VR. Wymaga: XPPython3 (dostarcza wlasnego Pythona 3.12 + imgui + requests). Konfiguracja zapisywana jest w config.json obok tego pliku. WAZNE (bezpieczenstwo watkow): - Odczyty datarefow (xp.getData*) MUSZA dzialac na glownym watku X-Plane. - Watek roboczy robi WYLACZNIE siec (requests) i aktualizuje self.messages. - Kontekst lotu zbierany jest na glownym watku i przekazywany do watku. """ import json import os import threading import subprocess import time from XPPython3 import xp from XPPython3.xp_imgui import Window as ImguiWindow import imgui import requests # -------------------------------------------------------------------------- # Konfiguracja i domyslne wartosci # -------------------------------------------------------------------------- CONFIG_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "config.json") DEFAULT_CONFIG = { "base_url": "http://localhost:8081", # adres serwera llama.cpp "model": "", # puste = pobierze pierwszy z /v1/models "temperature": 0.7, "max_tokens": 512, "system_prompt": ( "You are a concise, professional air traffic controller in X-Plane 12. " "Give short, clear, realistic ATC instructions. Use standard phraseology. " "You have access to the pilot's current flight context (position, altitude, " "speed, heading, transponder, radio frequencies, nearest airport, weather) " "and to nearby traffic. " "IMPORTANT: adopt the role of the facility the pilot is currently tuned to " "(the 'Tuned facility' field): Delivery/Clearance gives IFR/VFR clearances and " "squawk codes; Ground issues taxi instructions; Tower controls takeoff, landing " "and the active runway; Tracon/Approach handles arrivals, departures and " "vectors; Center handles enroute. If 'Tuned facility' is 'None', act as a " "generic ATC using the active COM frequency. " "HANDOFF RULE (very important): when you finish with the pilot, you MUST hand " "them off to the next facility exactly like real ATC, using standard phraseology " "such as 'contact Ground on 121.900', 'contact Tower on 118.300', or 'frequency " "change approved'. Use the 'Airport frequencies' list to give the correct " "frequency for the 'Next expected facility'. If the next facility has several " "frequencies, pick the most plausible one and state it clearly. " "DIRECTION: use the 'Flight phase' field. On DEPARTURE the flow is Delivery->" "Ground->Tower->Departure->Center (so Tower hands off to Departure). On ARRIVAL " "the flow is Center->Approach->Tower->Ground (so Tower hands off to Ground). " "Never hand off to yourself (e.g. Tower must NOT say 'contact Tower'). " "RUNWAY STATUS: when the pilot requests takeoff or landing, check the " "'Selected runway' status in the context. If it says OCCUPIED, you must " "withhold the clearance (e.g. 'hold short', 'go around', 'runway occupied'). " "Only issue a takeoff/landing clearance when the runway is clear. " "Use the nearby traffic list when issuing traffic advisories " "(e.g. bearing in clock positions and distance). " "Respond with ATC instructions only, no extra commentary." ), "include_flight_context": True, "no_think": True, # dodaje /no_think do promptu (modele Qwen3 z reasoningiem) "window_always_on_top": True, # --- Glos (whisper / piper) --- "voice_enabled": True, "voice_ptt_mode": "hold", # "hold" = przytrzymaj PTT, mowisz, puszczasz; "toggle" = wcisnij aby zaczac/konczyc "whisper_cli": "/usr/bin/whisper-cli", "whisper_model": "/home/pali112/models/ggml-small.bin", "whisper_language": "auto", "record_cmd": ["pw-record", "--format=s16", "--rate=16000", "--channels=1"], "piper": "/opt/piper-tts/piper", "piper_model": "/home/pali112/.local/share/piper-voices/en_US-lessac-medium.onnx", "play_cmd": ["pw-play"], "tts_enabled": True, # --- Plan lotu --- # Fallback dla samolotow z wlasnym FMC (Toliss/Zibo), ktore nie zapisuja # planu do natywnego FMS X-Plane. Wskaz plik tekstowy; kazda linia to jeden # punkt: "NAZWA [WYSOKOSC_stop]" (wysokosc opcjonalna), '#' = komentarz. "flightplan_file": "", # --- Procedury ATC --- # Katalog z plikami procedur. Puste = /procedures. # _global.txt = zawsze dolaczane; .txt = per-lotnisko. "procedures_dir": "", "use_procedures": True, # --- Proaktywny ATC --- # Gdy wlaczone, ATC sam inicjuje kontakt (np. traffic advisory, zmiana fazy # lotu), zamiast tylko odpowiadac na Twoje wiadomosci. "proactive_enabled": True, # Minimalny odstęp (sekundy) miedzy dwoma proaktywnymi komunikatami. "proactive_cooldown": 30, } # Dataref -> (nazwa kontekstu, mnoznik, jednostka) CONTEXT_DATAREFS = [ ("sim/flightmodel/position/latitude", "Latitude", 1.0, "deg"), ("sim/flightmodel/position/longitude", "Longitude", 1.0, "deg"), ("sim/flightmodel/misc/h_ind", "Alt (baro)", 1.0, "ft"), ("sim/flightmodel/position/indicated_airspeed", "IAS", 1.0, "kt"), ("sim/flightmodel/position/groundspeed", "GS", 1.943844, "kt"), ("sim/flightmodel/position/mag_psi", "HDG (mag)", 1.0, "deg"), ("sim/cockpit/radios/transponder_code", "Squawk", 1.0, ""), ("sim/cockpit/radios/com1_freq_hz", "COM1", 0.01, "MHz"), ("sim/cockpit/radios/com2_freq_hz", "COM2", 0.01, "MHz"), ("sim/cockpit/radios/nav1_freq_hz", "NAV1", 0.01, "MHz"), ] TAILNUM_DATAREF = "sim/aircraft/view/acf_tailnum" VR_ENABLED_DATAREF = "sim/graphics/VR/enabled" TUNED1_DATAREF = "sim/atc/com1_tuned_facility" TUNED2_DATAREF = "sim/atc/com2_tuned_facility" ELEVATION_DATAREF = "sim/flightmodel/position/elevation" # Nowoczesne datarefy radiowe (cockpit2/radios/actuators). Samoloty z wlasnym # systemem radiowym (Garmin / REP / Toliss / Zibo) czesto zapisuja czestotliwosc # TU, a legacy sim/cockpit/radios/*_freq_hz zostaje 0. Uzywamy jako fallback. RADIO_MODERN_DATAREFS = { "sim/cockpit/radios/com1_freq_hz": "sim/cockpit2/radios/actuators/com1_frequency_hz", "sim/cockpit/radios/com2_freq_hz": "sim/cockpit2/radios/actuators/com2_frequency_hz", "sim/cockpit/radios/nav1_freq_hz": "sim/cockpit2/radios/actuators/nav1_frequency_hz", } # Mapa typu sluzby ATC (sim/atc/*_tuned_facility) FACILITY_NAMES = { 0: "None", 1: "Delivery/Clearance", 2: "Ground", 3: "Tower", 4: "Tracon/Approach-Departure", 5: "Center", } # Datarefy TCAS (ruch z LiveTraffic / AI / multiplayer) # TCAS daje gotowe: namiar wzgledny, dystans, wysokosc wzgledna. TCAS_BEARING_DATAREF = "sim/cockpit2/tcas/indicators/relative_bearing_degs" TCAS_DISTANCE_DATAREF = "sim/cockpit2/tcas/indicators/relative_distance_mtrs" TCAS_ALTITUDE_DATAREF = "sim/cockpit2/tcas/indicators/relative_altitude_mtrs" TCAS_NUM_ACF_DATAREF = "sim/cockpit2/tcas/indicators/tcas_num_acf" TCAS_FLIGHT_ID_DATAREF = "sim/cockpit2/tcas/targets/flight_id" TCAS_ICAO_TYPE_DATAREF = "sim/cockpit2/tcas/targets/icao_type" # Ile slotow TCAS sprawdzac (X-Plane ma tablice float[64]) NUM_TCAS_SLOTS = 64 # Typy sluzb ATC w plikach scenery apt.dat (kolumna 1, wiersze 1050-1056) # 1050=ATIS/AWOS/ASOS, 1051=UNICOM/CTAF, 1052=Delivery/Clearance, # 1053=Ground, 1054=Tower, 1055=Approach, 1056=Departure APT_FREQ_CODES = { "1050": "ATIS", "1051": "UNICOM/CTAF", "1052": "Delivery/Clearance", "1053": "Ground", "1054": "Tower", "1055": "Approach", "1056": "Departure", } # Sluzby ATC, ktore powinny przy przelaczeniu podac nastepna czestotliwosc. # Dwie sciezki zalezne od kierunku lotu (odlot / przylot). # Odlot: Delivery -> Ground -> Tower -> Departure -> Center # Przylot: Center -> Approach -> Tower -> Ground NEXT_FACILITY_DEPARTURE = { "Delivery/Clearance": "Ground", "Ground": "Tower", "Tower": "Departure", "Tracon/Approach-Departure": "Center", "Center": None, } NEXT_FACILITY_ARRIVAL = { "Delivery/Clearance": "Ground", "Ground": None, "Tower": "Ground", "Tracon/Approach-Departure": "Tower", "Center": "Approach", } ELEVATION_AGL_DATAREF = "sim/flightmodel/position/y_agl" # Datarefy LiveTraffic (pelna informacja o ruchu: pozycja bezwzgledna, faza lotu, # czy na ziemi). LiveTraffic zapisuje je pod livetraffic/ac/*. # phase: 0=ground, 1=airborne (patrz dokumentacja LiveTraffic; dokladne znaczenie # sprawdzamy podgladem, bo enum fazy zalezy od wersji). LT_NUM_DATAREF = "livetraffic/ac/num" LT_PHASE_DATAREF = "livetraffic/ac/phase" LT_ON_GND_DATAREF = "livetraffic/ac/on_gnd" LT_LAT_DATAREF = "livetraffic/ac/lat" LT_LON_DATAREF = "livetraffic/ac/lon" LT_ALT_DATAREF = "livetraffic/ac/alt" LT_HEADING_DATAREF = "livetraffic/ac/heading" LT_SPEED_DATAREF = "livetraffic/ac/speed" LT_VSI_DATAREF = "livetraffic/ac/vsi" LT_DIST_DATAREF = "livetraffic/ac/dist" LT_BEARING_DATAREF = "livetraffic/ac/bearing" LT_KEY_DATAREF = "livetraffic/ac/key" LT_BULK_QUICK_DATAREF = "livetraffic/bulk/quick" LT_BULK_EXPENSIVE_DATAREF = "livetraffic/bulk/expensive" # Typy datarefow XPLM (bitfield) XPLM_TYPE_INT = 1 XPLM_TYPE_FLOAT = 2 XPLM_TYPE_DOUBLE = 4 XPLM_TYPE_FLOAT_ARRAY = 8 XPLM_TYPE_INT_ARRAY = 16 XPLM_TYPE_DATA = 32 # Ile slotow LiveTraffic sprawdzac (domyslnie tablice maja sporo slotow). NUM_LT_SLOTS = 64 # Mapa fazy lotu LiveTraffic (enum LTFlightPhase z LTAPI.h). # Kluczowe dla logiki "pas zajety": fazy startu (20-24) i ladowania (70-74). LT_PHASE_NAMES = { 0: "Unknown", 5: "Parked", 10: "Taxi", 20: "Take Off", 21: "Take Off Roll", 22: "Rotate", 23: "Lift Off", 24: "Initial Climb", 30: "Climb", 40: "Cruise", 50: "Descend", 60: "Approach", 61: "Final", 70: "Landing", 71: "Flare", 72: "Touch Down", 73: "Roll Out", 74: "Stopped on Runway", } # Fazy LiveTraffic, ktore oznaczaja "samolot fizycznie jest NA pasie" (na ziemi). # Wylaczamy fazy powietrzne (Lift Off 23, Initial Climb 24, Landing 70, Flare 71), # bo wtedy samolot juz NIE zajmuje pasa — inaczej "pas zajety" pali sie w nieskonczonosc # podczas startu (21->22->23->24) i ATC powtarza "hold short". LT_RUNWAY_OCCUPYING_PHASES = {10, 21, 22, 72, 73, 74} # Szerokosc buforu (metry) doliczana do pasa przy sprawdzaniu "czy na pasie". RUNWAY_BUFFER_M = 60.0 class XSayATC: def __init__(self): self.config = self._load_config() self.datarefs = {} # name -> dataref object self._resolved_datarefs = False self._tailnum_ref = None self._vr_ref = None self._modern_radio_refs = {} # Stan rozmowy self.messages = [] # lista slownikow {"role": "user"/"assistant"/"system", "text": str} self.pending_text = "" # tekst w polu wprowadzania self.status = "Gotowy." self.streaming = False self._model_cache = None self._stop_event = threading.Event() self._worker = None # Okna ImGui self._imgui_window = None self._config_window = None # Menu self._menu = None self._menu_open_idx = None self._menu_cfg_idx = None # Cache wyswietlania czestotliwosci w oknie glownym self._freq_display_cache = None # (icao, [linie]) lub None self._freq_display_ts = 0.0 # VR self._last_vr = None # Glos (STT / TTS) self._recording = False self._record_proc = None self._ptt_toggled = False # dla trybu "toggle" self._pending_send = None # tekst do wyslania z glownego watku (po STT) self._speak_lock = threading.Lock() # serializacja TTS (jedna odpowiedz naraz) # Sluzba ATC, na ktora bylismy ostatnio nastrojeni (do resetu rozmowy) self._last_facility = None # Kierunek lotu (odlot / przylot) — determinuje handoff ATC. # phase_mode: "auto" (z planu lotu) | "departure" | "arrival" (recznie). self.phase_mode = "auto" self.flight_phase = "departure" # faktyczna faza ("departure" | "arrival") # Proaktywny ATC (sam inicjuje kontakt) self._proactive_last_ts = 0.0 # timestamp ostatniego proaktywnego komunikatu self._proactive_last_phase = None # ostatnia znana faza (ground/airborne) self._proactive_announced_airports = set() # lotniska, na ktorych juz powitalismy/przegadalismy self._proactive_last_reason = None # ostatni powod (dedup: nie powtarzaj w petli) # Czestotliwosci lotnisk z apt.dat (leniwie wczytywane w tle) self._apt_freqs = {} # ICAO -> {kategoria: [freq_khz, ...]} self._apt_runways = {} # ICAO -> [ {name1,name2,lat1,lon1,lat2,lon2,width}, ... ] self._apt_loading = False self._apt_loaded = False self._elevation_agl_ref = None # Cache najblizszego lotniska (czasowy, zeby nie iterowac navaidow co klatke) self._nearest_icao_cache = None # (icao, timestamp) # Wybor pasa (opcja A: recznie przez pilota) self.selected_runway = "" # np. "33" lub "29"; puste = brak wyboru self._runway_icao = None # ICAO, dla ktorego wczytano liste pasow # Datarefy LiveTraffic (do podgladu ruchu; None = nie znaleziono) self._lt_num_ref = None self._lt_phase_ref = None self._lt_on_gnd_ref = None self._lt_lat_ref = None self._lt_lon_ref = None self._lt_alt_ref = None self._lt_heading_ref = None self._lt_speed_ref = None self._lt_vsi_ref = None self._lt_dist_ref = None self._lt_bearing_ref = None self._lt_key_ref = None self._lt_bulk_quick_ref = None self._lt_bulk_expensive_ref = None self._lt_available = False # Cache enumeracji LiveTraffic (2 s) — zeby nie czytac ~9 datarefow # na samolot co klatke (powodowalo przyciecia). self._lt_cache = None self._lt_cache_ts = 0.0 # ---------------------------- Config ---------------------------- def _load_config(self): cfg = dict(DEFAULT_CONFIG) try: with open(CONFIG_FILE, "r", encoding="utf-8") as f: data = json.load(f) if isinstance(data, dict): cfg.update(data) except Exception: pass return cfg def _save_config(self): try: with open(CONFIG_FILE, "w", encoding="utf-8") as f: json.dump(self.config, f, ensure_ascii=False, indent=2) except Exception as e: xp.log(f"[XSayATC] Blad zapisu config.json: {e}") # ---------------------------- Datarefs ---------------------------- def _ensure_datarefs(self): if self._resolved_datarefs: return for name, _label, _mult, _unit in CONTEXT_DATAREFS: self.datarefs[name] = xp.findDataRef(name) self._tailnum_ref = xp.findDataRef(TAILNUM_DATAREF) self._vr_ref = xp.findDataRef(VR_ENABLED_DATAREF) self._tuned1_ref = xp.findDataRef(TUNED1_DATAREF) self._tuned2_ref = xp.findDataRef(TUNED2_DATAREF) self._elevation_ref = xp.findDataRef(ELEVATION_DATAREF) self._elevation_agl_ref = xp.findDataRef(ELEVATION_AGL_DATAREF) # Datarefy TCAS (ruch z LiveTraffic / AI / multiplayer) self._tcas_bearing_ref = xp.findDataRef(TCAS_BEARING_DATAREF) self._tcas_distance_ref = xp.findDataRef(TCAS_DISTANCE_DATAREF) self._tcas_altitude_ref = xp.findDataRef(TCAS_ALTITUDE_DATAREF) self._tcas_num_ref = xp.findDataRef(TCAS_NUM_ACF_DATAREF) self._tcas_flightid_ref = xp.findDataRef(TCAS_FLIGHT_ID_DATAREF) self._tcas_icao_ref = xp.findDataRef(TCAS_ICAO_TYPE_DATAREF) # Nowoczesne datarefy radiowe jako fallback self._modern_radio_refs = { name: xp.findDataRef(modern) for name, modern in RADIO_MODERN_DATAREFS.items() } # LiveTraffic (opcjonalny — jesli nie ma, zostaje None) self._lt_num_ref = xp.findDataRef(LT_NUM_DATAREF) self._lt_phase_ref = xp.findDataRef(LT_PHASE_DATAREF) self._lt_on_gnd_ref = xp.findDataRef(LT_ON_GND_DATAREF) self._lt_lat_ref = xp.findDataRef(LT_LAT_DATAREF) self._lt_lon_ref = xp.findDataRef(LT_LON_DATAREF) self._lt_alt_ref = xp.findDataRef(LT_ALT_DATAREF) self._lt_heading_ref = xp.findDataRef(LT_HEADING_DATAREF) self._lt_speed_ref = xp.findDataRef(LT_SPEED_DATAREF) self._lt_vsi_ref = xp.findDataRef(LT_VSI_DATAREF) self._lt_dist_ref = xp.findDataRef(LT_DIST_DATAREF) self._lt_bearing_ref = xp.findDataRef(LT_BEARING_DATAREF) self._lt_key_ref = xp.findDataRef(LT_KEY_DATAREF) self._lt_bulk_quick_ref = xp.findDataRef(LT_BULK_QUICK_DATAREF) self._lt_bulk_expensive_ref = xp.findDataRef(LT_BULK_EXPENSIVE_DATAREF) self._lt_available = self._lt_num_ref is not None if self._lt_available: xp.log("[XSayATC] LiveTraffic datarefy wykryte (livetraffic/ac/*)") self._resolved_datarefs = True def _get_dataref(self, name, is_float=True): d = self.datarefs.get(name) if d is None: return None try: if is_float: return xp.getDataf(d) return xp.getDatai(d) except Exception: return None def _get_radio_hz(self, name): """Czyta czestotliwosc radia (int, 10 kHz). Najpierw legacy sim/cockpit/radios/*_freq_hz, a jesli 0 -> nowoczesny cockpit2.""" legacy = self.datarefs.get(name) legacy_v = 0 try: if legacy is not None: legacy_v = xp.getDatai(legacy) except Exception: legacy_v = 0 modern_ref = self._modern_radio_refs.get(name) modern_v = 0 if modern_ref is not None: try: modern_v = xp.getDatai(modern_ref) except Exception: modern_v = 0 if not legacy_v and not modern_v: xp.log(f"[XSayATC] radio {name}: legacy i modern = 0 (radio wylaczone?)") return legacy_v or modern_v def _read_string(self, dref): try: return xp.getDatas(dref) except Exception: return None # ---------------------------- Kontekst lotu (TYLKO glowny watek) ---------------------------- def _collect_context(self): """Zbiera kontekst lotu. WYWOLYWAC TYLKO na glownym watku.""" ctx = {} lines = [] INT_RADIO_DATAREFS = ( "sim/cockpit/radios/transponder_code", "sim/cockpit/radios/com1_freq_hz", "sim/cockpit/radios/com2_freq_hz", "sim/cockpit/radios/nav1_freq_hz", ) RADIO_FREQ_DATAREFS = ( "sim/cockpit/radios/com1_freq_hz", "sim/cockpit/radios/com2_freq_hz", "sim/cockpit/radios/nav1_freq_hz", ) for name, label, mult, unit in CONTEXT_DATAREFS: if name in RADIO_FREQ_DATAREFS: # Czestotliwosc radia czytana z fallbackiem na cockpit2 v = self._get_radio_hz(name) val = int(v) * mult ctx[label] = val lines.append(f"{label}: {val:.3f} {unit}".strip()) continue v = self._get_dataref(name, is_float=(name not in INT_RADIO_DATAREFS)) if v is None: continue if name == "sim/cockpit/radios/transponder_code": ctx[label] = int(v) lines.append(f"{label}: {int(v)}") else: val = v * mult ctx[label] = val unit_s = (" " + unit) if unit else "" lines.append(f"{label}: {val:.1f}{unit_s}") tail = self._read_string(self._tailnum_ref) if tail: tail = tail.strip() ctx["Callsign"] = tail lines.insert(0, f"Callsign: {tail}") # Sluzba ATC, na ktora jestes nastrojony fac1 = self._get_tuned_facility(self._tuned1_ref) fac2 = self._get_tuned_facility(self._tuned2_ref) com1 = ctx.get("COM1") com2 = ctx.get("COM2") tuned = None if fac1 and fac1 != "None": tuned = (fac1, com1, 1) elif fac2 and fac2 != "None": tuned = (fac2, com2, 2) if tuned: name, freq, num = tuned freq_s = f"{freq:.3f} MHz" if freq is not None else "? MHz" ctx["TunedFacility"] = name lines.append(f"Tuned facility: {name} ({freq_s} on COM{num})") else: ctx["TunedFacility"] = "None" lines.append("Tuned facility: None (no active ATC service on COM1/COM2)") # Faza lotu (na ziemi / w powietrzu) z AGL agl_m = self._get_agl() on_ground = (agl_m is not None and agl_m < 1.0) ctx["Phase"] = "ground" if on_ground else "airborne" lines.append("Phase: " + ("on ground (taxi/ramp)" if on_ground else "airborne")) # Kierunek lotu (odlot / przylot) — auto z planu lub recznie self._update_flight_phase_auto() ctx["FlightPhase"] = self.flight_phase mode_s = self.phase_mode if self.phase_mode != "auto" else "auto (from flight plan)" lines.append("Flight phase (" + mode_s + "): " + ("DEPARTURE" if self.flight_phase == "departure" else "ARRIVAL")) # Czestotliwosci najblizszego lotniska (do podpowiedzi nastepnej czestotliwosci) icao = self._nearest_airport_icao() if icao: ctx["NearestAirport"] = icao lines.append(f"Nearest airport: {icao}") freq_lines = self._format_airport_freqs(icao) if freq_lines: lines.append("Airport frequencies:") lines.extend(freq_lines) ctx["AirportFreqs"] = freq_lines else: lines.append("Airport frequencies: (not available)") # Podpowiedz nastepna sluzbe, na ktora pilot ma sie przelaczyc if tuned: nxt = self._next_facility_hint(tuned[0]) if nxt: ctx["NextFacility"] = nxt lines.append(f"Next expected facility (per standard flow): {nxt}") # Stan wybranego pasa (zajety/wolny) — dodawany do kontekstu, zeby # ATC wiedzial, czy moze dac zgodę na start/lądowanie, gdy pilot pyta. if self.selected_runway and self._runway_icao: occ = self._runway_occupants(self._runway_icao, self.selected_runway) if occ: desc = ", ".join( (o['phase_name'] + (f" (key 0x{o['key']:X})" if isinstance(o.get('key'), int) else "")) for o in occ ) ctx["RunwayStatus"] = "occupied" lines.append(f"Selected runway {self.selected_runway}: OCCUPIED by {desc}") else: ctx["RunwayStatus"] = "clear" lines.append(f"Selected runway {self.selected_runway}: clear") # Ruch lotniczy w poblizu traffic_lines = self._collect_traffic() ctx["Traffic"] = traffic_lines if traffic_lines: lines.append("Nearby traffic:") lines.extend(traffic_lines) else: lines.append("Nearby traffic: none detected") # Plan lotu z FMS/GPS fp_lines = self._collect_flight_plan() ctx["FlightPlan"] = fp_lines if fp_lines: lines.append("Flight plan (FMS/GPS):") lines.extend(fp_lines) return ctx, "\n".join(lines) def _get_tuned_facility(self, ref): if ref is None: return None try: code = xp.getDatai(ref) return FACILITY_NAMES.get(code, f"Unknown({code})") except Exception: return None def _get_agl(self): """Zwraca wysokosc AGL w metrach (lub None).""" if self._elevation_agl_ref is None: return None try: return xp.getDataf(self._elevation_agl_ref) except Exception: return None def _procedures_dir(self): """Zwraca sciezke katalogu procedur.""" if self.config.get("procedures_dir"): return self.config["procedures_dir"] return os.path.join(os.path.dirname(os.path.abspath(__file__)), "procedures") def _nearest_airport_icao(self, force=False): """Zwraca ICAO najblizszego lotniska (z natywnej bazy navaidow). Skan calej bazy navaidow jest ciezki, wiec normalnie wynik jest cache'owany (10 s). force=True wymusza ponowny skan.""" import time as _time now = _time.time() if not force and self._nearest_icao_cache is not None: c_icao, c_ts = self._nearest_icao_cache if now - c_ts < 10.0: return c_icao lat = self._get_dataref("sim/flightmodel/position/latitude", is_float=True) lon = self._get_dataref("sim/flightmodel/position/longitude", is_float=True) if lat is None or lon is None: return None try: import math best_id = None best_dist = None nav = xp.getFirstNavAid() while nav is not None and nav != xp.NAV_NOT_FOUND: info = xp.getNavAidInfo(nav) if info is not None and getattr(info, "type", None) == xp.Nav_Airport: dlat = info.latitude - lat dlon = info.longitude - lon dist = dlat * dlat + dlon * dlon if best_dist is None or dist < best_dist: best_dist = dist best_id = getattr(info, "navAidID", None) nav = xp.getNextNavAid(nav) self._nearest_icao_cache = (best_id, now) return best_id except Exception as e: xp.log(f"[XSayATC] Blad szukania lotniska: {e}") return None def _read_procedure_file(self, path): """Czyta plik procedury, zwraca tekst (bez linii komentarza '#').""" try: with open(path, "r", encoding="utf-8") as f: lines = [ln.rstrip() for ln in f if ln.strip() and not ln.lstrip().startswith("#")] return "\n".join(lines) except Exception: return "" def _collect_procedures(self): """Zbiera tekst procedur: _global.txt + .txt najblizszego lotniska.""" if not self.config.get("use_procedures", True): return "" d = self._procedures_dir() if not os.path.isdir(d): return "" parts = [] g = os.path.join(d, "_global.txt") if os.path.exists(g): t = self._read_procedure_file(g) if t: parts.append(t) icao = self._nearest_airport_icao() if icao: p = os.path.join(d, icao.upper() + ".txt") if os.path.exists(p): t = self._read_procedure_file(p) if t: parts.append(f"[Procedures for {icao.upper()}]\n" + t) return "\n\n".join(parts) # ---------------------------- Czestotliwosci lotnisk (apt.dat) ---------------------------- def _airport_freq_path(self): """Zwraca sciezke do apt.dat Global Airports (najwieksza baza lotnisk).""" try: xp_dir = xp.getSystemPath() except Exception: xp_dir = None if xp_dir: p = os.path.join(xp_dir, "Global Scenery", "Global Airports", "Earth nav data", "apt.dat") if os.path.exists(p): return p # Fallback: zgadnij wzgledem tego pliku (Resources/plugins/PythonPlugins) here = os.path.dirname(os.path.abspath(__file__)) p = os.path.normpath(os.path.join(here, "..", "..", "..", "Global Scenery", "Global Airports", "Earth nav data", "apt.dat")) if os.path.exists(p): return p return None def _ensure_apt_freqs(self): """Wczytuje czestotliwosci z apt.dat w tle (raz, leniwie).""" if self._apt_loaded or self._apt_loading: return path = self._airport_freq_path() if not path: self._apt_loaded = True xp.log("[XSayATC] Nie znaleziono apt.dat (Global Airports)") return self._apt_loading = True threading.Thread(target=self._parse_apt_freqs, args=(path,), daemon=True).start() def _parse_apt_freqs(self, path): """Watek roboczy: parsuje apt.dat (czestotliwosci + pasy).""" freqs = {} runways = {} try: cur_icao = None with open(path, "r", encoding="utf-8", errors="ignore") as f: for line in f: parts = line.split() if not parts: continue code = parts[0] # Wiersz naglowka lotniska: 1|16|17 ... ICAO Nazwa if code in ("1", "16", "17") and len(parts) >= 5: cur_icao = parts[4] freqs.setdefault(cur_icao, {}) continue # Wiersz czestotliwosci: 1050-1056 FREQ NAZWA if code in APT_FREQ_CODES and len(parts) >= 2: cat = APT_FREQ_CODES[code] try: freq_khz = int(parts[1]) except ValueError: continue if cur_icao: freqs.setdefault(cur_icao, {}).setdefault(cat, []).append(freq_khz) # Wiersz pasa: 100 width ... name1 lat1 lon1 ... name2 lat2 lon2 ... elif code == "100" and len(parts) >= 20 and cur_icao: try: width_ft = float(parts[1]) name1 = parts[8] lat1 = float(parts[9]) lon1 = float(parts[10]) name2 = parts[17] lat2 = float(parts[18]) lon2 = float(parts[19]) runways.setdefault(cur_icao, []).append({ "name1": name1, "name2": name2, "lat1": lat1, "lon1": lon1, "lat2": lat2, "lon2": lon2, "width_ft": width_ft, }) except (ValueError, IndexError): continue self._apt_freqs = freqs self._apt_runways = runways except Exception as e: xp.log(f"[XSayATC] Blad parsowania apt.dat: {e}") self._apt_freqs = {} self._apt_runways = {} finally: self._apt_loaded = True self._apt_loading = False def _airport_freqs(self, icao): """Zwraca slownik {kategoria: [freq_khz, ...]} dla lotniska (albo {}).""" self._ensure_apt_freqs() if not icao: return {} return self._apt_freqs.get(icao.upper(), self._apt_freqs.get(icao, {})) def _format_airport_freqs(self, icao): """Zwraca liste linii tekstowych z czestotliwosciami lotniska.""" freqs = self._airport_freqs(icao) if not freqs: return [] lines = [] order = ["ATIS", "Delivery/Clearance", "Ground", "Tower", "Departure", "Approach", "UNICOM/CTAF"] for cat in order: vals = freqs.get(cat) if not vals: continue for f in vals: lines.append(f" {cat}: {f / 1000.0:.3f} MHz") # Ewentualne kategorie spoza listy (np. inne nazwy) for cat, vals in freqs.items(): if cat in order: continue for f in vals: lines.append(f" {cat}: {f / 1000.0:.3f} MHz") return lines def _next_facility_hint(self, name): """Zwraca nastepna sluzbe ATC wg kierunku lotu (odlot / przylot).""" if not name: return None if self.flight_phase == "arrival": return NEXT_FACILITY_ARRIVAL.get(name) return NEXT_FACILITY_DEPARTURE.get(name) def _airport_runways(self, icao): """Zwraca liste pasow lotniska [{name1,name2,lat1,lon1,lat2,lon2,width_ft}].""" self._ensure_apt_freqs() if not icao: return [] return self._apt_runways.get(icao.upper(), self._apt_runways.get(icao, [])) def _runway_names(self, icao): """Zwraca liste nazw pasow (np. ['11','29','15','33']) dla lotniska.""" rwys = self._airport_runways(icao) names = [] for r in rwys: if r["name1"] not in names: names.append(r["name1"]) if r["name2"] not in names: names.append(r["name2"]) return names def _find_runway(self, icao, name): """Zwraca pas o nazwie name (np. '33') dla lotniska, lub None.""" for r in self._airport_runways(icao): if r["name1"] == name or r["name2"] == name: return r return None def _point_on_runway(self, runway, lat, lon): """Zwraca True, jesli punkt (lat,lon) lezy w prostokacie pasa (+ bufor). Pasek traktujemy jako odcinek + szerokosc. Liczymy odleglosc punktu od odcinka (prog1 -> prog2) w metrach i sprawdzamy, czy <= (szerokosc/2 + bufor) ORAZ czy rzut punktu lezy w zakresie dlugosci pasa (z buforem na koncach).""" import math # Konwersja deg -> metry (przyblizenie lokalne) lat1, lon1 = runway["lat1"], runway["lon1"] lat2, lon2 = runway["lat2"], runway["lon2"] width_m = runway["width_ft"] * 0.3048 half = width_m / 2.0 + RUNWAY_BUFFER_M # lokalne wspolrzedne metryczne wzgledem progu 1 m_per_deg_lat = 111320.0 m_per_deg_lon = 111320.0 * math.cos(math.radians(lat1)) x1, y1 = 0.0, 0.0 x2 = (lon2 - lon1) * m_per_deg_lon y2 = (lat2 - lat1) * m_per_deg_lat xp = (lon - lon1) * m_per_deg_lon yp = (lat - lat1) * m_per_deg_lat dx = x2 - x1 dy = y2 - y1 length2 = dx * dx + dy * dy if length2 <= 0: return False # rzut parametru t (0..1) t = ((xp - x1) * dx + (yp - y1) * dy) / length2 # bufor na koncach pasa (ok. 60m) end_buf = RUNWAY_BUFFER_M / (math.sqrt(length2) or 1.0) if t < -end_buf or t > 1.0 + end_buf: return False # punkt rzutu proj_x = x1 + t * dx proj_y = y1 + t * dy dist = math.hypot(xp - proj_x, yp - proj_y) return dist <= half def _runway_occupants(self, icao, runway_name): """Zwraca liste samolotow LiveTraffic, ktore zajmuja wskazany pas. Zajmujacy = faza w LT_RUNWAY_OCCUPYING_PHASES ORAZ pozycja na pasie. Zwraca liste dictow {key, phase, phase_name, lat, lon, alt}.""" runway = self._find_runway(icao, runway_name) if not runway: return [] acs = self._lt_enumerate() occ = [] for a in acs: ph = a.get("phase") if ph not in LT_RUNWAY_OCCUPYING_PHASES: continue lat = a.get("lat") lon = a.get("lon") if lat is None or lon is None: continue if self._point_on_runway(runway, lat, lon): occ.append({ "key": a.get("key"), "phase": ph, "phase_name": LT_PHASE_NAMES.get(ph, str(ph)), "lat": lat, "lon": lon, "alt": a.get("alt"), }) return occ def _freq_display_lines(self): """Zwraca (icao, [linie]) czestotliwosci z cache. NIE liczy nic — tylko zwraca to, co bylo ostatnio policzone (przez _refresh_freq_display).""" if self._freq_display_cache is None: return (None, []) return self._freq_display_cache def _refresh_freq_display(self): """Recznie (przycisk) przelicza najblizsze lotnisko, jego czestotliwosci i liste pasow (ustawia tez self._runway_icao).""" import time as _time icao = self._nearest_airport_icao(force=True) lines = self._format_airport_freqs(icao) if icao else [] self._freq_display_cache = (icao, lines) self._freq_display_ts = _time.time() # Zapamietaj ICAO do wyboru pasa (bez ponownego skanu navaidow) self._runway_icao = icao return self._freq_display_cache def _read_float_array(self, ref, count): """Czyta tablice float z datarefu. Zwraca liste lub [].""" if ref is None: return [] try: values = [] xp.getDatavf(ref, values, 0, count) return values except Exception: return [] def _read_packed_strings(self, ref, count, strlen=8): """Czyta byte[512] jako 64 stringow po strlen bajtow (7 znakow + NUL).""" if ref is None: return [] try: raw = xp.getDatas(ref) if not raw: return [] out = [] for i in range(count): chunk = raw[i * strlen:(i + 1) * strlen] s = chunk.split("\x00", 1)[0].strip() out.append(s) return out except Exception: return [] def _collect_traffic(self): """Zbiera liste pobliskiego ruchu z TCAS (LiveTraffic / AI / multiplayer).""" out = [] bearing = self._read_float_array(self._tcas_bearing_ref, NUM_TCAS_SLOTS) distance = self._read_float_array(self._tcas_distance_ref, NUM_TCAS_SLOTS) altitude = self._read_float_array(self._tcas_altitude_ref, NUM_TCAS_SLOTS) flight_ids = self._read_packed_strings(self._tcas_flightid_ref, NUM_TCAS_SLOTS) icao_types = self._read_packed_strings(self._tcas_icao_ref, NUM_TCAS_SLOTS) if not distance: return out for i in range(NUM_TCAS_SLOTS): if i >= len(distance): break dist_m = distance[i] # 0 lub blisko 0 = pusty slot if not dist_m or dist_m <= 0: continue dist_nm = dist_m / 1852.0 rel_alt_m = altitude[i] if i < len(altitude) else 0.0 rel_alt_ft = rel_alt_m * 3.28084 brg_rel = bearing[i] if i < len(bearing) else 0.0 brg_rel = brg_rel % 360.0 # pozycja zegarowa (12-godzinna) wzgledem namiaru wzglednego clock = int(round((brg_rel / 30.0) % 12)) or 12 callsign = flight_ids[i] if i < len(flight_ids) else "" icao = icao_types[i] if i < len(icao_types) else "" tag = "" if callsign: tag += callsign if icao: tag += ((" " + icao) if tag else icao) if tag: tag = " (" + tag + ")" out.append( f" {dist_nm:.1f} nm, {clock}:00, alt {rel_alt_ft:+.0f} ft (brg {brg_rel:.0f}){tag}" ) return out def _collect_flight_plan(self): """Zbiera plan lotu z FMS/GPS lub z pliku fallback. TYLKO glowny watek.""" lines = [] # 1) Najpierw natywny FMS/GPS X-Plane try: n = xp.countFMSEntries() except Exception: n = 0 if n and n > 0: try: dest_idx = xp.getDestinationFMSEntry() except Exception: dest_idx = -1 for i in range(n): try: info = xp.getFMSEntryInfo(i) except Exception: continue if info is None: continue navid = getattr(info, "navAidID", "") or "" alt = getattr(info, "altitude", 0) or 0 marker = " [DEST]" if i == dest_idx else "" alt_s = f", alt {int(alt)} ft" if alt else "" if navid: lines.append(f" {i}: {navid}{alt_s}{marker}") else: lat = getattr(info, "lat", None) lon = getattr(info, "lon", None) if lat is not None and lon is not None: lines.append(f" {i}: lat/lon {lat:.4f}/{lon:.4f}{alt_s}{marker}") return lines # 2) Fallback: plik wskazany w konfiguracji (samoloty z wlasnym FMC) fp_file = self.config.get("flightplan_file", "") if not fp_file or not os.path.exists(fp_file): return lines try: with open(fp_file, "r", encoding="utf-8") as f: for i, raw in enumerate(f): line = raw.strip() if not line or line.startswith("#"): continue # "NAZWA [WYSOKOSC]" — oddziel nazwe od opcjonalnej wysokosci parts = line.split() alt = None if len(parts) >= 2: # ostatni token moze byc liczba (wysokosc w stopach) try: alt = int(parts[-1]) name = " ".join(parts[:-1]) except ValueError: alt = None name = " ".join(parts) else: name = " ".join(parts) alt_s = f", alt {alt} ft" if alt else "" lines.append(f" {i}: {name}{alt_s}") except Exception as e: xp.log(f"[XSayATC] Blad odczytu pliku planu lotu: {e}") return lines def _get_flight_plan_airports(self): """Zwraca (departure_icao, destination_icao) z planu lotu. Dla natywnego FMS: pierwszy wpis = odlot, wpis DEST = przylot. Dla pliku fallback: pierwsza linia = odlot, ostatnia = przylot. Zwraca (None, None), jesli planu nie ma.""" # 1) Natywny FMS/GPS try: n = xp.countFMSEntries() except Exception: n = 0 if n and n > 0: try: dest_idx = xp.getDestinationFMSEntry() except Exception: dest_idx = -1 dep = None dest = None for i in range(n): try: info = xp.getFMSEntryInfo(i) except Exception: continue if info is None: continue navid = getattr(info, "navAidID", "") or "" if not navid: continue if dep is None: dep = navid if i == dest_idx: dest = navid if dep is not None or dest is not None: return (dep, dest) # 2) Plik fallback fp_file = self.config.get("flightplan_file", "") if fp_file and os.path.exists(fp_file): try: names = [] with open(fp_file, "r", encoding="utf-8") as f: for raw in f: line = raw.strip() if not line or line.startswith("#"): continue parts = line.split() if not parts: continue # ostatni token moze byc liczba (wysokosc) try: int(parts[-1]) name = " ".join(parts[:-1]) or parts[-1] except ValueError: name = " ".join(parts) if name: names.append(name) if names: return (names[0], names[-1]) except Exception as e: xp.log(f"[XSayATC] Blad odczytu planu (airports): {e}") return (None, None) def _update_flight_phase_auto(self): """Auto-detekcja kierunku z planu lotu (odlot/przylot). Porownuje najblizsze lotnisko z lotniskiem startu i celu planu. - blisko lotniska startu (i nie jestesmy wysoko) -> departure - blisko lotniska celu -> arrival Gdy planu brak, nie zmienia fazy.""" if self.phase_mode != "auto": return dep, dest = self._get_flight_plan_airports() if not dep and not dest: return icao = self._nearest_airport_icao() if not icao: return icao = icao.upper() if dest and icao == dest.upper(): self.flight_phase = "arrival" elif dep and icao == dep.upper(): self.flight_phase = "departure" # ---------------------------- Komunikacja z LLM ---------------------------- def _resolve_model(self): if self._model_cache: return self._model_cache if self.config.get("model"): self._model_cache = self.config["model"] return self._model_cache try: r = requests.get(self.config["base_url"].rstrip("/") + "/v1/models", timeout=5) r.raise_for_status() data = r.json() models = data.get("data") or [] if models: self._model_cache = models[0].get("id") return self._model_cache except Exception as e: xp.log(f"[XSayATC] Nie mozna pobrac modelu: {e}") return None def _build_messages(self, user_text, flight_ctx_text, procedures_text, proactive_reason=None): """Buduje liste messages. flight_ctx_text i procedures_text musza byc przekazane (bez odczytu datarefow / plikow na watku roboczym). proactive_reason != None -> ATC ma sie odezwac sam (bez wiadomosci pilota).""" msgs = [] sp = self.config.get("system_prompt", "") if self.config.get("no_think", True) and sp and "/no_think" not in sp: sp = sp + "\n/no_think" msgs.append({"role": "system", "content": sp}) if self.config.get("include_flight_context", True) and flight_ctx_text: msgs.append({"role": "system", "content": "Pilot's current flight context:\n" + flight_ctx_text}) if procedures_text: msgs.append({"role": "system", "content": "Local ATC procedures:\n" + procedures_text}) for m in self.messages[-12:]: msgs.append({"role": m["role"], "content": m["text"]}) if proactive_reason: # ATC inicjuje kontakt — nie ma wiadomosci pilota, jest wyzwalacz. msgs.append({"role": "system", "content": "ATC PROACTIVE trigger: " + proactive_reason + ". You must now initiate contact with the pilot in your " "current facility role, using standard phraseology."}) else: msgs.append({"role": "user", "content": user_text}) return msgs def _request(self, messages): url = self.config["base_url"].rstrip("/") + "/v1/chat/completions" model = self._resolve_model() or self.config.get("model") or "model" payload = { "model": model, "messages": messages, "temperature": self.config.get("temperature", 0.7), "max_tokens": self.config.get("max_tokens", 512), "stream": True, } return requests.post(url, json=payload, stream=True, timeout=(10, 120)) def _run_stream(self, user_text, flight_ctx_text, procedures_text, proactive_reason=None): """Watek roboczy: TYLKO siec i aktualizacja self.messages. Bez xp.getData*.""" self.streaming = True self.status = "ATC mysli..." # Historia do UI if proactive_reason: # Brak wiadomosci pilota — ATC mowi sam. Zapisujemy tylko odpowiedz. self.messages.append({"role": "assistant", "text": ""}) else: self.messages.append({"role": "user", "text": user_text}) self.messages.append({"role": "assistant", "text": ""}) try: messages = self._build_messages(user_text, flight_ctx_text, procedures_text, proactive_reason) resp = self._request(messages) resp.raise_for_status() buf = "" for raw in resp.iter_lines(decode_unicode=True): if self._stop_event.is_set(): break if not raw or not raw.startswith("data:"): continue data = raw[len("data:"):].strip() if data == "[DONE]": break try: chunk = json.loads(data) except Exception: continue choices = chunk.get("choices") or [] if not choices: continue delta = choices[0].get("delta") or {} content = delta.get("content") if content: buf += content self.messages[-1]["text"] = buf if self.messages[-1]["text"] == "": self.messages[-1]["text"] = "(brak odpowiedzi)" self.status = "Gotowy." except Exception as e: xp.log(f"[XSayATC] Blad zapytania: {e}") self.status = f"Blad: {e}" if self.messages and self.messages[-1]["role"] == "assistant": if not self.messages[-1]["text"]: self.messages[-1]["text"] = f"(blad: {e})" finally: self.streaming = False # Odczytaj odpowiedz glosem (TTS) w osobnym watku if self.config.get("tts_enabled", True) and self.messages: last_text = self.messages[-1].get("text", "") if last_text and last_text not in ("(brak odpowiedzi)",): threading.Thread(target=self._speak, args=(last_text,), daemon=True).start() def send(self, text): """Wywolywane na glownym watku (przycisk / PTT). Zbiera kontekst tu, bo tu wolno.""" text = (text or "").strip() if not text or self.streaming: return self._dispatch(text, None) def _dispatch(self, user_text, proactive_reason): """Wspolna sciezka wysylania (tekst pilota lub wyzwalacz proaktywny). Zbiera kontekst i procedury na glownym watku, potem startuje watek.""" if self.streaming: return # Ustaw flage NATYCHMIAST (przed startem watku), zeby zamknac okno # czasowe, w ktorym drugie zdarzenie tez przeszlo i odpowiedzi sie # nakladaly. To zwykle przypisanie — nic nie blokuje. self.streaming = True # Zbierz kontekst lotu NA GLOWNYM WATKU flight_ctx_text = None _ctx = None if self.config.get("include_flight_context", True): try: _ctx, flight_ctx_text = self._collect_context() except Exception as e: xp.log(f"[XSayATC] Blad zbierania kontekstu: {e}") flight_ctx_text = None # Reset rozmowy przy zmianie sluzby ATC (Ground->Tower itp.), # zeby model nie mieszal frazeologii poprzednich rol. facility = _ctx.get("TunedFacility") if _ctx else None if facility is not None and facility != self._last_facility: self.messages = [] self.status = f"Przelaczono na: {facility}" self._last_facility = facility # Zbierz procedury ATC NA GLOWNYM WATKU (czytanie plikow/navaidow) procedures_text = "" try: procedures_text = self._collect_procedures() except Exception as e: xp.log(f"[XSayATC] Blad zbierania procedur: {e}") procedures_text = "" self._stop_event.clear() self._worker = threading.Thread( target=self._run_stream, args=(user_text, flight_ctx_text, procedures_text, proactive_reason), daemon=True) self._worker.start() def stop(self): self._stop_event.set() # ---------------------------- Glos (STT / TTS) ---------------------------- def _voice_enabled(self): return bool(self.config.get("voice_enabled", True)) def _start_recording(self): """Rozpoczyna nagrywanie mikrofonu do pliku tymczasowego.""" if self._recording: return import tempfile self._record_file = tempfile.mktemp(suffix=".wav", prefix="xsayatc_") cmd = list(self.config.get("record_cmd", ["pw-record", "--format=s16", "--rate=16000", "--channels=1"])) cmd.append(self._record_file) try: self._record_proc = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) self._recording = True self.status = "Nagrywanie... (pusc PTT aby wyslac)" except Exception as e: xp.log(f"[XSayATC] Blad nagrywania: {e}") self._record_proc = None def _stop_recording_and_send(self): """Konczy nagrywanie, potem W TLE transkrybuje whisperem i wysyla. Transkrypcja (whisper, subprocess.run) trwa kilka sekund, wiec NIE moze dzialac na glownym watku — inaczej zamraza gre. Robimy ja w watku.""" if not self._recording: return self._recording = False if self._record_proc is not None: try: # SIGINT kaze pw-record poprawnie domknac plik WAV self._record_proc.send_signal(2) # 2 = SIGINT try: self._record_proc.wait(timeout=3) except Exception: self._record_proc.kill() self._record_proc.wait(timeout=2) except Exception: pass self._record_proc = None wav = getattr(self, "_record_file", None) if not wav or not os.path.exists(wav): self.status = "Blad: brak nagrania" return self.status = "Transkrybuje (whisper)..." # Transkrypcja + wyslanie w osobnym watku, zeby nie blokowac X-Plane. threading.Thread(target=self._transcribe_and_send, args=(wav,), daemon=True).start() def _transcribe_and_send(self, wav): """Watek roboczy: transkrybuje WAV, a wynik kolejki do self._pending_send. NIE wywoluje send() tutaj — send() czyta datarefy (musi byc na glownym watku). Zamiast tego zapisuje tekst, a glowna petla (flight loop) go podniesie i wywola send() bezpiecznie.""" text = self._transcribe(wav) try: os.remove(wav) except Exception: pass if text: self._pending_send = text else: self.status = "Nie rozpoznano mowy." def _transcribe(self, wav_path): """Uruchamia whisper-cli i zwraca rozpoznany tekst.""" import tempfile out_file = tempfile.mktemp(suffix="", prefix="xsayatc_stt_") cli = self.config.get("whisper_cli", "/usr/bin/whisper-cli") model = self.config.get("whisper_model", "") lang = self.config.get("whisper_language", "auto") cmd = [cli, "-m", model, "-l", lang, "-otxt", "-of", out_file, "-f", wav_path, "-np"] try: subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=60) txt_file = out_file + ".txt" if os.path.exists(txt_file): with open(txt_file, "r", encoding="utf-8") as f: text = f.read().strip() try: os.remove(txt_file) except Exception: pass return text return "" except Exception as e: xp.log(f"[XSayATC] Blad whisper: {e}") return "" def _clean_env(self): """Zwraca srodowisko bez LD_LIBRARY_PATH/LD_PRELOAD ze Steam, zeby piper/pw-play uzywaly wlasnych bibliotek (inaczej Steam Runtime podklada stara libespeak-ng i piper zwraca pusty plik).""" env = dict(os.environ) env.pop("LD_PRELOAD", None) # Zostawiamy tylko sciezki systemowe, nie Steam Runtime. ld = env.pop("LD_LIBRARY_PATH", "") # Dopisujemy /opt/piper-tts na poczatek, by piper znalazl swoje libs. env["LD_LIBRARY_PATH"] = "/opt/piper-tts" return env def _speak(self, text): """Synteza mowy (piper) i odtworzenie. Watek roboczy. Lock serializuje TTS — inaczej dwie odpowiedzi naraz sie nakladaja (piper + pw-play z dwoch watkow jednoczesnie).""" if not self.config.get("tts_enabled", True): xp.log("[XSayATC] TTS wylaczone.") return text = (text or "").strip() if not text: return if not self._speak_lock.acquire(blocking=False): # Inna odpowiedz wlasnie gra — nie nakladaj, po prostu pomin. xp.log("[XSayATC] TTS: pomijam (inny komunikat gra)") return try: self._speak_locked(text) finally: self._speak_lock.release() def _speak_locked(self, text): """Wlasciwa synteza + odtworzenie (pod lockiem).""" piper = self.config.get("piper", "/opt/piper-tts/piper") model = self.config.get("piper_model", "") import tempfile wav = tempfile.mktemp(suffix=".wav", prefix="xsayatc_tts_") env = self._clean_env() try: xp.log(f"[XSayATC] TTS: piper -> {wav}") p = subprocess.Popen( [piper, "-m", model, "-f", wav], stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, env=env) _out, err = p.communicate(input=text.encode("utf-8"), timeout=60) if err: xp.log(f"[XSayATC] TTS piper stderr: {err.decode('utf-8', 'ignore')[:200]}") if os.path.exists(wav) and os.path.getsize(wav) > 0: play_cmd = list(self.config.get("play_cmd", ["pw-play"])) xp.log(f"[XSayATC] TTS: odtwarzam: {play_cmd} {wav}") r = subprocess.run(play_cmd + [wav], stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, timeout=60, env=env) if r.returncode != 0: xp.log(f"[XSayATC] TTS odtwarzanie kod={r.returncode} stderr={r.stderr.decode('utf-8','ignore')[:200]}") try: os.remove(wav) except Exception: pass else: xp.log(f"[XSayATC] TTS: brak pliku WAV (rozmiar 0 lub nie istnieje)") except Exception as e: xp.log(f"[XSayATC] Blad TTS: {e}") # ---------------------------- Proaktywny ATC ---------------------------- def _proactive_check(self): """Sprawdza warunki i ewentualnie kaze ATC samodzielnie sie odezwac. Wywolywane na glownym watku (z flight loop), co ~1 s. Samo wyslanie do LLM idzie do watku roboczego przez _dispatch().""" if not self.config.get("proactive_enabled", True): return if self.streaming: return import time as _time now = _time.time() cooldown = self.config.get("proactive_cooldown", 30) if now - self._proactive_last_ts < cooldown: return reason = self._detect_proactive_reason() if not reason: # Warunek zniknal -> pozwol mu znowu zadzialac, gdy sie pojawi. self._proactive_last_reason = None return # Dedup: ten sam powod nie powtarza sie w petli (np. pas ciagle zajety). # Wysylamy tylko, gdy powod sie zmienil od ostatniego razu. if reason == self._proactive_last_reason: return self._proactive_last_reason = reason # Zaznacz czas, zeby nie spamowac, i wyslij. self._proactive_last_ts = now self._dispatch("", reason) def _detect_proactive_reason(self): """Wykrywa prosty wyzwalacz proaktywny. Zwraca opis powodu lub None. UWAGA: tylko tanie odczyty datarefow (AGL, TCAS). NIE skanujemy bazy navaidow (getFirstNavAid/getNextNavAid), bo to powoduje zacinki co ~10s.""" # 1) Zmiana fazy: ziemia -> powietrze (start) lub powietrze -> ziemia (ladowanie) agl_m = self._get_agl() if agl_m is not None: phase = "ground" if agl_m < 1.0 else "airborne" if self._proactive_last_phase is not None and phase != self._proactive_last_phase: if phase == "airborne": return "aircraft just became airborne (takeoff)" else: return "aircraft just touched down (landing)" self._proactive_last_phase = phase # 2) Bliski ruch (traffic advisory) — tylko w powietrzu. Na ziemi # (parking) inne samoloty stoją obok i nie wolno o nich spamować. if agl_m is not None and agl_m >= 1.0: close = self._close_traffic(5.0) if close: return "nearby traffic within 5 nm (issue traffic advisory)" # 3) Pas zajety — tylko gdy pilot jest BLISKO lotniska (< 15 nm). # Inaczej po odlocie ATC gadalby o pasie oddalonego lotniska w petli. if self.selected_runway and self._runway_icao: runway = self._find_runway(self._runway_icao, self.selected_runway) if runway: plat, plon = self._pilot_latlon() if plat is not None: mid_lat = (runway["lat1"] + runway["lat2"]) / 2.0 mid_lon = (runway["lon1"] + runway["lon2"]) / 2.0 if self._dist_nm(plat, plon, mid_lat, mid_lon) < 15.0: occ = self._runway_occupants(self._runway_icao, self.selected_runway) if occ: desc = ", ".join( f"{o['phase_name']} (key 0x{o['key']:X})" if isinstance(o.get('key'), int) else o['phase_name'] for o in occ ) return f"runway {self.selected_runway} occupied: {desc}" return None def _pilot_latlon(self): """Zwraca (lat, lon) pilota lub (None, None).""" lat = self._get_dataref("sim/flightmodel/position/latitude", is_float=True) lon = self._get_dataref("sim/flightmodel/position/longitude", is_float=True) return lat, lon def _dist_nm(self, lat1, lon1, lat2, lon2): """Odleglosc (nm) miedzy dwoma punktami (haversine).""" import math R = 3440.065 # promien Ziemi w milach morskich p1 = math.radians(lat1) p2 = math.radians(lat2) dp = math.radians(lat2 - lat1) dl = math.radians(lon2 - lon1) a = math.sin(dp / 2) ** 2 + math.cos(p1) * math.cos(p2) * math.sin(dl / 2) ** 2 return 2 * R * math.asin(math.sqrt(a)) def _read_int_array(self, ref, count): """Czyta tablice int z datarefu (indeksowaną slotem).""" if ref is None: return [] try: values = [] xp.getDatavi(ref, values, 0, count) return values except Exception: return [] def _read_lt_float_array(self, ref, count): """Czyta tablice float z datarefu LiveTraffic.""" if ref is None: return [] try: values = [] xp.getDatavf(ref, values, 0, count) return values except Exception: return [] def _lt_read_ac_scalar(self, index): """Ustawia ac/key = index i czyta skalarne phase/on_gnd/lat/lon/alt. ac/key to indeks (0..num-1): po zapisie LiveTraffic wybiera samolot, a skalarne ac/* zwracaja jego dane. Zwraca dict lub None.""" if self._lt_key_ref is None: return None try: xp.setDatai(self._lt_key_ref, int(index)) def gi(ref): return int(xp.getDatai(ref)) if ref is not None else None def gf(ref): return float(xp.getDataf(ref)) if ref is not None else None # key po zapisie to Mode-S hex danego samolotu key = gi(self._lt_key_ref) return { "key": key, "phase": gi(self._lt_phase_ref), "on_gnd": gi(self._lt_on_gnd_ref), "lat": gf(self._lt_lat_ref), "lon": gf(self._lt_lon_ref), "alt": gf(self._lt_alt_ref), "heading": gf(self._lt_heading_ref), "speed": gf(self._lt_speed_ref), "vsi": gf(self._lt_vsi_ref), } except Exception as e: xp.log(f"[XSayATC] Blad czytania ac/key={index}: {e}") return None def _lt_enumerate(self): """Zwraca liste dictow z danymi wszystkich samolotow LiveTraffic. Iteruje po indeksie 0..num-1 (ac/key = indeks, potem skalary). Wynik cache'owany 2 s (enumeracja robi ~9 odczytow datarefow/samolot, nie wolno jej wywolywac co klatke).""" import time as _time now = _time.time() if self._lt_cache is not None and (now - self._lt_cache_ts) < 2.0: return self._lt_cache if not self._lt_available or self._lt_key_ref is None: return [] try: num = int(xp.getDatai(self._lt_num_ref)) except Exception: num = 0 if num <= 0: self._lt_cache = [] self._lt_cache_ts = now return [] out = [] for i in range(min(num, NUM_LT_SLOTS)): d = self._lt_read_ac_scalar(i) if d is not None: out.append(d) self._lt_cache = out self._lt_cache_ts = now return out def _lt_type_str(self, ref): """Zwraca opis typu datarefu (do debugu).""" if ref is None: return "None" try: t = xp.getDataRefTypes(ref) except Exception: return "?" parts = [] if t & XPLM_TYPE_INT: parts.append("int") if t & XPLM_TYPE_FLOAT: parts.append("float") if t & XPLM_TYPE_DOUBLE: parts.append("double") if t & XPLM_TYPE_FLOAT_ARRAY: parts.append("float[]") if t & XPLM_TYPE_INT_ARRAY: parts.append("int[]") if t & XPLM_TYPE_DATA: parts.append("data") return ",".join(parts) if parts else f"({t})" def _collect_livetraffic_debug(self): """Zwraca liste linii z danymi LiveTraffic (enumeracja po indeksie ac/key).""" if not self._lt_available: return ["LiveTraffic: brak datarefow livetraffic/ac/*"] num = 0 try: num = int(xp.getDatai(self._lt_num_ref)) except Exception: num = 0 lines = [f"LiveTraffic: {num} samolotow"] ac = self._lt_enumerate() if not ac: lines.append("(brak danych — sprawdz, czy ac/key daje sie iterowac po 0..num-1)") return lines lines.append(f"Dane {len(ac)} samolotow (ac/key -> phase, on_gnd, lat, lon, alt):") for d in ac[:30]: ph = d.get("phase") ph_s = LT_PHASE_NAMES.get(ph, str(ph)) if ph is not None else "?" key = d.get("key") key_s = f"0x{key:X}" if isinstance(key, int) else str(key) lines.append( f" key={key_s} phase={ph}({ph_s}) on_gnd={d['on_gnd']} " f"lat={d['lat']} lon={d['lon']} alt={d['alt']} " f"hdg={d['heading']} spd={d['speed']} vsi={d['vsi']}" ) return lines def _close_traffic(self, max_nm): """Zwraca liste bliskiego ruchu (dist_nm < max_nm). TYLKO glowny watek.""" bearing = self._read_float_array(self._tcas_bearing_ref, NUM_TCAS_SLOTS) distance = self._read_float_array(self._tcas_distance_ref, NUM_TCAS_SLOTS) if not distance: return [] out = [] for i in range(NUM_TCAS_SLOTS): if i >= len(distance): break dist_m = distance[i] if not dist_m or dist_m <= 0: continue dist_nm = dist_m / 1852.0 if dist_nm < max_nm: brg_rel = (bearing[i] % 360.0) if i < len(bearing) else 0.0 clock = int(round((brg_rel / 30.0) % 12)) or 12 out.append(f"{dist_nm:.1f} nm at {clock}:00") return out # ---------------------------- VR ---------------------------- def _vr_flight_loop(self, lastCall, elapsed, counter, refCon): """Co 1s: VR, monitor proaktywny, oraz podniesienie tekstu z STT (wszystko na glownym watku).""" vr = self._get_vr_enabled() if vr != self._last_vr: self._last_vr = vr self._apply_vr_mode(vr) # Proaktywny ATC (bezpiecznie w try/except, zeby nie wywalic pętli) try: self._proactive_check() except Exception as e: xp.log(f"[XSayATC] Blad monitora proaktywnego: {e}") # Podnies tekst z STT (transkrypcja robi sie w tle, wyslanie tu, na # glownym watku, bo send() czyta datarefy). if self._pending_send is not None: txt = self._pending_send self._pending_send = None self.send(txt) return 1.0 def _get_vr_enabled(self): if self._vr_ref is None: return 0 try: return xp.getDatai(self._vr_ref) except Exception: return 0 def _apply_vr_mode(self, vr): for win in (self._imgui_window, self._config_window): if win is None or win.windowID is None: continue try: if vr: # Okno w przestrzeni VR (3D), widoczne i interaktywne w headsetcie xp.setWindowPositioningMode(win.windowID, xp.WindowVR, -1) xp.setWindowGeometryVR(win.windowID, 800, 900) else: xp.setWindowPositioningMode(win.windowID, xp.WindowPositionFree, -1) except Exception as e: xp.log(f"[XSayATC] Blad ustawiania VR: {e}") # ---------------------------- Okno ImGui ---------------------------- def _draw(self, windowID, refCon): imgui.text("XSayATC - lokalny ATC") imgui.separator() # Obszar czatu (scrollowalny) avail_h = imgui.get_content_region_available()[1] chat_h = max(60.0, avail_h - 130.0) with imgui.begin_child("chat", 0, chat_h, border=True): for m in self.messages: if m["role"] == "user": imgui.text_colored("Ty: " + m["text"], 0.5, 0.8, 1.0, 1.0) elif m["role"] == "assistant": imgui.text_wrapped("ATC: " + m["text"]) if self.streaming: imgui.text_colored("...", 0.9, 0.9, 0.3, 1.0) imgui.set_scroll_here_y(1.0) # Pole tekstowe + przycisk PTT changed, self.pending_text = imgui.input_text( "##msg", self.pending_text, 512, flags=imgui.INPUT_TEXT_ENTER_RETURNS_TRUE ) imgui.same_line() if imgui.button("Wyslij (PTT)") or (changed and self.pending_text.strip()): self.send(self.pending_text) self.pending_text = "" imgui.same_line() if imgui.button("Stop"): self.stop() imgui.text(self.status) imgui.separator() # Wybor kierunku lotu (determinuje handoff ATC) imgui.text("Kierunek lotu:") if imgui.radio_button("Auto", self.phase_mode == "auto"): self.phase_mode = "auto" imgui.same_line() if imgui.radio_button("Odlot", self.phase_mode == "departure"): self.phase_mode = "departure" self.flight_phase = "departure" imgui.same_line() if imgui.radio_button("Przylot", self.phase_mode == "arrival"): self.phase_mode = "arrival" self.flight_phase = "arrival" imgui.separator() # Wybor pasa (opcja A: recznie) imgui.text("Pas (runway):") # UWAGA: nie wolno tu wywolywac _nearest_airport_icao() (pelny skan # navaidow co klatke -> przyciecia). Uzywamy zapamietanego ICAO, # ustawianego przy "Odswiez czestotliwosci". names = self._runway_names(self._runway_icao) if self._runway_icao else [] if names: # combo proste: przyciski na nazwy pasow for n in names: if imgui.radio_button(n, self.selected_runway == n): self.selected_runway = n imgui.same_line() imgui.text("") else: imgui.text_colored("(brak danych o pasach — kliknij Odswiez ponizej)", 0.7, 0.7, 0.7, 1.0) imgui.separator() # Czestotliwosci + pasy najblizszego lotniska (odswiezane recznie przyciskiem) if imgui.button("Odswiez (czestotliwosci + pasy)"): self._refresh_freq_display() icao, freq_lines = self._freq_display_lines() if icao: imgui.text(f"Czestotliwosci - {icao}:") else: imgui.text_colored("Czestotliwosci: (kliknij Odswiez)", 0.7, 0.7, 0.7, 1.0) # Wlasny przewijany obszar, zeby czestotliwosci mialy zawsze suwak with imgui.begin_child("freqs", 0, 120.0, border=True): if freq_lines: for ln in freq_lines: imgui.text(ln) else: imgui.text_colored("(brak danych)", 0.7, 0.7, 0.7, 1.0) def _draw_config(self, windowID, refCon): imgui.text("Konfiguracja XSayATC") imgui.separator() _, self.config["base_url"] = imgui.input_text( "Base URL", self.config["base_url"], 256) _, self.config["model"] = imgui.input_text( "Model (puste=auto)", self.config["model"], 512) _, self.config["temperature"] = imgui.slider_float( "Temperature", self.config["temperature"], 0.0, 2.0, "%.2f") _, self.config["max_tokens"] = imgui.slider_int( "Max tokens", self.config["max_tokens"], 64, 4096) _, self.config["no_think"] = imgui.checkbox( "Tryb /no_think (Qwen3)", self.config["no_think"]) _, self.config["include_flight_context"] = imgui.checkbox( "Dolacz kontekst lotu", self.config["include_flight_context"]) imgui.separator() imgui.text("Glos (whisper / piper):") _, self.config["voice_enabled"] = imgui.checkbox( "Glos wlaczony (STT)", self.config["voice_enabled"]) _, self.config["tts_enabled"] = imgui.checkbox( "Odczytywanie odpowiedzi (TTS)", self.config["tts_enabled"]) _, self.config["whisper_model"] = imgui.input_text( "Model whisper", self.config["whisper_model"], 512) _, self.config["piper_model"] = imgui.input_text( "Model piper", self.config["piper_model"], 512) imgui.separator() imgui.text("Plan lotu (fallback dla samolotow z wlasnym FMC):") _, self.config["flightplan_file"] = imgui.input_text( "Plik planu lotu", self.config["flightplan_file"], 512) imgui.separator() imgui.text("Procedury ATC:") _, self.config["use_procedures"] = imgui.checkbox( "Wlacz procedury", self.config["use_procedures"]) _, self.config["procedures_dir"] = imgui.input_text( "Katalog procedur", self.config["procedures_dir"], 512) imgui.separator() imgui.text("Proaktywny ATC:") _, self.config["proactive_enabled"] = imgui.checkbox( "ATC sam inicjuje kontakt (ruch, faza lotu)", self.config["proactive_enabled"]) _, self.config["proactive_cooldown"] = imgui.slider_int( "Odstep (s)", self.config["proactive_cooldown"], 5, 300) imgui.separator() imgui.text("System prompt (instrukcje ATC):") _, self.config["system_prompt"] = imgui.input_text_multiline( "##sysprompt", self.config["system_prompt"], 4096, width=0, height=120) imgui.separator() if imgui.button("Zapisz"): self._save_config() self._model_cache = None self.status = "Konfiguracja zapisana." # pokaz kontekst lotu na zywo imgui.separator() imgui.text("Kontekst lotu (podglad):") try: _, ctx_text = self._collect_context() imgui.text_wrapped(ctx_text) except Exception as e: imgui.text(f"(blad: {e})") # Podglad danych LiveTraffic (debug) imgui.separator() imgui.text("LiveTraffic (podglad/debug):") lt_lines = self._collect_livetraffic_debug() with imgui.begin_child("ltdebug", 0, 160.0, border=True): for ln in lt_lines: imgui.text_wrapped(ln) # ---------------------------- Cykl zycia pluginu ---------------------------- def XPluginStart(self): self._ensure_datarefs() # Rozpocznij wczytywanie czestotliwosci z apt.dat w tle od razu, # zeby pierwsze klikniecie "Odswiez czestotliwosci" nie musialo czekac. self._ensure_apt_freqs() # Komenda PTT (przypisz klawisz w Settings > Keyboard) self._cmd = xp.createCommand("xsayatc/ptt", "XSayATC push-to-talk") xp.registerCommandHandler(self._cmd, self._ptt_handler, 1, None) # Komenda toggle okna (przypisz klawisz, zeby wlaczac/wylaczac okno) self._cmd_toggle = xp.createCommand("xsayatc/toggle_window", "XSayATC toggle window") xp.registerCommandHandler(self._cmd_toggle, self._toggle_handler, 1, None) # Menu self._menu = xp.createMenu("XSayATC", None, 0, self._menu_handler, None) self._menu_open_idx = xp.appendMenuItemWithCommand( self._menu, "Pokaz/ukryj okno", self._cmd_toggle) self._menu_cfg_idx = xp.appendMenuItem(self._menu, "Konfiguracja", "xsayatc_config") # Okno glowne (ukryte domyslnie — pokaz klawiszem/menu "Pokaz/ukryj okno") self._imgui_window = ImguiWindow( left=100, top=400, right=600, bottom=100, visible=0, draw=self._draw, refCon=None, decoration=1, layer=1) self._imgui_window.setTitle("XSayATC") # Okno konfiguracji (ukryte domyslnie) self._config_window = ImguiWindow( left=150, top=500, right=700, bottom=120, visible=0, draw=self._draw_config, refCon=None, decoration=1, layer=1) self._config_window.setTitle("XSayATC - Konfiguracja") # Ustaw limity zmiany rozmiaru for win in (self._imgui_window, self._config_window): try: xp.setWindowResizingLimits(win.windowID, 200, 100, 2000, 2000) except Exception: pass # Flight loop do detekcji VR xp.registerFlightLoopCallback(self._vr_flight_loop, 1.0, None) self._last_vr = self._get_vr_enabled() self._apply_vr_mode(self._last_vr) return "XSayATC", "pali112.xsayatc", "Lokalny asystent ATC (llama.cpp)" def XPluginStop(self): self.stop() try: xp.unregisterFlightLoopCallback(self._vr_flight_loop, None) except Exception: pass for win in (self._config_window, self._imgui_window): if win is not None: try: win.delete() except Exception: pass self._config_window = None self._imgui_window = None def XPluginEnable(self): return 1 def XPluginDisable(self): pass def XPluginReceiveMessage(self, inFromWho, inMessage, inParam): pass # ---------------------------- Handlery ---------------------------- def _ptt_handler(self, cmdRef, phase, refCon): # Glos: PTT steruje nagrywaniem if self._voice_enabled(): mode = self.config.get("voice_ptt_mode", "hold") if mode == "toggle": if phase == xp.CommandBegin: if self._recording: self._stop_recording_and_send() else: self._start_recording() return 0 else: # "hold" if phase == xp.CommandBegin: self._start_recording() return 0 elif phase == xp.CommandEnd: self._stop_recording_and_send() return 0 return 1 # Tryb tekstowy (bez glosu) if phase == xp.CommandBegin: text = self.pending_text.strip() if text: self.send(text) self.pending_text = "" return 0 return 1 def _toggle_handler(self, cmdRef, phase, refCon): if phase == xp.CommandBegin: self._toggle_main_window() return 0 return 1 def _menu_handler(self, menuRef, itemRef): if itemRef == "xsayatc_config": self._toggle_config_window() def _toggle_main_window(self): if self._imgui_window is not None and self._imgui_window.windowID is not None: cur = xp.getWindowIsVisible(self._imgui_window.windowID) xp.setWindowIsVisible(self._imgui_window.windowID, 0 if cur else 1) def _open_config_window(self): if self._config_window is not None and self._config_window.windowID is not None: xp.setWindowIsVisible(self._config_window.windowID, 1) xp.bringWindowToFront(self._config_window.windowID) def _toggle_config_window(self): if self._config_window is not None and self._config_window.windowID is not None: cur = xp.getWindowIsVisible(self._config_window.windowID) xp.setWindowIsVisible(self._config_window.windowID, 0 if cur else 1) # -------------------------------------------------------------------------- # Punkt wejscia XPPython3 # -------------------------------------------------------------------------- _plugin = XSayATC() class PythonInterface: def XPluginStart(self): return _plugin.XPluginStart() def XPluginStop(self): _plugin.XPluginStop() def XPluginEnable(self): return _plugin.XPluginEnable() def XPluginDisable(self): _plugin.XPluginDisable() def XPluginReceiveMessage(self, inFromWho, inMessage, inParam): _plugin.XPluginReceiveMessage(inFromWho, inMessage, inParam)