update activities interface

packages/core/src/core/module/module.ts

@@ -1,7 +1,7 @@
 import { ModuleConfig } from "@core/global-type";
 import { IStore } from "@core/store";
 
-import { AnyActivity, IActivityHandler } from "@modules/activity";
+import { Activity, IActivityHandler } from "@modules/activity";
 
 export interface ProvideClass {
   new (...args: any[]): any;
@@ -17,7 +17,7 @@ export interface StoreClass {
 }
 
 export interface ActivityClass {
-  new (...args: any[]): IActivityHandler<AnyActivity>;
+  new (...args: any[]): IActivityHandler<Activity>;
 }
 
 export interface ModulActivity {

packages/core/src/modules/activity/activity-manager.ts

@@ -6,7 +6,7 @@ import { GetActivityHandlerToken } from "@core/module/tokens";
 import { PartyStore } from "@modules/party";
 
 import { ActivityStore } from "./activity-store";
-import { ActivityType, GetActivityHandlerByName, PartyActivity, PartyActivityStartArgs } from "./interfaces";
+import { Activity, ActivityType, GetActivityHandlerByName, PartyActivityStartArgs } from "./interfaces";
 
 @injectable()
 export class ActivityManager {
@@ -28,6 +28,7 @@ export class ActivityManager {
         type: ActivityType.Party,
         startArgs: startingArgs,
       });
+
       this.partyStore.setActivity(startingArgs.partyId, activity.id);
       if (startingArgs.involvedPartyId) {
         this.partyStore.setActivity(startingArgs.involvedPartyId, activity.id);
@@ -39,18 +40,21 @@ export class ActivityManager {
     forEach(activity => this.executeActivity(activity), values(this.activityStore.getState()));
   }
 
-  private executeActivity(activity: PartyActivity) {
+  private executeActivity(activity: Activity) {
     const activityHandler = this.getActivityHandler(activity.name);
     const activityNewState = activityHandler.execute(activity);
-    const updatedActivity = assoc("state", activityNewState, activity);
+    const updatedActivity = assoc("state", activityNewState, activity) as Activity;
     const isDone = activityHandler.isDone(updatedActivity);
 
     if (isDone) {
       activityHandler.resolve(updatedActivity);
       this.activityStore.remove(activity.id);
-      this.partyStore.clearActivity(activity.startArgs.partyId);
-      if (activity.startArgs.involvedPartyId) {
-        this.partyStore.clearActivity(activity.startArgs.involvedPartyId);
+
+      if(activity.type === ActivityType.Party) {
+        this.partyStore.clearActivity(activity.startArgs.partyId);
+        if (activity.startArgs.involvedPartyId) {
+          this.partyStore.clearActivity(activity.startArgs.involvedPartyId);
+        }
       }
     } else {
       this.activityStore.update(activity.id, updatedActivity);

packages/core/src/modules/activity/activity-store.ts

@@ -1,5 +1,5 @@
 import { EntityStore } from "@core/store";
 
-import { ActivityID, PartyActivity } from "./interfaces";
+import { ActivityID, Activity } from "./interfaces";
 
-export class ActivityStore extends EntityStore<ActivityID, PartyActivity> {}
+export class ActivityStore extends EntityStore<ActivityID, Activity> {}

packages/core/src/modules/activity/interfaces/activity-handler.ts

@@ -1,9 +1,9 @@
 import { Activity } from "./activity";
 
-export interface IActivityHandler<A extends Activity> {
-  start(startArgs: A['startArgs']): A['state'];
-  isRunnable(startArgs: A['startArgs']): boolean;
-  isDone(activity: Activity): boolean;
-  execute(activity: Activity): A['state'];
-  resolve(activity: Activity): void;
+export interface IActivityHandler<T extends Activity> {
+  start(startArgs: T['startArgs']): T['state'];
+  isRunnable(startArgs: T['startArgs']): boolean;
+  isDone(activity: T): boolean;
+  execute(activity: T): T['state'];
+  resolve(activity: T): void;
 }

packages/core/src/modules/activity/interfaces/activity.ts

@@ -3,23 +3,29 @@ import { PartyID } from "@modules/party";
 export type ActivityID = string;
 export enum ActivityType {
   Party = "party",
+  Global = "global"
 }
 
-export type Activity<State = unknown, StartingArgs = unknown> = {
+type ActivityBase<State = unknown, StartingArgs = unknown> = {
   id: ActivityID;
   state: State;
   name: string;
   startArgs: StartingArgs;
   type: ActivityType;
 };
 
-export type AnyActivity = Activity<any, any>;
-
 export type PartyActivityStartArgs = {
   partyId: PartyID;
   involvedPartyId?: PartyID;
 };
 
-export type PartyActivity<T = unknown> = Activity<T, PartyActivityStartArgs> & {
+export interface GlobalActivity<State = unknown, StartingArgs = unknown> extends ActivityBase<State, StartingArgs>  {
+  type: ActivityType.Global;
+
+}
+
+export interface PartyActivity<State = unknown, StartingArgs = unknown> extends ActivityBase<State, PartyActivityStartArgs & StartingArgs> {
   type: ActivityType.Party;
 };
+
+export type Activity<State = unknown, StartingArgs = unknown> = GlobalActivity<State, StartingArgs> | PartyActivity<State, StartingArgs>;

packages/core/src/modules/activity/interfaces/get-activity-handler-by-tag.ts

@@ -1,4 +1,4 @@
-import { AnyActivity } from "./activity";
+import { Activity } from "./activity";
 import { IActivityHandler } from "./activity-handler";
 
-export type GetActivityHandlerByName = (name: string) => IActivityHandler<AnyActivity>;
+export type GetActivityHandlerByName = (name: string) => IActivityHandler<Activity>;

packages/core/src/modules/battle/battle-activity.ts

@@ -4,7 +4,7 @@ import { complement, prop } from "ramda";
 import { ModuleConfig } from "@core/global-type";
 import { ModuleConfigToken } from "@core/module/tokens";
 
-import { Activity, IActivityHandler } from "@modules/activity";
+import { IActivityHandler, PartyActivity } from "@modules/activity";
 import { PartyID, PartyService } from "@modules/party";
 import { isAlive } from "@modules/unit";
 import { VillageStashService } from "@modules/village";
@@ -14,11 +14,11 @@ import { BattleService } from "./battle-service";
 import { BattleID } from "./interfaces";
 import { calculateLoot, calculateXpGain } from "./lib";
 
-export type BattleState = { battleId: BattleID };
-export type BattleStartArgs = { partyId: PartyID; involvedPartyId: PartyID };
+type BattleState = { battleId: BattleID };
+type BattleStartArgs = { partyId: PartyID; involvedPartyId: PartyID };
 
 @injectable()
-export class BattleActivity implements IActivityHandler<Activity<BattleState, BattleStartArgs>> {
+export class BattleActivity implements IActivityHandler<PartyActivity<BattleState, BattleStartArgs>> {
   constructor(
     private partyService: PartyService,
     private battleService: BattleService,
@@ -36,17 +36,17 @@ export class BattleActivity implements IActivityHandler<Activity<BattleState, Ba
     return this.partyService.isPartyAlive(partyId) && this.partyService.isPartyAlive(involvedPartyId);
   }
 
-  execute(activity: Activity<BattleState>): BattleState {
+  execute(activity: PartyActivity<BattleState>): BattleState {
     this.battleService.turnBattle(activity.state.battleId);
 
     return activity.state;
   }
 
-  isDone({ state: { battleId } }: Activity<BattleState>): boolean {
+  isDone({ state: { battleId } }: PartyActivity<BattleState>): boolean {
     return this.battleService.isDoneBattle(battleId);
   }
 
-  resolve({ state }: Activity<BattleState>) {
+  resolve({ state }: PartyActivity<BattleState>) {
     const battle = this.battleService.getBattle(state.battleId);
 
     const [winnerPartyId, looserPartyId] = this.partyService.isPartyAlive(battle.partyId)

packages/core/src/modules/game/interfaces/game-state.ts

@@ -1,4 +1,4 @@
-import { ActivityID, PartyActivity } from "@modules/activity";
+import { Activity, ActivityID } from "@modules/activity";
 import { BattleID, BattleStoreState } from "@modules/battle";
 import { Map, MapID, MapLocation, MapLocationID } from "@modules/map";
 import { Party, PartyID } from "@modules/party";
@@ -8,7 +8,7 @@ import { VillageState } from "@modules/village";
 import { GeneralGameStoreState } from "./general-game-store-state";
 
 export type GameState = {
-  activities: Record<ActivityID, PartyActivity<any>>;
+  activities: Record<ActivityID, Activity>;
   battle: Record<BattleID, BattleStoreState>;
   units: Record<UnitID, Unit>;
   parties: Record<PartyID, Party>;

packages/core/src/modules/map/activites/explore.ts

@@ -1,23 +1,23 @@
 import { injectable } from "inversify";
 import { dec, evolve } from "ramda";
 
-import { Activity, IActivityHandler } from "@modules/activity";
+import { PartyActivity, IActivityHandler } from "@modules/activity";
 import { PartyID, PartyStore } from "@modules/party";
 
 import { MapLocationStore } from "../map-location-store";
 import { MapService } from "../map-service";
 
-export type ExploreState = {
+type ExploreState = {
   progress: number;
   partyId: PartyID;
 };
 
-export type ExploreStartArgs = {
+type ExploreStartArgs = {
   partyId: PartyID;
 };
 
 @injectable()
-export class MapExploreActivity implements IActivityHandler<Activity<ExploreState, ExploreStartArgs>> {
+export class MapExploreActivity implements IActivityHandler<PartyActivity<ExploreState, ExploreStartArgs>> {
   constructor(
     private mapService: MapService,
     private mapLocationStore: MapLocationStore,
@@ -37,15 +37,15 @@ export class MapExploreActivity implements IActivityHandler<Activity<ExploreStat
     return !exploreLocation.explored;
   }
 
-  execute({ state }: Activity<ExploreState>): ExploreState {
+  execute({ state }: PartyActivity<ExploreState>): ExploreState {
     return evolve({ progress: dec }, state);
   }
 
-  isDone({ state }: Activity<ExploreState>): boolean {
+  isDone({ state }: PartyActivity<ExploreState>): boolean {
     return state.progress === 0;
   }
 
-  resolve({ state }: Activity<ExploreState>) {
+  resolve({ state }: PartyActivity<ExploreState>) {
     this.mapService.exploreLocation(this.partyStore.get(state.partyId).locationId);
   }
 }

packages/core/src/modules/map/activites/travel.ts

@@ -3,25 +3,25 @@ import { dec, evolve } from "ramda";
 
 import { EventSystem } from "@core/event";
 
-import { Activity, IActivityHandler } from "@modules/activity";
+import { PartyActivity, IActivityHandler } from "@modules/activity";
 import { PartyEvent, PartyID, PartyStore } from "@modules/party";
 
 import { MapLocationID } from "../interfaces";
 import { MapService } from "../map-service";
 
-export type TravelState = {
+type TravelState = {
   partyId: PartyID;
   targetLocationId: MapLocationID;
   progress: number;
 };
 
-export type TravelStartArgs = {
+type TravelStartArgs = {
   partyId: PartyID;
   targetLocationId: MapLocationID;
 };
 
 @injectable()
-export class MapTravelActivity implements IActivityHandler<Activity<TravelState, TravelStartArgs>> {
+export class MapTravelActivity implements IActivityHandler<PartyActivity<TravelState, TravelStartArgs>> {
   constructor(private partyStore: PartyStore, private mapService: MapService, private eventSystem: EventSystem) {}
 
   start({ partyId, targetLocationId }: TravelStartArgs): TravelState {
@@ -40,15 +40,15 @@ export class MapTravelActivity implements IActivityHandler<Activity<TravelState,
     return targetLocationId !== partyLocation;
   }
 
-  execute({ state }: Activity<TravelState>): TravelState {
+  execute({ state }: PartyActivity<TravelState>): TravelState {
     return evolve({ progress: dec }, state);
   }
 
-  isDone({ state }: Activity<TravelState>): boolean {
+  isDone({ state }: PartyActivity<TravelState>): boolean {
     return state.progress === 0;
   }
 
-  resolve({ state }: Activity<TravelState>) {
+  resolve({ state }: PartyActivity<TravelState>) {
     this.partyStore.setLocation(state.partyId, state.targetLocationId);
     this.eventSystem.fire(PartyEvent.ArrivedToLocation, {
       partyId: state.partyId,

packages/core/src/modules/village/activities/village-heal.ts

@@ -1,19 +1,22 @@
 import { injectable } from "inversify";
 import { filter, forEach, map } from "ramda";
 
-import { Activity, IActivityHandler } from "@modules/activity";
+import { PartyActivity, IActivityHandler } from "@modules/activity";
 import { PartyID, PartyStore } from "@modules/party";
 import { UnitID, UnitService, UnitStore } from "@modules/unit";
 
-export type VillageHealState = {
+type VillageHealState = {
   partyId: PartyID;
 };
 
-export type VillageHealStartArgs = VillageHealState;
-export type RecoverableUnit = { id: UnitID; hp: number; maxhp: number };
+type VillageHealStartArgs = {
+  partyId: PartyID;
+};
+
+type RecoverableUnit = { id: UnitID; hp: number; maxhp: number };
 
 @injectable()
-export class VillageHealActivity implements IActivityHandler<Activity<VillageHealState, VillageHealStartArgs>> {
+export class VillageHealActivity implements IActivityHandler<PartyActivity<VillageHealState, VillageHealStartArgs>> {
   constructor(private unitStore: UnitStore, private unitService: UnitService, private partyStore: PartyStore) {}
 
   start({ partyId }: VillageHealStartArgs): VillageHealState {
@@ -26,15 +29,15 @@ export class VillageHealActivity implements IActivityHandler<Activity<VillageHea
     return this.getRecoverableUnits(partyId).length > 0;
   }
 
-  execute({ state }: Activity<VillageHealState>): VillageHealState {
+  execute({ state }: PartyActivity<VillageHealState>): VillageHealState {
     const recoverableUnits = this.getRecoverableUnits(state.partyId);
 
     forEach(unit => this.unitService.healUnit(unit.id, Math.ceil(unit.maxhp / 10)), recoverableUnits);
 
     return state;
   }
 
-  isDone({ state: { partyId } }: Activity<VillageHealState>): boolean {
+  isDone({ state: { partyId } }: PartyActivity<VillageHealState>): boolean {
     return this.getRecoverableUnits(partyId).length === 0;
   }
 

packages/core/src/modules/village/buildings/training-field/activities/train-activity.ts

@@ -1,20 +1,19 @@
 import { injectable } from "inversify";
 import { dec, evolve, forEach } from "ramda";
 
-import { Activity, IActivityHandler } from "@modules/activity";
+import { PartyActivity, IActivityHandler } from "@modules/activity";
 import { PartyID, PartyStore } from "@modules/party";
-import { UnitID, UnitService } from "@modules/unit";
+import { UnitService } from "@modules/unit";
 
-export type TrainingFieldState = {
+type TrainingFieldState = {
   partyId: PartyID;
   progress: number;
 };
 
-export type TrainingFieldStartArgs = TrainingFieldState;
-export type RecoverableUnit = { id: UnitID; hp: number; maxhp: number };
+type TrainingFieldStartArgs = TrainingFieldState;
 
 @injectable()
-export class TrainingFieldTrainActivity implements IActivityHandler<Activity<TrainingFieldState, TrainingFieldStartArgs>> {
+export class TrainingFieldTrainActivity implements IActivityHandler<PartyActivity<TrainingFieldState, TrainingFieldStartArgs>> {
   constructor(private unitService: UnitService, private partyStore: PartyStore) {}
 
   start({ partyId }: TrainingFieldStartArgs): TrainingFieldState {
@@ -28,15 +27,15 @@ export class TrainingFieldTrainActivity implements IActivityHandler<Activity<Tra
     return true;
   }
 
-  execute({ state }: Activity<TrainingFieldState>): TrainingFieldState {
+  execute({ state }: PartyActivity<TrainingFieldState, TrainingFieldStartArgs>): TrainingFieldState {
     const units = this.partyStore.get(state.partyId).unitIds;
 
     forEach(unitId => this.unitService.gainXpUnit(unitId, 25), units);
 
     return evolve({ progress: dec }, state);
   }
 
-  isDone({ state }: Activity<TrainingFieldState>): boolean {
+  isDone({ state }: PartyActivity<TrainingFieldState, TrainingFieldStartArgs>): boolean {
     return state.progress === 0;
   }