@flashist/appframework 0.0.3

package/src/server/models/ServerModel.ts

@@ -0,0 +1,34 @@
+import {BaseAppGenericObjectsModel} from "../../base/models/BaseAppGenericObjectsModel";
+
+export class ServerModel extends BaseAppGenericObjectsModel {
+
+    private _clientTimeWhenServerTimeChanged: number = 0;
+
+    private _serverTime: number = 0;
+    get serverTime(): number {
+        return this._serverTime;
+    }
+    set serverTime(value: number) {
+        if (value === this.serverTime) {
+            return;
+        }
+
+        this._serverTime = value;
+        this._clientTimeWhenServerTimeChanged = Date.now();
+    }
+
+    get clientTimeWhenServerTimeChanged(): number {
+        return this._clientTimeWhenServerTimeChanged;
+    }
+    set clientTimeWhenServerTimeChanged(value: number) {
+        throw new Error("ERROR! The param 'clientTimeWhenServerTimeChanged' can't be changed directly!");
+    }
+
+    get clientTimeDeltaSinceServerTimeChanged(): number {
+        return Date.now() - this._clientTimeWhenServerTimeChanged;
+    }
+
+    get clientToServerTimeDelta(): number {
+        return this._clientTimeWhenServerTimeChanged - this._serverTime;
+    }
+}

package/src/sounds/SoundsModule.ts

@@ -0,0 +1,24 @@
+import {getInstance, serviceLocatorAdd, SoundsManager} from "@flashist/flibs";
+
+import {BaseAppModule} from "../base/modules/BaseAppModule";
+import {BackgroundMusicManager} from "./managers/BackgroundMusicManager";
+import {SoundsStorageManager} from "./managers/SoundsStorageManager";
+
+export class SoundsModule extends BaseAppModule {
+
+    init(): void {
+        super.init();
+
+        // Load
+        serviceLocatorAdd(SoundsManager, {isSingleton: true});
+        serviceLocatorAdd(BackgroundMusicManager, {isSingleton: true});
+        serviceLocatorAdd(SoundsStorageManager, {isSingleton: true, forceCreation: true});
+    }
+
+    activateCompleteHook(): void {
+        super.activateCompleteHook();
+
+        const soundsStorageModule: SoundsStorageManager = getInstance(SoundsStorageManager);
+        soundsStorageModule.activateCompleteHook();
+    }
+}

package/src/sounds/SoundsSettings.ts

@@ -0,0 +1,5 @@
+export const SoundsSettings = {
+    storage: {
+        isMutedParamId: "SoundsSettings.isMutedParamId"
+    }
+};

package/src/sounds/managers/BackgroundMusicManager.ts

@@ -0,0 +1,48 @@
+import {BaseObject} from "@flashist/fcore";
+import {getInstance, Sound, SoundsManager} from "@flashist/flibs";
+
+export class BackgroundMusicManager extends BaseObject {
+
+    protected soundsManager: SoundsManager = getInstance(SoundsManager);
+
+    protected currentMusic: Sound;
+    protected currentMusicId: string;
+
+    public fadeInTime: number = 0.5;
+    public fadeOutTime: number = 0.5;
+
+    public changeMusic(id: string): void {
+        if (this.currentMusicId === id) {
+            return;
+        }
+
+        this.stopMusic();
+
+        this.currentMusicId = id;
+        this.currentMusic = this.soundsManager.getSound(id);
+        if (this.currentMusic) {
+            // this.currentMusic.setVolume(0);
+            this.currentMusic.play({loop: true});
+            this.currentMusic.tweenVolume(1, this.fadeInTime);
+        }
+    }
+
+    public stopMusic(): void {
+        if (!this.currentMusic) {
+            return;
+        }
+
+        // Make link-copy of the currently played music, as it might be changed after volume tween
+        const currentMusicCopy: Sound = this.currentMusic;
+        this.currentMusic = null;
+        this.currentMusicId = null;
+
+        currentMusicCopy.tweenVolume(
+            0,
+            this.fadeOutTime,
+            () => {
+                currentMusicCopy.stop();
+            }
+        );
+    }
+}

package/src/sounds/managers/SoundsStorageManager.ts

@@ -0,0 +1,45 @@
+import {BaseObject} from "@flashist/fcore";
+import {getInstance, SoundsManager, SoundsManagerEvent} from "@flashist/flibs";
+
+import {StorageManager} from "../../storage/managers/StorageManager";
+import {SoundsSettings} from "../SoundsSettings";
+
+export class SoundsStorageManager extends BaseObject {
+
+    protected soundsManager: SoundsManager;
+    protected storageManager: StorageManager;
+
+    protected construction(...args): void {
+        this.soundsManager = getInstance(SoundsManager);
+        this.storageManager = getInstance(StorageManager);
+
+        super.construction(...args);
+    }
+
+    protected addListeners(): void {
+        super.addListeners();
+
+        this.eventListenerHelper.addEventListener(
+            this.soundsManager,
+            SoundsManagerEvent.IS_MUTED_CHANGE,
+            this.onSoundsDataChange
+        );
+    }
+
+    protected onSoundsDataChange(): void {
+        this.commitSoundsData();
+    }
+
+    public activateCompleteHook(): void {
+        const isMuted: boolean = this.storageManager.getParam<boolean>(SoundsSettings.storage.isMutedParamId);
+        if (isMuted === true || isMuted === false) {
+            this.soundsManager.isMuted = isMuted;
+        }
+
+        this.commitSoundsData();
+    }
+
+    protected commitSoundsData(): void {
+        this.storageManager.setParam(SoundsSettings.storage.isMutedParamId, this.soundsManager.isMuted);
+    }
+}

package/src/storage/StorageModule.ts

@@ -0,0 +1,13 @@
+import {serviceLocatorAdd} from "@flashist/flibs";
+import {BaseAppModule} from "../base/modules/BaseAppModule";
+import {StorageManager} from "./managers/StorageManager";
+
+export class StorageModule extends BaseAppModule {
+
+    init(): void {
+        super.init();
+
+        serviceLocatorAdd(StorageManager, {isSingleton: true, forceCreation: true});
+    }
+
+}

package/src/storage/StorageModuleConfig.ts

@@ -0,0 +1,3 @@
+export const StorageModuleConfig = {
+    storageId: "defaultStorageId"
+};

package/src/storage/managers/StorageManager.ts

@@ -0,0 +1,159 @@
+import {BaseObject} from "@flashist/fcore";
+import {StorageModuleConfig} from "../StorageModuleConfig";
+
+export class StorageManager extends BaseObject {
+
+    protected storageId: string;
+    protected storageData: any;
+
+    protected construction(): void {
+        super.construction();
+
+        this.storageId = StorageModuleConfig.storageId;
+
+        this.prepareStorage();
+        this.createStorage();
+    }
+
+    protected getWindowStorageObject(): any {
+        let rawData: string = localStorage.getItem(this.storageId);
+        if (!rawData) {
+            rawData = "{}";
+        }
+
+        return JSON.parse(rawData);
+    }
+
+    public setParam<DataType>(id: keyof DataType, value: DataType[keyof DataType]): void;
+    public setParam<ParamType>(id: string, value: ParamType): void;
+    public setParam(id: string, value: any): void {
+        if (this.storageData[id] === value) {
+            return;
+        }
+
+        this.storageData[id] = value;
+        this.writeSaves();
+    }
+
+    public getParam<DataType, ParamType>(id: keyof DataType): ParamType;
+    public getParam<DataType>(id: keyof DataType): DataType[keyof DataType];
+    public getParam<ParamType>(id: string): ParamType;
+    public getParam(id: string): any {
+        return this.storageData[id];
+    }
+
+    protected writeSaves(): void {
+        let rawData: string = JSON.stringify(this.storageData);
+        localStorage.setItem(this.storageId, rawData);
+    }
+
+    protected createStorage(): void {
+        this.storageData = this.getWindowStorageObject();
+
+        if (this.storageData.isCreated) {
+            this.initializeStorageData();
+        }
+    }
+
+    protected initializeStorageData(): void {
+        this.storageData.isCreated = true;
+
+        this.writeSaves();
+    }
+
+    public clearSaves(): void {
+        this.initializeStorageData();
+    }
+
+    protected prepareStorage(): void {
+        if (!window.localStorage) {
+            Object.defineProperty(window, "localStorage", new (function () {
+                var aKeys = [], oStorage = {};
+                Object.defineProperty(oStorage, "getItem", {
+                    value: function (sKey) {
+                        return this[sKey] ? this[sKey] : null;
+                    },
+                    writable: false,
+                    configurable: false,
+                    enumerable: false
+                });
+                Object.defineProperty(oStorage, "key", {
+                    value: function (nKeyId) {
+                        return aKeys[nKeyId];
+                    },
+                    writable: false,
+                    configurable: false,
+                    enumerable: false
+                });
+                Object.defineProperty(oStorage, "setItem", {
+                    value: function (sKey, sValue) {
+                        if (!sKey) {
+                            return;
+                        }
+                        document.cookie = escape(sKey) + "=" + escape(sValue) + "; expires=Tue, 19 Jan 2038 03:14:07 GMT; path=/";
+                    },
+                    writable: false,
+                    configurable: false,
+                    enumerable: false
+                });
+                Object.defineProperty(oStorage, "length", {
+                    get: function () {
+                        return aKeys.length;
+                    },
+                    configurable: false,
+                    enumerable: false
+                });
+                Object.defineProperty(oStorage, "removeItem", {
+                    value: function (sKey) {
+                        if (!sKey) {
+                            return;
+                        }
+                        document.cookie = escape(sKey) + "=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/";
+                    },
+                    writable: false,
+                    configurable: false,
+                    enumerable: false
+                });
+                Object.defineProperty(oStorage, "clear", {
+                    value: function () {
+                        if (!aKeys.length) {
+                            return;
+                        }
+                        for (var sKey in oStorage) {
+                            document.cookie = escape(sKey) + "=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/";
+                        }
+                    },
+                    writable: false,
+                    configurable: false,
+                    enumerable: false
+                });
+                this.get = function () {
+                    var iThisIndx;
+                    for (var sKey in oStorage) {
+                        iThisIndx = aKeys.indexOf(sKey);
+                        if (iThisIndx === -1) {
+                            (oStorage as any).setItem(sKey, oStorage[sKey]);
+                        }
+                        else {
+                            aKeys.splice(iThisIndx, 1);
+                        }
+                        delete oStorage[sKey];
+                    }
+                    for (aKeys; aKeys.length > 0; aKeys.splice(0, 1)) {
+                        (oStorage as any).removeItem(aKeys[0]);
+                    }
+                    for (var aCouple, iKey, nIdx = 0, aCouples = document.cookie.split(/\s*;\s*/); nIdx < aCouples.length; nIdx++) {
+                        aCouple = aCouples[nIdx].split(/\s*=\s*/);
+                        if (aCouple.length > 1) {
+                            oStorage[iKey = unescape(aCouple[0])] = unescape(aCouple[1]);
+                            aKeys.push(iKey);
+                        }
+                    }
+                    return oStorage;
+                };
+                this.configurable = false;
+                this.enumerable = true;
+            })());
+        }
+    }
+}

package/src/strategy/managers/BaseStrategyManager.ts

@@ -0,0 +1,37 @@
+import {BaseAppManager} from "../../base/managers/BaseAppManager";
+import {BaseStrategyModel} from "../models/BaseStrategyModel";
+import {BaseStrategy} from "../strategies/BaseStrategy";
+
+export abstract class BaseStrategyManager<
+        StrategyType extends BaseStrategy = BaseStrategy,
+        StrategyModelType extends BaseStrategyModel<StrategyType> = BaseStrategyModel<StrategyType>
+    > extends BaseAppManager {
+
+    protected strategyModel: StrategyModelType;
+    protected lastActiveStrategy: StrategyType;
+
+    /**
+     * It's supposed, that there is an external common-purpose model,
+     * which provides some data (e.g. the ID of an active item),
+     * and based on this data the manager should make the decision,
+     * about which specific id for a strategy should be used.
+     */
+    protected abstract findIdForCurrentStrategy(): string;
+
+    protected commitStrategyData(): void {
+        const newToolStrategy: StrategyType = this.strategyModel.getStrategyById(this.findIdForCurrentStrategy());
+        if (this.lastActiveStrategy === newToolStrategy) {
+            return;
+        }
+
+        if (this.lastActiveStrategy) {
+            this.lastActiveStrategy.deactivate();
+        }
+
+        this.lastActiveStrategy = newToolStrategy;
+        if (this.lastActiveStrategy) {
+            this.lastActiveStrategy.activate();
+        }
+    }
+
+}

package/src/strategy/models/BaseStrategyModel.ts

@@ -0,0 +1,40 @@
+import {AssociativeArray} from "@flashist/fcore";
+
+import {BaseAppModel} from "../../base/models/BaseAppModel";
+import {BaseStrategy} from "../strategies/BaseStrategy";
+
+export class BaseStrategyModel<StrategyType extends BaseStrategy = BaseStrategy> extends BaseAppModel {
+
+    protected strategyToIdMap: AssociativeArray<StrategyType> = new AssociativeArray<StrategyType>();
+
+    private _strategyId: string = "";
+
+    public addStrategy(strategy: StrategyType, id: string): void {
+        this.strategyToIdMap.push(strategy, id);
+    }
+
+    public removeStrategy(id: string): void {
+        this.strategyToIdMap.removeByKey(id);
+    }
+
+    public getStrategyById(id: string): StrategyType {
+        if (!this.strategyToIdMap.containsKey(id)) {
+            console.log("BaseStrategyModel | getStrategyForId __ WARNING! Can't find strategy for id: ", id);
+        }
+
+        return this.strategyToIdMap.getItem(id);
+    }
+
+
+    get strategyId(): string {
+        return this._strategyId;
+    }
+
+    set strategyId(value: string) {
+        if (value === this._strategyId) {
+            return;
+        }
+
+        this._strategyId = value;
+    }
+}

package/src/strategy/strategies/BaseStrategy.ts

@@ -0,0 +1,21 @@
+import {ArrayTools, Logger} from "@flashist/fcore";
+import {BaseObjectWithGlobalDispatcher} from "../../base/BaseObjectWithGlobalDispatcher";
+
+export abstract class BaseStrategy extends BaseObjectWithGlobalDispatcher {
+
+    protected static cache: BaseStrategy[] = [];
+
+    activate(): void {
+        Logger.log("BaseStrategy | activate __ this: ", this);
+
+        if (BaseStrategy.cache.indexOf(this) == -1) {
+            BaseStrategy.cache.push(this);
+        }
+    };
+
+    deactivate(): void {
+        this.eventListenerHelper.removeAllListeners();
+
+        ArrayTools.removeItem(BaseStrategy.cache, this);
+    }
+}

package/src/time/TimeModule.ts

@@ -0,0 +1,16 @@
+import {serviceLocatorAdd} from "@flashist/flibs";
+
+import {BaseAppModule} from "../base/modules/BaseAppModule";
+import {TimeManager} from "./managers/TimeManager";
+import {TimeModel} from "./models/TimeModel";
+
+export class TimeModule extends BaseAppModule {
+
+    init(): void {
+        super.init();
+
+        serviceLocatorAdd(TimeModel, {isSingleton: true, forceCreation: true});
+        serviceLocatorAdd(TimeManager, {isSingleton: true, forceCreation: true});
+    }
+
+}

package/src/time/managers/TimeManager.ts

@@ -0,0 +1,29 @@
+import {Ticker} from "pixi.js";
+
+import {getInstance} from "@flashist/flibs";
+
+import {BaseAppManager} from "../../base/managers/BaseAppManager";
+import {TimeModel} from "../models/TimeModel";
+
+
+export class TimeManager extends BaseAppManager {
+
+    protected timeModel: TimeModel = getInstance(TimeModel);
+
+    protected addListeners(): void {
+        super.addListeners();
+
+        //this is the same PIXI's ticker as it uses for its purposes (like MovieClips atc)
+        Ticker.shared.add(this.onTick, this);
+    }
+
+    protected removeListeners(): void {
+        super.removeListeners();
+
+        Ticker.shared.remove(this.onTick, this);
+    }
+
+    protected onTick(deltaTime: number): void {
+        this.timeModel.changeTimeData(Date.now(), deltaTime);
+    }
+}

package/src/time/models/TimeModel.ts

@@ -0,0 +1,29 @@
+import {BaseAppGenericObjectsModel} from "../../base/models/BaseAppGenericObjectsModel";
+import {TimeModelEvent} from "./TimeModelEvent";
+
+export class TimeModel extends BaseAppGenericObjectsModel {
+
+    public startTime: number = 0;
+    public prevTime: number = 0;
+    public currentTime: number = 0;
+    public lastRenderDeltaTime: number = 0;
+
+    protected construction(...args): void {
+        super.construction(args);
+
+        this.startTime = Date.now();
+    }
+
+    public changeTimeData(currentTime: number, lastRenderDeltaTime: number): void {
+        this.prevTime = this.currentTime;
+        this.currentTime = currentTime;
+
+        this.lastRenderDeltaTime = lastRenderDeltaTime;
+
+        this.dispatchEvent(TimeModelEvent.TIME_DATA_CHANGE);
+    }
+
+    public get timeDelta(): number {
+        return this.currentTime - this.prevTime;
+    }
+}

package/src/time/models/TimeModelEvent.ts

@@ -0,0 +1,3 @@
+export const TimeModelEvent = {
+    TIME_DATA_CHANGE: "TimeModelEvent.TIME_DATA_CHANGE"
+};

package/src/windows/data/IWindowConfigVO.ts

@@ -0,0 +1,9 @@
+import {IConstructor} from "@flashist/fcore";
+
+import {BaseWindow} from "../views/BaseWindow";
+
+export interface IWindowConfigVO {
+    type: string;
+    RenderClass: IConstructor<BaseWindow>;
+    bgConfig: {color: number, alpha: number};
+}

package/src/windows/managers/IShowWindowVO.ts

@@ -0,0 +1,4 @@
+export interface IShowWindowVO {
+    type: string;
+    data?: any;
+}

package/src/windows/managers/WindowsManager.ts

@@ -0,0 +1,72 @@
+import {FContainer} from "@flashist/flibs";
+
+import {BaseAppManager} from "../../base/managers/BaseAppManager";
+import {IWindowConfigVO} from "../data/IWindowConfigVO";
+import {IShowWindowVO} from "./IShowWindowVO";
+import {BaseWindow} from "../views/BaseWindow";
+
+export class WindowsManager extends BaseAppManager {
+    protected windowsContainer: FContainer;
+
+    protected windowConfigToTypeMap: { [type: string]: IWindowConfigVO } = {};
+
+    protected windowsToShowQueue: IShowWindowVO[] = [];
+
+    protected shownWindows: BaseWindow[] = [];
+
+    public setup(windowsContainer: FContainer): void {
+        this.windowsContainer = windowsContainer;
+    }
+
+    public addWindowConfig(config: IWindowConfigVO): void {
+        this.windowConfigToTypeMap[config.type] = config;
+    }
+
+    public showWindow(type: string, data?: any): void {
+        this.windowsToShowQueue.push(
+            {
+                type: type,
+                data: data
+            }
+        );
+
+        // TODO: at the current moment there is no logic about using queues
+        // or to configure how whondows might behave with each other
+        // (e.g. the new window might require to hide all others)
+
+        this.showNextWindow();
+    }
+
+    protected showNextWindow(): void {
+        if (this.windowsToShowQueue.length <= 0) {
+            return;
+        }
+
+        let tempShowData: IShowWindowVO = this.windowsToShowQueue.shift();
+        let tempConfig: IWindowConfigVO = this.windowConfigToTypeMap[tempShowData.type];
+        if (!tempConfig) {
+            return;
+        }
+
+        // TODO: change logic, if more complex relationships between windows required
+        // (e.g. some windows might allow to some other windows to be shown)
+        this.hideAllWindows();
+
+        let tempWindow: BaseWindow = this.createWindow(tempConfig, tempShowData.data);
+        this.windowsContainer.addChild(tempWindow);
+    }
+
+    protected createWindow(config: IWindowConfigVO, data?: any): BaseWindow {
+        let result = new config.RenderClass();
+        result.config = config;
+        result.data = data;
+
+        return result;
+    }
+
+    public hideAllWindows(): void {
+        for (let tempWindow of this.shownWindows) {
+            tempWindow.visible = false;
+        }
+    }
+}

package/src/windows/views/BaseWindow.ts

@@ -0,0 +1,22 @@
+import {FContainer} from "@flashist/flibs";
+import {IWindowConfigVO} from "../data/IWindowConfigVO";
+
+export class BaseWindow extends FContainer {
+
+    private _config: IWindowConfigVO;
+
+    get config(): IWindowConfigVO {
+        return this._config;
+    }
+    set config(value: IWindowConfigVO) {
+        if (value === this.config) {
+            return;
+        }
+
+        this._config = value;
+
+        this.commitData();
+    }
+
+
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "module": "es2015",
+    "moduleResolution": "node",
+    "allowSyntheticDefaultImports": true,
+    "lib": [
+      "es2015",
+      "dom"
+    ],
+    "sourceMap": true,
+    "declaration": true,
+    "outDir": "dist/",
+    "declarationDir": "dist/"
+  },
+  "include": [
+    "src/**/*"
+  ]
+}