Merge pull request #1419 from solaris-games/dev

Update 251.3

Author: SpacialCircumstances

client/src/eventBusEventNames/map.ts

@@ -0,0 +1,41 @@
+import { makeCastFunc } from "@solaris-common";
+import type { EventBusEventName } from "./eventBusEventName";
+import type { Star, Carrier } from "../types/game";
+import type { TempWaypoint } from "../types/waypoint";
+import type {RulerPoint} from "@/types/ruler";
+
+export type MapEventBusEventType = { mapEventBusEventType: 'mapEventBusEventType' };
+export type MapEventBusEventName<TData> = EventBusEventName<MapEventBusEventType, TData> & { mapEventBusEventType: 'mapEventBusEventType' };
+
+const toEventName: <TData>(value: string) => MapEventBusEventName<TData> = makeCastFunc();
+
+type StarClicked = {
+  type: 'star',
+  data: Star,
+}
+
+type CarrierClicked = {
+  type: 'carrier',
+  data: Carrier,
+}
+
+type ObjectClickedData = StarClicked | CarrierClicked;
+
+export type ObjectClicked = {
+  distance: number,
+} & ObjectClickedData;
+
+export default class MapEventBusEventNames {
+  private constructor() {};
+
+  public static readonly MapOnStarClicked: MapEventBusEventName<{ star: Star }> = toEventName('onStarClicked');
+  public static readonly MapOnStarRightClicked: MapEventBusEventName<{ star: Star }> = toEventName("onStarRightClicked");
+  public static readonly MapOnCarrierClicked: MapEventBusEventName<{ carrier: Carrier }> = toEventName('onCarrierClicked');
+  public static readonly MapOnCarrierRightClicked: MapEventBusEventName<{ carrier: Carrier }> = toEventName("onCarrierRightClicked");
+  public static readonly MapOnWaypointCreated: MapEventBusEventName<{ waypoint: TempWaypoint }> = toEventName("onWaypointCreated");
+  public static readonly MapOnObjectsClicked: MapEventBusEventName<{ objects: ObjectClicked[]  }> = toEventName("onObjectsClicked");
+  public static readonly MapOnWaypointOutOfRange: MapEventBusEventName<{}> = toEventName("onWaypointOutOfRange");
+  public static readonly MapOnRulerPointCreated: MapEventBusEventName<{ rulerPoint: RulerPoint }> = toEventName("onRulerPointCreated");
+  public static readonly MapOnRulerPointRemoved: MapEventBusEventName<{ rulerPoint: RulerPoint }> = toEventName("onRulerPointRemoved");
+  public static readonly MapOnRulerPointsCleared: MapEventBusEventName<{}> = toEventName("onRulerPointsCleared");
+}

client/src/eventBusEventNames/mapCommand.ts

@@ -0,0 +1,24 @@
+import type {EventBusEventName} from "./eventBusEventName";
+import {type MapObject, makeCastFunc, type Location} from "@solaris-common";
+import type {Player} from "../types/game";
+
+export type MapCommandEventBusEventType = { mapCommandEventBusEventType: 'mapCommandEventBusEventType' };
+export type MapCommandEventBusEventName<TData> = EventBusEventName<MapCommandEventBusEventType, TData> & { mapEventBusEventType: 'mapEventBusEventType' };
+
+const toEventName: <TData>(value: string) => MapCommandEventBusEventName<TData> = makeCastFunc();
+
+export default class MapCommandEventBusEventNames {
+  private constructor() {};
+
+  public static readonly MapCommandPanToUser: MapCommandEventBusEventName<{}> = toEventName('panToUser');
+  public static readonly MapCommandPanToObject: MapCommandEventBusEventName<{ object: MapObject<string> }> = toEventName('panToObject');
+  public static readonly MapCommandPanToLocation: MapCommandEventBusEventName<{ location: Location }> = toEventName('panToLocation');
+  public static readonly MapCommandPanToPlayer: MapCommandEventBusEventName<{ player: Player }> = toEventName('panToPlayer');
+  public static readonly MapCommandClearHighlightedLocations: MapCommandEventBusEventName<{}> = toEventName('clearHighlightedLocations');
+  public static readonly MapCommandHighlightLocation: MapCommandEventBusEventName<{ object: MapObject<string>, opacity: number }> = toEventName('highlightLocation');
+  public static readonly MapCommandClickStar: MapCommandEventBusEventName<{ starId: string }> = toEventName('clickStar');
+  public static readonly MapCommandClickCarrier: MapCommandEventBusEventName<{ carrierId: string }> = toEventName('clickCarrier');
+  public static readonly MapCommandRemoveLastRulerPoint: MapCommandEventBusEventName<{}> = toEventName('removeLastRulerPoint');
+  public static readonly MapCommandShowIgnoreBulkUpgrade: MapCommandEventBusEventName<{}> = toEventName('showIgnoreBulkUpgrade');
+  public static readonly MapCommandHideIgnoreBulkUpgrade: MapCommandEventBusEventName<{}> = toEventName('hideIgnoreBulkUpgrade');
+}

client/src/eventBusEventNames/menu.ts

@@ -1,5 +1,5 @@
 import { makeCastFunc } from "@solaris-common";
-import MENU_STATES from '../services/data/menuStates';
+import MENU_STATES from '../services/data/menuStates.js';
 import type { EventBusEventName } from "./eventBusEventName";
 
 export type MenuEventBusEventType = { menuEventBusEventType: 'menuEventBusEventType' };

client/src/eventBusEventNames/player.ts

@@ -12,7 +12,6 @@ const toEventName: <TData>(value: string) => PlayerEventBusEventName<TData> = ma
 export default class PlayerEventBusEventNames {
   private constructor() { };
 
-  public static readonly GameMessageSent: PlayerEventBusEventName<ConversationMessageSentResult<string>> = toEventName('gameMessageSent');
   public static readonly GameConversationRead: PlayerEventBusEventName<{ conversationId: string, readByPlayerId: string }> = toEventName('gameConversationRead');
 
   public static readonly GameConversationLeft: PlayerEventBusEventName<{ conversationId: string, playerId: string }> = toEventName('gameConversationLeft');

client/src/eventBusEventNames/user.ts

@@ -0,0 +1,11 @@
+import type {EventBusEventName} from "./eventBusEventName";
+import {type ConversationMessageSentResult, makeCastFunc} from "@solaris-common";
+
+export type UserEventBusEventType = { playerEventBusEventType: 'playerEventBusEventType' };
+export type UserEventBusEventName<TData> = EventBusEventName<UserEventBusEventType, TData> & { playerEventBusEventName: 'playerEventBusEventName' }
+
+const toEventName: <TData>(value: string) => UserEventBusEventName<TData> = makeCastFunc();
+
+export default class UserEventBusEventNames {
+  public static readonly GameMessageSent: UserEventBusEventName<ConversationMessageSentResult<string>> = toEventName('gameMessageSent');
+}

client/src/game/container.ts

@@ -9,6 +9,7 @@ import type {UserGameSettings} from "@solaris-common";
 import type {Game, Player, Star, Carrier} from "../types/game";
 import { screenshot } from './screenshot';
 import { DebugTools } from './debugTools';
+import type { EventBus } from '../eventBus';
 
 export class DrawingContext {
   store: Store<State>;
@@ -35,11 +36,11 @@ export class GameContainer {
   userSettings: UserGameSettings | undefined;
   game: Game | undefined;
   debugTools: DebugTools | undefined;
+  eventBus: EventBus | undefined;
 
   reportGameError: ((err: string) => void) | undefined;
 
   constructor () {
-
   }
 
   checkPerformance(): { webgl: boolean, performance: boolean } {
@@ -59,8 +60,9 @@ export class GameContainer {
     }
   }
 
-  async setupApp (store, userSettings, reportGameError) {
+  async setupApp (store, userSettings, reportGameError, eventBus: EventBus) {
     this.store = store
+    this.eventBus = eventBus;
     this.reportGameError = reportGameError;
 
     this.context = new DrawingContext(store)
@@ -108,11 +110,13 @@ export class GameContainer {
     this.app!.stage.addChild(this.viewport)
 
     // Add a new map to the viewport
-    this.map = new Map(this.app, this.store, this, this.context!)
+    this.map = new Map(this.app, this.store, this, this.context!, eventBus);
     this.viewport.addChild(this.map.container)
   }
 
   destroy () {
+    console.warn('Destroying game container')
+
     if (this.viewport) {
       this.viewport.destroy()
       this.viewport = undefined
@@ -186,7 +190,7 @@ export class GameContainer {
     this.viewport!.on('pointerdown', this.map!.onViewportPointerDown.bind(this.map))
   }
 
-  setup (game: Game, userSettings: UserGameSettings, context: DrawingContext) {
+  setup (game: Game, userSettings: UserGameSettings) {
     this.game = game;
     this.userSettings = userSettings
 
@@ -234,12 +238,12 @@ export class GameContainer {
   }
 
   reloadStar (star) {
-    let starObject = this.map!.setupStar(this.game, this.userSettings, star)
+    const starObject = this.map!.setupStar(this.game!, this.userSettings!, star)
     this.map!.drawStar(starObject)
   }
 
   reloadCarrier (carrier) {
-    let carrierObject = this.map!.setupCarrier(this.game, this.userSettings, carrier)
+    const carrierObject = this.map!.setupCarrier(this.game, this.userSettings, carrier)
     this.map!.drawCarrier(carrierObject)
   }
 
@@ -248,7 +252,7 @@ export class GameContainer {
   }
 
   getViewportZoomPercentage () {
-    let viewportWidth = this.viewport!.right - this.viewport!.left
+    const viewportWidth = this.viewport!.right - this.viewport!.left
     return (this.viewport!.screenWidth / viewportWidth) * 100
   }
 
@@ -301,6 +305,14 @@ export class GameContainer {
   panToCarrier(carrier: Carrier) {
     this.map!.panToCarrier(carrier);
   }
+
+  fitGalaxy(x, y) {
+    console.log(this)
+
+    this.viewport!.moveCenter(x, y)
+    this.viewport!.fitWorld()
+    this.viewport!.zoom(this.starFieldRight, true)
+  }
 }
 
 export default new GameContainer()

client/src/game/map.ts

@@ -11,28 +11,29 @@ import PathManager from './PathManager'
 import OrbitalLocationLayer from './orbital'
 import WormHoleLayer from './wormHole'
 import TooltipLayer from './tooltip'
-import {EventEmitter} from "./eventEmitter.js";
 import type {Store} from "vuex";
 import type {State} from "../store";
 import type {DrawingContext, GameContainer} from "./container";
 import type {Game, Player, Star as StarData, Carrier as CarrierData} from "../types/game";
-import type {Location, UserGameSettings} from "@solaris-common";
+import type {Location, MapObject, UserGameSettings} from "@solaris-common";
 import { Chunks } from './chunks'
 import Carrier from "./carrier";
+import type { EventBus } from '../eventBus'
+import MapEventBusEventNames from '../eventBusEventNames/map'
+import MapCommandEventBusEventNames from "../eventBusEventNames/mapCommand";
 
 enum Mode {
   Galaxy = 'galaxy',
   Waypoints = 'waypoints',
   Ruler = 'ruler',
 }
 
-
-
-export class Map extends EventEmitter {
+export class Map {
   // Represents the current game mode, these are as follows:
   // galaxy - Normal galaxy view
   // waypoints - Displays waypoints overlay for a given carrier
   mode = Mode.Galaxy;
+  eventBus: EventBus;
   app: PIXI.Application;
   store: Store<State>;
   context: DrawingContext;
@@ -68,16 +69,16 @@ export class Map extends EventEmitter {
   currentViewportCenter: PIXI.Point | undefined;
   lastPointerDownPosition: PIXI.Point | undefined;
   chunks: Chunks | undefined;
+  unsubscribe: (() => void) | undefined;
 
-  constructor (app, store: Store<State>, gameContainer, context: DrawingContext) {
-    super()
-
+  constructor (app: PIXI.Application, store: Store<State>, gameContainer, context: DrawingContext, eventBus: EventBus) {
     this.app = app
     this.store = store
     this.context = context
     this.gameContainer = gameContainer;
     this.container = new PIXI.Container()
     this.container.sortableChildren = true
+    this.eventBus = eventBus;
 
     this.stars = []
 
@@ -132,6 +133,11 @@ export class Map extends EventEmitter {
     this.userSettings = userSettings
     this.game = game
 
+    if (this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = undefined;
+    }
+
     this.app.ticker.maxFPS = userSettings.technical.fpsLimit || 60;
 
     this.pathManager = new PathManager( game, userSettings, this )
@@ -236,9 +242,51 @@ export class Map extends EventEmitter {
     this.tooltipLayer = new TooltipLayer()
     this.tooltipLayer.setup(this.game, this.context)
     this.tooltipContainer!.addChild(this.tooltipLayer.container)
+
+    this.unsubscribe = this.subscribe();
+  }
+
+  subscribe() {
+    const panToLocation = ({ location }: { location: Location }) => this.panToLocation(location);
+    const panToObject = ({ object }: { object: MapObject<string> }) => this.panToObject(object);
+    const panToUser = () => this.panToUser(this.game!);
+    const panToPlayer = ({ player }: { player: Player }) => this.panToPlayer(this.game!, player);
+    const clearHighlightedLocations = () => this.clearCarrierHighlights();
+    const highlightLocation = ({ object, opacity }: { object: MapObject<string>, opacity: number }) => this.highlightLocation(object, opacity);
+    const clickStar = ({ starId }: { starId: string }) => this.clickStar(starId);
+    const clickCarrier = ({ carrierId }: { carrierId: string }) => this.clickCarrier(carrierId);
+    const removeLastRulerWaypoint = () => this.removeLastRulerPoint();
+    const showIgnoreBulkUpgrade = () => this.showIgnoreBulkUpgrade();
+    const hideIgnoreBulkUpgrade = () => this.hideIgnoreBulkUpgrade();
+
+    this.eventBus.on(MapCommandEventBusEventNames.MapCommandPanToLocation, panToLocation);
+    this.eventBus.on(MapCommandEventBusEventNames.MapCommandPanToObject, panToObject);
+    this.eventBus.on(MapCommandEventBusEventNames.MapCommandPanToUser, panToUser);
+    this.eventBus.on(MapCommandEventBusEventNames.MapCommandPanToPlayer, panToPlayer);
+    this.eventBus.on(MapCommandEventBusEventNames.MapCommandClearHighlightedLocations, clearHighlightedLocations);
+    this.eventBus.on(MapCommandEventBusEventNames.MapCommandHighlightLocation, highlightLocation);
+    this.eventBus.on(MapCommandEventBusEventNames.MapCommandClickStar, clickStar);
+    this.eventBus.on(MapCommandEventBusEventNames.MapCommandClickCarrier, clickCarrier);
+    this.eventBus.on(MapCommandEventBusEventNames.MapCommandRemoveLastRulerPoint, removeLastRulerWaypoint);
+    this.eventBus.on(MapCommandEventBusEventNames.MapCommandShowIgnoreBulkUpgrade, showIgnoreBulkUpgrade);
+    this.eventBus.on(MapCommandEventBusEventNames.MapCommandHideIgnoreBulkUpgrade, hideIgnoreBulkUpgrade);
+
+    return () => {
+      this.eventBus.off(MapCommandEventBusEventNames.MapCommandPanToLocation, panToLocation);
+      this.eventBus.off(MapCommandEventBusEventNames.MapCommandPanToObject, panToObject);
+      this.eventBus.off(MapCommandEventBusEventNames.MapCommandPanToUser, panToUser);
+      this.eventBus.off(MapCommandEventBusEventNames.MapCommandPanToPlayer, panToPlayer);
+      this.eventBus.off(MapCommandEventBusEventNames.MapCommandClearHighlightedLocations, clearHighlightedLocations);
+      this.eventBus.off(MapCommandEventBusEventNames.MapCommandHighlightLocation, highlightLocation);
+      this.eventBus.off(MapCommandEventBusEventNames.MapCommandClickStar, clickStar);
+      this.eventBus.off(MapCommandEventBusEventNames.MapCommandClickCarrier, clickCarrier);
+      this.eventBus.off(MapCommandEventBusEventNames.MapCommandRemoveLastRulerPoint, removeLastRulerWaypoint);
+      this.eventBus.off(MapCommandEventBusEventNames.MapCommandShowIgnoreBulkUpgrade, showIgnoreBulkUpgrade);
+      this.eventBus.off(MapCommandEventBusEventNames.MapCommandHideIgnoreBulkUpgrade, hideIgnoreBulkUpgrade);
+    }
   }
 
-  setupStar (game, userSettings, starData) {
+  setupStar (game: Game, userSettings: UserGameSettings, starData: StarData) {
     let star = this.stars.find(x => x.data._id === starData._id)
 
     if (!star) {
@@ -581,6 +629,10 @@ export class Map extends EventEmitter {
     this.panToPlayer(game, player)
   }
 
+  panToObject(object: { location: Location }) {
+    this.panToLocation(object.location)
+  }
+
   panToStar (star: StarData) {
     this.panToLocation(star.location)
   }
@@ -732,7 +784,7 @@ export class Map extends EventEmitter {
 
       if (!dic.tryMultiSelect || !this.tryMultiSelect(e.location)) {
         selectedStar!.toggleSelected()
-        this.emit('onStarClicked', e)
+        this.eventBus.emit(MapEventBusEventNames.MapOnStarClicked, { star: e })
       }
     } else if (this.mode === 'waypoints') {
       this.waypoints!.onStarClicked(e)
@@ -766,7 +818,7 @@ export class Map extends EventEmitter {
         dic.permitCallback && dic.permitCallback()
 
         if (this.mode === 'galaxy') {
-          this.emit('onStarRightClicked', e)
+          this.eventBus.emit(MapEventBusEventNames.MapOnStarRightClicked, { star: e })
         }
       }
     })
@@ -796,7 +848,7 @@ export class Map extends EventEmitter {
       }
 
       if (!dic.tryMultiSelect || !this.tryMultiSelect(e.location)) {
-        this.emit('onCarrierClicked', e)
+        this.eventBus.emit(MapEventBusEventNames.MapOnCarrierClicked, { carrier: e })
       } else {
         selectedCarrier!.unselect()
       }
@@ -809,7 +861,7 @@ export class Map extends EventEmitter {
 
   onCarrierRightClicked (e) {
     if (this.mode === 'galaxy') {
-      this.emit('onCarrierRightClicked', e)
+      this.eventBus.emit(MapEventBusEventNames.MapOnCarrierRightClicked, { carrier: e });
     }
   }
 
@@ -844,23 +896,25 @@ export class Map extends EventEmitter {
   }
 
   onWaypointCreated (e) {
-    this.emit('onWaypointCreated', e)
+    this.eventBus.emit(MapEventBusEventNames.MapOnWaypointCreated, { waypoint: e })
   }
 
   onWaypointOutOfRange (e) {
-    this.emit('onWaypointOutOfRange', e)
+    this.eventBus.emit(MapEventBusEventNames.MapOnWaypointOutOfRange)
   }
 
   onRulerPointCreated (e) {
-    this.emit('onRulerPointCreated', e)
+    console.log(e);
+
+    this.eventBus.emit(MapEventBusEventNames.MapOnRulerPointCreated, { rulerPoint: e });
   }
 
   onRulerPointRemoved (e) {
-    this.emit('onRulerPointRemoved', e)
+    this.eventBus.emit(MapEventBusEventNames.MapOnRulerPointRemoved, { rulerPoint: e });
   }
 
   onRulerPointsCleared (e) {
-    this.emit('onRulerPointsCleared', e)
+    this.eventBus.emit(MapEventBusEventNames.MapOnRulerPointsCleared);
   }
 
   tryMultiSelect (location) {
@@ -925,7 +979,9 @@ export class Map extends EventEmitter {
         }
       })
 
-      this.emit('onObjectsClicked', eventObj)
+      this.eventBus.emit(MapEventBusEventNames.MapOnObjectsClicked, {
+        objects: eventObj
+      })
 
       return true
     }