GeoFS MCP Server

/** * Simulated GeoFS Controller * * This is a simplified version that simulates a GeoFS flight simulator * without requiring browser automation. It maintains an internal state * that mimics the behavior of an aircraft in GeoFS. */ // Import flight data models import { FlightData, PositionData } from '../models/flight-data'; export class GeoFSController { // Flag to track initialization status private _isInitialized = false; // Aircraft state private aircraft = { // Current position (lat, long, altitude) position: { latitude: 37.6213, // Default to San Francisco airport longitude: -122.3790, altitude: 0 // Ground level }, // Speed data speed: { kias: 0, // Knots Indicated Airspeed groundSpeed: 0, verticalSpeed: 0 }, // Attitude data attitude: { roll: 0, pitch: 0, heading: 0 // North }, // Control surfaces controls: { throttle: 0, elevators: 0, ailerons: 0, rudder: 0, flaps: 0, gear: 1 // Default to gear down }, // Aircraft type (default: Cessna 172) aircraftId: 1, // Engine state engines: [{ throttle: 0, running: false }] }; // Physics update interval private updateInterval: NodeJS.Timeout | null = null; /** * Initialize the GeoFS controller */ async initialize(): Promise<void> { try { console.log('Initializing simulated GeoFS controller'); // Start the physics simulation this.startPhysicsSimulation(); this._isInitialized = true; console.log('GeoFS simulation started successfully'); } catch (error) { console.error('Failed to initialize GeoFS controller:', error); throw error; } } /** * Start the physics simulation that updates aircraft state */ private startPhysicsSimulation(): void { // Update physics at 10Hz this.updateInterval = setInterval(() => { this.updateAircraftPhysics(); }, 100); } /** * Update aircraft physics based on current state */ private updateAircraftPhysics(): void { // Simple physics model const dt = 0.1; // 100ms in seconds // Update speed based on throttle const maxSpeed = 150; // knots const targetSpeed = this.aircraft.engines[0].throttle * maxSpeed; // Gradually approach target speed this.aircraft.speed.kias += (targetSpeed - this.aircraft.speed.kias) * 0.1; this.aircraft.speed.groundSpeed = this.aircraft.speed.kias; // Convert knots to meters per second for position calculations const speedMps = this.aircraft.speed.groundSpeed * 0.51444; // Update position based on heading and speed const headingRad = this.aircraft.attitude.heading * (Math.PI / 180); const distanceM = speedMps * dt; // Calculate new position (simplified, not accounting for Earth's curvature for small distances) const earthRadius = 6371000; // meters const latChange = (distanceM * Math.cos(headingRad)) / earthRadius * (180 / Math.PI); const lonChange = (distanceM * Math.sin(headingRad)) / (earthRadius * Math.cos(this.aircraft.position.latitude * (Math.PI / 180))) * (180 / Math.PI); this.aircraft.position.latitude += latChange; this.aircraft.position.longitude += lonChange; // Update altitude based on vertical speed this.aircraft.position.altitude += this.aircraft.speed.verticalSpeed * dt / 60; // fpm to m/s conversion // Ensure altitude doesn't go below ground if (this.aircraft.position.altitude < 0) { this.aircraft.position.altitude = 0; this.aircraft.speed.verticalSpeed = 0; } } /** * Check if the controller is initialized */ public isInitialized(): boolean { return this._isInitialized; } /** * Get current flight data */ public getFlightData(): FlightData { return { position: { ...this.aircraft.position }, attitude: { ...this.aircraft.attitude }, speed: { ...this.aircraft.speed }, controls: { ...this.aircraft.controls }, aircraft: { id: this.aircraft.aircraftId, name: this.getAircraftName(this.aircraft.aircraftId), type: this.getAircraftType(this.aircraft.aircraftId) } }; } /** * Set throttle value */ public setThrottle(value: number): void { // Ensure value is between 0 and 1 const throttle = Math.max(0, Math.min(1, value)); // Update all engines this.aircraft.engines.forEach(engine => { engine.throttle = throttle; engine.running = throttle > 0; }); this.aircraft.controls.throttle = throttle; console.log(`Throttle set to ${throttle}`); } /** * Set target heading */ public setHeading(degrees: number): void { // Normalize heading to 0-360 range let heading = degrees % 360; if (heading < 0) heading += 360; // Set target heading const targetHeading = heading; // Simulate turning to the target heading this.turnToHeading(targetHeading); console.log(`Heading set to ${targetHeading} degrees`); } /** * Start a predefined flight pattern */ public startPattern(pattern: string): void { console.log(`Starting pattern: ${pattern}`); switch (pattern.toLowerCase()) { case 'takeoff': this.executeTakeoffPattern(); break; case 'landing': this.executeLandingPattern(); break; case 'approach': this.executeApproachPattern(); break; case 'holdingpattern': this.executeHoldingPattern(); break; default: console.error(`Unknown pattern: ${pattern}`); } } /** * Execute takeoff pattern */ private executeTakeoffPattern(): void { // Set flaps for takeoff this.aircraft.controls.flaps = 0.3; // Ensure gear is down this.aircraft.controls.gear = 1; // Apply full throttle this.setThrottle(1.0); // Simulate rotation at appropriate speed setTimeout(() => { // Pitch up for takeoff this.aircraft.attitude.pitch = 10; // Simulate positive climb setTimeout(() => { // Retract gear this.aircraft.controls.gear = 0; // Climb to 1000 feet this.aircraft.position.altitude += 300; // Reduce flaps setTimeout(() => { this.aircraft.controls.flaps = 0; }, 5000); }, 3000); }, 5000); } /** * Execute landing pattern */ private executeLandingPattern(): void { // Reduce speed this.setThrottle(0.3); // Set flaps for approach this.aircraft.controls.flaps = 0.5; // Lower landing gear this.aircraft.controls.gear = 1; // Set approach pitch (3-degree glideslope) this.aircraft.attitude.pitch = -3; // Simulate touchdown setTimeout(() => { // Flare before touchdown this.aircraft.attitude.pitch = 0; // Touch down setTimeout(() => { // Reduce throttle to idle this.setThrottle(0); }, 3000); }, 10000); } /** * Execute approach pattern */ private executeApproachPattern(): void { // Configure for approach this.setThrottle(0.4); this.aircraft.controls.flaps = 0.3; // Align with runway // (This would use the current airport data in a real implementation) // Descend to pattern altitude this.aircraft.position.altitude = 1000; } /** * Execute holding pattern */ private executeHoldingPattern(): void { // Set up for holding pattern this.setThrottle(0.5); this.aircraft.controls.flaps = 0; // Execute a series of turns to create a racetrack pattern this.turnToHeading(this.aircraft.attitude.heading); // After 2 minutes, turn 90 degrees right setTimeout(() => { this.turnToHeading((this.aircraft.attitude.heading + 90) % 360); // After 1 minute, turn 90 degrees right again setTimeout(() => { this.turnToHeading((this.aircraft.attitude.heading + 90) % 360); // After 2 minutes, turn 90 degrees right again setTimeout(() => { this.turnToHeading((this.aircraft.attitude.heading + 90) % 360); }, 120000); }, 60000); }, 120000); } /** * Turn to a specific heading */ private turnToHeading(targetHeading: number): void { // Calculate turn direction (shortest path) const currentHeading = this.aircraft.attitude.heading; let headingDiff = targetHeading - currentHeading; // Normalize to -180 to 180 range if (headingDiff > 180) headingDiff -= 360; if (headingDiff < -180) headingDiff += 360; // Determine bank direction const bankDirection = headingDiff > 0 ? 1 : -1; // Apply bank this.aircraft.attitude.roll = bankDirection * 20; // Simulate turn const turnRate = 3; // degrees per second const turnTime = Math.abs(headingDiff) / turnRate; // Gradually update heading const startTime = Date.now(); const startHeading = currentHeading; const updateHeading = () => { const elapsed = (Date.now() - startTime) / 1000; const progress = Math.min(1, elapsed / turnTime); this.aircraft.attitude.heading = startHeading + headingDiff * progress; // Normalize heading this.aircraft.attitude.heading = (this.aircraft.attitude.heading + 360) % 360; if (progress < 1) { setTimeout(updateHeading, 100); } else { // Level off this.aircraft.attitude.roll = 0; } }; updateHeading(); } /** * Get aircraft name based on ID */ private getAircraftName(id: number): string { const aircraftNames: { [key: number]: string } = { 1: 'Cessna 172', 18: 'Boeing 737-800', 24: 'Boeing 787-9', 25: 'Boeing 787-10' }; return aircraftNames[id] || 'Unknown Aircraft'; } /** * Get aircraft type based on ID */ private getAircraftType(id: number): string { if (id >= 18 && id <= 25) { return 'airliner'; } else if (id >= 1 && id <= 10) { return 'general'; } else { return 'unknown'; } } /** * Execute a command in the simulated GeoFS */ public async executeCommand(command: string, params: any): Promise<any> { if (!this._isInitialized) { throw new Error('GeoFS controller not initialized'); } try { switch (command) { case 'setThrottle': return this.setThrottle(params.value); case 'setHeading': return this.setHeading(params.degrees); case 'getPosition': return this.getPosition(); case 'selectAircraft': return this.selectAircraft(params.aircraftId); case 'takeOff': return this.takeOff(); case 'land': return this.land(); case 'getFlightData': return this.getFlightData(); case 'updateAircraftState': return this.updateAircraftState(params); case 'startPattern': return this.startPattern(params.pattern); default: throw new Error(`Unknown command: ${command}`); } } catch (error) { console.error(`Error executing command ${command}:`, error); throw error; } } /** * Update aircraft state directly from external data * Used for replaying flight data */ private updateAircraftState(params: any): boolean { try { // Update position if provided if (params.position) { this.aircraft.position = { ...this.aircraft.position, ...params.position }; } // Update attitude if provided if (params.attitude) { this.aircraft.attitude = { ...this.aircraft.attitude, ...params.attitude }; } // Update speed if provided if (params.speed) { this.aircraft.speed = { ...this.aircraft.speed, ...params.speed }; } // Update controls if provided if (params.controls) { this.aircraft.controls = { ...this.aircraft.controls, ...params.controls }; } console.log('Aircraft state updated from external data'); return true; } catch (error) { console.error('Error updating aircraft state:', error); return false; } } /** * Get the current aircraft position */ private getPosition(): PositionData { return { ...this.aircraft.position }; } /** * Select an aircraft by ID */ private selectAircraft(aircraftId: number): boolean { // Store previous aircraft ID const previousAircraftId = this.aircraft.aircraftId; // Set new aircraft ID this.aircraft.aircraftId = aircraftId; console.log(`Aircraft changed from ID ${previousAircraftId} to ID ${aircraftId}`); return true; } /** * Simulate takeoff procedure */ private takeOff(): boolean { // Set throttle to max this.setThrottle(1.0); // Set initial climb this.aircraft.speed.verticalSpeed = 500; // 500 feet per minute this.aircraft.attitude.pitch = 10; // 10 degrees nose up console.log('Takeoff procedure initiated'); return true; } /** * Simulate landing procedure */ private land(): boolean { // Reduce throttle this.setThrottle(0.3); // Set descent rate this.aircraft.speed.verticalSpeed = -300; // -300 feet per minute this.aircraft.attitude.pitch = -3; // 3 degrees nose down console.log('Landing procedure initiated'); return true; } /** * Clean up resources */ async close(): Promise<void> { if (this.updateInterval) { clearInterval(this.updateInterval); this.updateInterval = null; } this._isInitialized = false; console.log('GeoFS simulation stopped'); } }