Update 251

client/src/game/map.ts

@@ -157,6 +157,8 @@ export class Map extends EventEmitter {
     this.userSettings = userSettings
     this.game = game
 
+    this.app.ticker.maxFPS = userSettings.technical.fpsLimit || 60;
+
     this.pathManager = new PathManager( game, userSettings, this )
 
 
@@ -432,7 +434,9 @@ export class Map extends EventEmitter {
     }
   }
 
-  reloadGame (game, userSettings) {
+  reloadGame (game: Game, userSettings: UserGameSettings) {
+    this.app.ticker.maxFPS = userSettings.technical.fpsLimit;
+
     this.game = game
 
     this.pathManager!.setup(game, userSettings)
@@ -480,7 +484,7 @@ export class Map extends EventEmitter {
       let existing = this.carriers.find(x => x.data!._id === carrierData._id)
 
       if (existing) {
-        let player = gameHelper.getPlayerById(game, carrierData.ownedByPlayerId)
+        let player = gameHelper.getPlayerById(game, carrierData.ownedByPlayerId!)
 
         existing.setup(carrierData, userSettings, this.context, this.stars, player, game.constants.distances.lightYear)
       } else {
@@ -721,6 +725,7 @@ export class Map extends EventEmitter {
 
       c.unselect()
     }
+    this.clearCarrierHighlights();
   }
 
   unselectAllStarsExcept (star) {
@@ -743,6 +748,11 @@ export class Map extends EventEmitter {
           c.unselect()
         }
       })
+      this.clearCarrierHighlights();
+  }
+
+  clearCarrierHighlights() {
+    this.waypoints!.clear();
   }
 
   onTick(deltaTime) {
@@ -915,6 +925,14 @@ export class Map extends EventEmitter {
 
       selectedCarrier!.toggleSelected()
 
+      //highlight carrier path if selected
+      if (selectedCarrier?.isSelected) {
+        this.waypoints!.draw(selectedCarrier!.data, false);
+      }
+      else {
+        this.waypoints!.clear();
+      }
+
       if (!dic.tryMultiSelect || !this.tryMultiSelect(e.location)) {
         this.emit('onCarrierClicked', e)
       } else {

client/src/game/waypoints.ts

@@ -36,14 +36,15 @@ class Waypoints extends EventEmitter {
     this.container.removeChildren()
   }
 
-  draw (carrier) {
+  draw (carrier, plotting=true) {
     this.clear()
 
     this.carrier = carrier
-
-    this.drawHyperspaceRange()
-    this.drawLastWaypoint()
-    this.drawNextWaypoints()
+    if (plotting) {
+      this.drawHyperspaceRange()
+      this.drawLastWaypoint()
+      this.drawNextWaypoints()
+    }
     this.drawPaths()
   }
 

client/src/main.ts

@@ -17,6 +17,8 @@ import { DiplomacyClientSocketHandler } from './sockets/socketHandlers/diplomacy
 import { GameClientSocketHandler } from './sockets/socketHandlers/game'
 import { PlayerClientSocketHandler } from "./sockets/socketHandlers/player"
 import { createSolarisStore, type State } from './store'
+import { httpInjectionKey } from "./services/typedapi"
+import {createHttpClient} from "./util/http";
 
 // Note: This was done to get around an issue where the Steam client
 // had bootstrap as undefined. This also affects the UI template we're using,
@@ -75,6 +77,10 @@ const playerClientSocketEmitter: PlayerClientSocketEmitter = new PlayerClientSoc
 app.provide(playerClientSocketEmitterInjectionKey, playerClientSocketEmitter);
 app.provide(eventBusInjectionKey, eventBus);
 
+const httpClient = createHttpClient();
+
+app.provide(httpInjectionKey, httpClient);
+
 const clientHandler: ClientHandler = new ClientHandler(socket, store, playerClientSocketEmitter);
 
 app.config.globalProperties.$confirm = async function(title, text, confirmText = 'Yes', cancelText = 'No', hideCancelButton = false, cover = false) {

client/src/services/typedapi/admin.ts

@@ -0,0 +1,17 @@
+import {type Announcement, createAdminRoutes, type ListPasswordReset, type ListUser} from "@solaris-common";
+import type { Axios } from "axios";
+import {doGet, type ResponseResult} from ".";
+
+const routes = createAdminRoutes<string>();
+
+export const getUsers = (axios: Axios) => async (): Promise<ResponseResult<ListUser<string>[]>> => {
+  return doGet(axios)(routes.listUsers, {});
+}
+
+export const getPasswordResets = (axios: Axios) => async (): Promise<ResponseResult<ListPasswordReset<string>[]>> => {
+  return doGet(axios)(routes.listPasswordResets, {});
+}
+
+export const getAllAnnouncements = (axios: Axios) => async (): Promise<ResponseResult<Announcement<string>[]>> => {
+  return doGet(axios)(routes.getAllAnnouncements, {});
+}

client/src/services/typedapi/index.ts

@@ -0,0 +1,144 @@
+import { type Route, type GetRoute, type PostRoute, type PatchRoute, type DeleteRoute, type PutRoute } from "@solaris-common";
+import { type Axios, type AxiosRequestConfig, isAxiosError } from "axios";
+import type { InjectionKey } from "vue";
+
+export type ReqOptions = AxiosRequestConfig;
+
+export enum ResponseResultKind {
+  Ok = 'ok',
+  RequestError = 'requestError',
+  ResponseError = 'responseError',
+};
+
+export type ResponseResultOk<T> = {
+  kind: ResponseResultKind.Ok,
+  data: T,
+};
+
+export type ResponseResultRequestError = {
+  kind: ResponseResultKind.RequestError,
+  cause: Error,
+}
+
+export type ResponseResultResponseError = {
+  kind: ResponseResultKind.ResponseError,
+  status: number,
+  data: string,
+  cause: Error,
+};
+
+export type ResponseResult<T> = ResponseResultOk<T> | ResponseResultRequestError | ResponseResultResponseError;
+
+export const isError = <T>(result: ResponseResult<T>) => result.kind !== ResponseResultKind.Ok;
+
+const PATH_VARIABLE_PATTERN = /:(.\w+)/;
+
+const pathReplacement = <PP extends Object, T1, T2>(route: Route<PP, T1, T2>, params: PP) => {
+  return route.path.replaceAll(PATH_VARIABLE_PATTERN, (_match, g1) => {
+    const param = params[g1];
+
+    if (param === undefined) {
+      throw new Error(`Call to ${route.path} is missing value for parameter ${g1}`);
+    }
+
+    return param;
+  });
+}
+
+const mapError = <T>(e: unknown, path: string): ResponseResult<T> => {
+  if (isAxiosError(e)) {
+    if (e.response) {
+      return {
+        kind: ResponseResultKind.ResponseError,
+        status: e.response.status,
+        data: e.response.data,
+        cause: e,
+      }
+    } else {
+      return {
+        kind: ResponseResultKind.RequestError,
+        cause: e,
+      }
+    }
+  } else {
+    throw new Error(`Error calling ${path}`, { cause: e });
+  }
+}
+
+export const doGet = (axios: Axios) => async <PathParams extends Object, Resp>(route: GetRoute<PathParams, Resp>, args: PathParams, options?: ReqOptions): Promise<ResponseResult<Resp>> => {
+  const path = pathReplacement(route, args);
+
+  try {
+    const response = await axios.get<Resp>(path, options);
+
+    return {
+      kind: ResponseResultKind.Ok,
+      data: response.data,
+    }
+  } catch (e) {
+    return mapError(e, path);
+  }
+}
+
+
+export const doPost = <PathParams extends Object, Req, Resp>(axios: Axios) => async (route: PostRoute<PathParams, Req, Resp>, args: PathParams, req: Req, options?: ReqOptions): Promise<ResponseResult<Resp>> => {
+  const path = pathReplacement(route, args);
+
+  try {
+    const response = await axios.post<Resp>(path, req, options);
+
+    return {
+      kind: ResponseResultKind.Ok,
+      data: response.data,
+    }
+  } catch (e) {
+    return mapError(e, path);
+  }
+}
+
+export const doPatch = <PathParams extends Object, Req, Resp>(axios: Axios) => async (route: PatchRoute<PathParams, Req, Resp>, args: PathParams, req: Req, options?: ReqOptions): Promise<ResponseResult<Resp>> => {
+  const path = pathReplacement(route, args);
+
+  try {
+    const response = await axios.patch<Resp>(path, req, options);
+
+    return {
+      kind: ResponseResultKind.Ok,
+      data: response.data,
+    }
+  } catch (e) {
+    return mapError(e, path);
+  }
+}
+
+export const doDelete = <PathParams extends Object, Req, Resp>(axios: Axios) => async (route: DeleteRoute<PathParams, Resp>, args: PathParams, req: Req, options?: ReqOptions): Promise<ResponseResult<Resp>> => {
+  const path = pathReplacement(route, args);
+
+  try {
+    const response = await axios.delete<Resp>(path, options);
+
+    return {
+      kind: ResponseResultKind.Ok,
+      data: response.data,
+    }
+  } catch (e) {
+    return mapError(e, path);
+  }
+}
+
+export const doPut = <PathParams extends Object, Req, Resp>(axios: Axios) => async (route: PutRoute<PathParams, Req, Resp>, args: PathParams, req: Req, options?: ReqOptions): Promise<ResponseResult<Resp>> => {
+  const path = pathReplacement(route, args);
+
+  try {
+    const response = await axios.put<Resp>(path, req, options);
+
+    return {
+      kind: ResponseResultKind.Ok,
+      data: response.data,
+    }
+  } catch (e) {
+    return mapError(e, path);
+  }
+}
+
+export const httpInjectionKey: InjectionKey<Axios> = Symbol('httpClient');

client/src/util/http.ts

@@ -0,0 +1,33 @@
+import axios from "axios";
+
+const isISODate = (value: unknown) => {
+  return typeof value === 'string' && value.match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(.\d+)?Z$/);
+};
+
+export const convertDates = (obj: unknown) => {
+  if (Array.isArray(obj)) {
+    return obj.map(convertDates);
+  } else if (obj !== null && typeof obj === 'object') {
+    return Object.fromEntries(
+      Object.entries(obj).map(([key, value]) => [key, convertDates(value)])
+    );
+  } else if (isISODate(obj)) {
+    return new Date(obj as string);
+  }
+  return obj;
+};
+
+export const createHttpClient = () => {
+  axios.create();
+
+  axios.interceptors.response.use((response) => {
+    if (response.data) {
+      response.data = convertDates(response.data);
+    }
+    return response;
+  }, (error) => {
+    return Promise.reject(error);
+  });
+
+  return axios
+}

client/src/views/game/Game.vue

@@ -37,15 +37,14 @@ import GameApiService from '../../services/api/game'
 import UserApiService from '../../services/api/user'
 import GameHelper from '../../services/gameHelper'
 import AudioService from '../../game/audio'
-import moment from 'moment'
 import gameHelper from '../../services/gameHelper'
-import authService from '../../services/api/auth'
 import ColourOverrideDialog from "./components/player/ColourOverrideDialog.vue";
 import { eventBusInjectionKey } from '../../eventBus'
 import { inject } from 'vue';
 import { playerClientSocketEmitterInjectionKey } from '../../sockets/socketEmitters/player'
 import PlayerEventBusEventNames from '../../eventBusEventNames/player'
 import GameEventBusEventNames from '../../eventBusEventNames/game'
+import router from '../../router'
 
 export default {
   components: {
@@ -172,6 +171,10 @@ export default {
         }
       } catch (err) {
         console.error(err)
+
+        this.$toast.error('Game failed to load');
+
+        await router.push({ name: 'main-menu' })
       }
     },
     async reloadSettings () {

client/src/views/game/components/menu/OptionsForm.vue

@@ -464,6 +464,13 @@
       </div>
     </div>
 
+    <div class="row pt-1 pb-1">
+      <label for="fpsLimit" class="col-12 col-sm-6 col-form-label">FPS Limit</label>
+      <div class="col-12 col-sm-6">
+        <input class="form-control" min="0" max="240" type="number" id="fpsLimit" v-model="settings.technical.fpsLimit" :disabled="isSavingSettings">
+      </div>
+    </div>
+
     <form-error-list v-bind:errors="errors"/>
 
     <div class="row mt-2">

client/src/views/game/components/specialist/HireSpecialistCarrier.vue

@@ -89,7 +89,7 @@ export default {
       this.$emit('onOpenCarrierDetailRequested', carrier._id)
     },
     async hireSpecialist (specialist) {
-        if (!await this.$confirm('Hire specialist', `Are you sure you want to hire a ${specialist.name} for ${this.getSpecialistActualCostString(specialist)}?`)) {
+        if (!await this.$confirm('Hire specialist', `Are you sure you want to hire a ${specialist.name} for ${this.getSpecialistActualCostString(specialist)} on Carrier ${this.carrier.name}?`)) {
           return
         }
 

client/src/views/game/components/specialist/HireSpecialistStar.vue

@@ -80,7 +80,7 @@ export default {
       this.$emit('onOpenStarDetailRequested', star._id)
     },
     async hireSpecialist (specialist) {
-        if (!await this.$confirm('Hire specialist', `Are you sure you want to hire a ${specialist.name} for ${this.getSpecialistActualCostString(specialist)}?`)) {
+        if (!await this.$confirm('Hire specialist', `Are you sure you want to hire a ${specialist.name} for ${this.getSpecialistActualCostString(specialist)} on Star ${this.star.name}?`)) {
           return
         }