@flashist/appframework 0.0.3

package/src/hints/data/IHintConfig.ts

@@ -0,0 +1,20 @@
+import {Point} from "@flashist/flibs";
+
+export interface IHintConfig {
+    containerId: string;
+
+    startGlobalPos: Point;
+
+    positionTweenDuration: number;
+    finalGlobalPosMinChange: Point;
+    finalGlobalPosMaxChange: Point;
+
+    startAlphaTweenDuration: number;
+    startAlphaTweenDelay: number;
+    finalAlphaTweenDuration: number;
+    finalAlphaTweenDelay: number;
+
+    startAlpha: number;
+    mainAlpha: number;
+    finalAlpha: number;
+}

package/src/html/HTMLModule.ts

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

package/src/html/managers/HTMLManager.ts

@@ -0,0 +1,32 @@
+import {getInstance, SoundsManager} from "@flashist/flibs";
+
+import {BaseAppManager} from "../../base/managers/BaseAppManager";
+
+export class HTMLManager extends BaseAppManager {
+
+    protected soundsManager: SoundsManager = getInstance(SoundsManager);
+
+    protected addListeners(): void {
+        super.addListeners();
+
+        this.eventListenerHelper.addEventListener(
+            window as any,
+            "focus",
+            this.onFocus
+        );
+
+        this.eventListenerHelper.addEventListener(
+            window as any,
+            "blur",
+            this.onBlur
+        );
+    }
+
+    protected onFocus(): void {
+        this.soundsManager.removeDisableLock(this);
+    }
+
+    protected onBlur(): void {
+        this.soundsManager.addDisableLock(this);
+    }
+}

package/src/index.ts

@@ -0,0 +1,21 @@
+export * from './facade/Facade'
+export * from './base/views/BaseAppView'
+export * from './base/models/BaseAppModel'
+export * from './base/models/BaseAppGenericObjectsModel'
+export * from './base/modules/AppModulesManager'
+export * from './base/modules/BaseAppModule'
+export * from './base/managers/BaseAppManager'
+export * from './base/mediators/BaseAppMediator'
+
+export * from './app/models/AppConfigModel'
+export * from './app/models/AppModel'
+
+export * from './renderer/RendererModule'
+
+export * from './time/models/TimeModelEvent'
+export * from './time/models/TimeModel'
+
+export * from './load/LoadGroupName'
+
+export * from './pages/views/BasePageView'
+export * from './pages/commands/ChangePageCommand'

package/src/init/commands/InitApplicationCommand.ts

@@ -0,0 +1,34 @@
+import { QueueCommand } from "@flashist/fcore";
+
+import { getInstance, WaitGroupLoadingCompleteCommand } from "@flashist/flibs";
+
+import { LoadAppConfigCommand } from "../../app/commands/LoadAppConfigCommand";
+import { LoadGroupName } from "../../load/LoadGroupName";
+import { ChangePageCommand } from "../../pages/commands/ChangePageCommand";
+import { PageId } from "../../pages/PageId";
+import { InitApplicationDataCommand } from "./InitApplicationDataCommand";
+import { ParseStaticItemsConfigCommand } from "../../app/commands/ParseStaticItemsConfigCommand";
+import { ParseLocaleConfigCommand } from "../../locales/commands/ParseLocaleConfigCommand";
+import { ParseAssetsConfigCommand } from "../../assets/commands/ParseAssetsConfigCommand";
+
+export class InitApplicationCommand extends QueueCommand {
+
+    constructor() {
+        super(
+            [
+                getInstance(LoadAppConfigCommand),
+                getInstance(WaitGroupLoadingCompleteCommand, LoadGroupName.CONFIG),
+
+                getInstance(ParseLocaleConfigCommand),
+                getInstance(ParseAssetsConfigCommand),
+                getInstance(ParseStaticItemsConfigCommand),
+
+                getInstance(WaitGroupLoadingCompleteCommand, LoadGroupName.PRELOAD),
+
+                getInstance(InitApplicationDataCommand),
+
+                getInstance(ChangePageCommand, PageId.PRELOADER_PAGE)
+            ] as any
+        );
+    }
+}

package/src/init/commands/InitApplicationDataCommand.ts

@@ -0,0 +1,19 @@
+import {BaseAppCommand} from "../../base/commands/BaseAppCommand";
+import {InitApplicationDataEvent} from "./InitApplicationDataEvent";
+
+/**
+ * Command-placeholder for specific applications init their data (e.g. first server request)
+ */
+export class InitApplicationDataCommand extends BaseAppCommand {
+
+    protected executeInternal(): void {
+        this.notifyComplete();
+    }
+
+
+    protected notifyComplete(resolveData?: any, rejectErrorData?: any): void {
+        this.dispatchEvent(InitApplicationDataEvent.INTI_APPLICATION_DATA_COMPLETE);
+
+        super.notifyComplete(resolveData, rejectErrorData);
+    }
+}

package/src/init/commands/InitApplicationDataEvent.ts

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

package/src/load/LoadGroupName.ts

@@ -0,0 +1,5 @@
+export enum LoadGroupName {
+    CONFIG = "config",
+    PRELOAD = "preload",
+    INIT = "init"
+};

package/src/load/LoadModule.ts

@@ -0,0 +1,23 @@
+import {LoadFactory, LoadManager, serviceLocatorAdd} from "@flashist/flibs";
+
+import {BaseAppModule} from "../base/modules/BaseAppModule";
+
+export class LoadModule extends BaseAppModule {
+
+    constructor(protected basePath: string = "") {
+        super();
+    }
+
+    init(): void {
+        super.init();
+
+        // Load
+        serviceLocatorAdd(LoadManager, {isSingleton: true, forceCreation: true});
+    }
+
+    activateCompleteHook(): void {
+        super.activateCompleteHook();
+
+        LoadFactory.instance.basePath = this.basePath;
+    }
+}

package/src/load/LoaderId.ts

@@ -0,0 +1,5 @@
+/*
+export enum LoaderId {
+    PRELOAD = "preload",
+    INIT = "init"
+};*/

package/src/locales/LocalesModule.ts

@@ -0,0 +1,11 @@
+import {LocaleManager, serviceLocatorAdd} from "@flashist/flibs";
+import {BaseAppModule} from "../base/modules/BaseAppModule";
+
+export class LocalesModule extends BaseAppModule {
+
+    init(): void {
+        super.init();
+
+        serviceLocatorAdd(LocaleManager, {isSingleton: true});
+    }
+}

package/src/locales/commands/ParseLocaleConfigCommand.ts

@@ -0,0 +1,28 @@
+import {AbstractLoadItem, getInstance, ILocaleConfig, LoadManager, LocaleManager} from "@flashist/flibs";
+
+import {AppConfigModel} from "../../app/models/AppConfigModel";
+import {BaseAppCommand} from "../../base/commands/BaseAppCommand";
+import {AppSettings} from "../../app/AppSettings";
+
+export class ParseLocaleConfigCommand extends BaseAppCommand {
+
+    protected executeInternal(): void {
+        let loadManager: LoadManager = getInstance(LoadManager);
+        let localeConfigFileItem: AbstractLoadItem = loadManager.getLoadItem(AppSettings.localeConfigFileId);
+        if (localeConfigFileItem && localeConfigFileItem.data) {
+            let appConfigModel: AppConfigModel = getInstance(AppConfigModel);
+
+            let localizationJson: ILocaleConfig = localeConfigFileItem.data;
+
+            let localeManager: LocaleManager = getInstance<LocaleManager>(LocaleManager);
+            localeManager.setCurrentLanguage(appConfigModel.appConfig.locale);
+            localeManager.addLocale(localizationJson, appConfigModel.appConfig.locale);
+
+            this.notifyComplete();
+
+        } else {
+            console.error("ParseLocalizationCommand | executeInternal __ ERROR! Can't find config file!");
+            this.terminate();
+        }
+    }
+}

package/src/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@flashist/flibs",
+  "version": "0.0.117",
+  "scripts": {
+    "build": "gulp",
+    "publish:patch": "npm version patch && npm run build && cd ./dist && npm publish",
+    "publish:minor": "npm version minor && npm run build && cd ./dist && npm publish",
+    "publish:major": "npm version major && npm run build && cd ./dist && npm publish"
+  },
+  "license": "MIT",
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/flashist/flibs"
+  },
+  "main": "index.js",
+  "typings": "index.d.ts",
+  "dependencies": {
+    "@flashist/fcore": "0.x",
+    "@types/gsap": "^1.20.2",
+    "@types/howler": "^2.1.0",
+    "webfontloader": "^1.6.28"
+  },
+  "devDependencies": {
+    "@types/webfontloader": "^1.6.29",
+    "gulp": "^4.0.2",
+    "gulp-shell": "^0.8.0",
+    "pixi.js": "^6.5.5",
+    "require-dir": "^1.2.0",
+    "rimraf": "^3.0.2",
+    "typescript": "^4.0.2"
+  },
+  "peerDependencies": {
+    "pixi.js": "^6.5.5"
+  }
+}

package/src/pages/PageId.ts

@@ -0,0 +1,4 @@
+export const PageId = {
+    PRELOADER_PAGE: "preloaderPage",
+    APP_PAGE: "appPage"
+};

package/src/pages/PagesModule.ts

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

package/src/pages/commands/ChangePageCommand.ts

@@ -0,0 +1,18 @@
+import {getInstance} from "@flashist/flibs";
+
+import {PagesModel} from "../models/PagesModel";
+import {BaseAppCommand} from "../../base/commands/BaseAppCommand";
+
+export class ChangePageCommand extends BaseAppCommand {
+
+    protected pagesModel: PagesModel = getInstance(PagesModel);
+
+    constructor(protected pageId: string) {
+        super();
+    }
+
+    protected executeInternal(): void {
+        this.pagesModel.pageId = this.pageId;
+        this.notifyComplete();
+    }
+}

package/src/pages/models/PagesModel.ts

@@ -0,0 +1,38 @@
+import {AssociativeArray, IConstructor} from "@flashist/fcore";
+
+import {BaseAppGenericObjectsModel} from "../../base/models/BaseAppGenericObjectsModel";
+import {PagesModelEvent} from "./PagesModelEvent";
+
+export class PagesModel extends BaseAppGenericObjectsModel {
+
+    private _pageId: string;
+
+    protected pageIdToViewClassMap: AssociativeArray<IConstructor>;
+
+    constructor() {
+        super();
+
+        this.pageIdToViewClassMap = new AssociativeArray<IConstructor>();
+    }
+
+    addPageViewClass(Class: IConstructor, id: string): void {
+        this.pageIdToViewClassMap.push(Class, id);
+    }
+
+    public getPageIdToViewClassMap(): AssociativeArray<IConstructor> {
+        return this.pageIdToViewClassMap.clone();
+    }
+
+    get pageId(): string {
+        return this._pageId;
+    }
+    set pageId(value: string) {
+        if (value === this._pageId) {
+            return;
+        }
+
+        this._pageId = value;
+
+        this.dispatchEvent(PagesModelEvent.PAGE_ID_CHANGE);
+    }
+}

package/src/pages/models/PagesModelEvent.ts

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

package/src/pages/views/BasePageView.ts

@@ -0,0 +1,75 @@
+import { DisplayResizeTools, FContainer, getInstance, Graphics, Point, Rectangle } from "@flashist/flibs";
+
+import { BaseAppView } from "../../base/views/BaseAppView";
+import { AppConfigModel } from "../../app/models/AppConfigModel";
+
+export class BasePageView extends BaseAppView {
+
+    protected appConfigModel: AppConfigModel;
+
+    protected sizeArea: Rectangle;
+    protected sizeAreaView: Graphics;
+
+    protected contentCont: FContainer;
+    protected reversedScaleContentScreenSize: Point;
+
+    protected construction(...args): void {
+        super.construction(args);
+
+        this.appConfigModel = getInstance(AppConfigModel);
+
+        this.sizeArea = new Rectangle();
+        if (this.appConfigModel.appConfig.sizeArea) {
+            this.sizeArea = new Rectangle(
+                this.appConfigModel.appConfig.sizeArea.x,
+                this.appConfigModel.appConfig.sizeArea.y,
+                this.appConfigModel.appConfig.sizeArea.width,
+                this.appConfigModel.appConfig.sizeArea.height
+            )
+        }
+
+        this.reversedScaleContentScreenSize = new Point();
+
+        this.contentCont = new FContainer();
+        this.addChild(this.contentCont);
+        this.contentCont.interactive = true;
+
+        this.sizeAreaView = new Graphics();
+        this.contentCont.addChild(this.sizeAreaView);
+        //
+        this.sizeAreaView.beginFill(0x000000, 0.5);
+        this.sizeAreaView.drawRect(
+            this.sizeArea.x,
+            this.sizeArea.y,
+            this.sizeArea.width,
+            this.sizeArea.height
+        );
+        this.sizeAreaView.endFill();
+        this.sizeAreaView.alpha = 0;
+    }
+
+    protected arrange(): void {
+        super.arrange();
+
+        // Reset previous scale
+        this.contentCont.scale.set(1, 1);
+
+        // Scale according to the current size
+        let tempScale: number = DisplayResizeTools.getScale(
+            this.sizeArea.width,
+            this.sizeArea.height,
+            this.resizeSize.x,
+            this.resizeSize.y
+        );
+        this.contentCont.scale.set(tempScale);
+        /*this.contentCont.x = this.sizeArea.x + Math.floor((this.resizeSize.x - this.contentCont.width) / 2);
+        this.contentCont.y = this.sizeArea.y + Math.floor((this.resizeSize.y - this.contentCont.height) / 2);*/
+        this.contentCont.x = Math.floor((this.resizeSize.x - (this.sizeArea.width * tempScale)) / 2);
+        this.contentCont.x -= Math.floor(this.sizeArea.x * tempScale);
+        this.contentCont.y = Math.floor((this.resizeSize.y - (this.sizeArea.height * tempScale)) / 2);
+        this.contentCont.y -= Math.floor(this.sizeArea.y * tempScale);
+
+        this.reversedScaleContentScreenSize.x = Math.floor(this.resizeSize.x / this.contentCont.scale.x);
+        this.reversedScaleContentScreenSize.y = Math.floor(this.resizeSize.y / this.contentCont.scale.y);
+    }
+}

package/src/pages/views/PagesView.ts

@@ -0,0 +1,57 @@
+import {ResizableContainer} from "../../display/views/resize/ResizableContainer";
+import {ViewLazyCreationServiceLocatorStack} from "../../display/views/viewstack/ViewLazyCreationServiceLocatorStack";
+import {PagesModel} from "../models/PagesModel";
+import {getInstance} from "@flashist/flibs";
+import {PagesModelEvent} from "../models/PagesModelEvent";
+
+export class PagesView extends ResizableContainer {
+
+    protected pagesModel: PagesModel;
+
+    public viewStack: ViewLazyCreationServiceLocatorStack;
+
+    protected construction(...args): void {
+        super.construction(args);
+
+        this.pagesModel = getInstance(PagesModel);
+
+        this.viewStack = new ViewLazyCreationServiceLocatorStack();
+        this.addChild(this.viewStack);
+
+        let pageIdToViewClassMap = this.pagesModel.getPageIdToViewClassMap();
+        let pageIds: string[] = pageIdToViewClassMap.getAllKeys();
+        let pageIdsCount: number = pageIds.length;
+        for (let pageIdIndex: number = 0; pageIdIndex < pageIdsCount; pageIdIndex++) {
+            let tempPageClass = pageIdToViewClassMap.getItemByIndex(pageIdIndex);
+            let tempPageId: string = pageIds[pageIdIndex];
+
+            this.viewStack.addViewClass(tempPageClass, tempPageId);
+        }
+
+        this.commitPagesData();
+    }
+
+    protected addListeners(): void {
+        super.addListeners();
+
+        this.eventListenerHelper.addEventListener(
+            this.pagesModel,
+            PagesModelEvent.PAGE_ID_CHANGE,
+            this.onPageIdChange
+        );
+    }
+
+    protected onPageIdChange(): void {
+        this.commitPagesData();
+    }
+
+    protected commitPagesData(): void {
+        this.viewStack.selectedId = this.pagesModel.pageId;
+    }
+
+    protected arrange(): void {
+        super.arrange();
+
+        this.viewStack.resize(this.resizeSize.x, this.resizeSize.y);
+    }
+}

package/src/pool/ObjectsPoolModule.ts

@@ -0,0 +1,13 @@
+import {ObjectsPool} from "@flashist/fcore";
+import {serviceLocatorAdd, ServiceLocatorObjectsPool} from "@flashist/flibs";
+
+import {BaseAppModule} from "../base/modules/BaseAppModule";
+
+export class ObjectsPoolModule extends BaseAppModule {
+    init(): void {
+        super.init();
+
+        serviceLocatorAdd(ObjectsPool, {isSingleton: true});
+        serviceLocatorAdd(ServiceLocatorObjectsPool, {toSubstitute: ObjectsPool});
+    }
+}

package/src/renderer/RendererModule.ts

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

package/src/renderer/events/RendererManagerEvent.ts

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

package/src/renderer/managers/RendererManager.ts

@@ -0,0 +1,52 @@
+import * as PIXI from "pixi.js";
+
+import { FApp } from "@flashist/flibs";
+
+import { BaseAppManager } from "../../base/managers/BaseAppManager";
+import { Facade } from "../../facade/Facade";
+import { RendererManagerEvent } from "../events/RendererManagerEvent";
+
+export class RendererManager extends BaseAppManager {
+
+    protected targetFps: number;
+
+    protected construction(targetFps?: number): void {
+        super.construction();
+
+        if (this.targetFps) {
+            PIXI.settings.TARGET_FPMS = this.targetFps / 1000;
+        }
+
+        Facade.instance.app = new FApp(
+            {
+                targetFps: targetFps
+            }
+        );
+
+        // Stage
+        Facade.instance.app.stage.interactive = true;
+
+        // Renderer
+        // Facade.instance.app.renderer.autoDensity = true;
+        // CSS settings
+        Facade.instance.app.renderer.view.style.position = "absolute";
+        Facade.instance.app.renderer.view.style.top = "0px";
+        Facade.instance.app.renderer.view.style.left = "0px";
+
+        // Append the renderer canvas to DOM
+        document.body.appendChild(Facade.instance.app.view);
+    }
+
+    public resize(width: number, height: number): void {
+        Facade.instance.app.renderer.resize(width, height);
+        this.dispatchEvent(RendererManagerEvent.RESIZE);
+    }
+
+    public get rendererWidth(): number {
+        return Facade.instance.app.renderer.width;
+    }
+
+    public get rendererHeight(): number {
+        return Facade.instance.app.renderer.height;
+    }
+}

package/src/server/ServerModule.ts

@@ -0,0 +1,14 @@
+import {serviceLocatorAdd} from "@flashist/flibs";
+
+import {BaseAppModule} from "../base/modules/BaseAppModule";
+import {ServerModel} from "./models/ServerModel";
+
+export class ServerModule extends BaseAppModule {
+
+    init(): void {
+        super.init();
+
+        serviceLocatorAdd(ServerModel, {isSingleton: true});
+    }
+
+}

package/src/server/commands/BaseServerCommand.ts

@@ -0,0 +1,39 @@
+import {GenericObjectsByTypeModel, getInstance} from "@flashist/flibs";
+
+import {BaseAppCommand} from "../../base/commands/BaseAppCommand";
+import {IServerResponseVO} from "../data/IServerResponseVO";
+import {ServerModel} from "../models/ServerModel";
+import {IServerRequestVO} from "../data/IServerRequestVO";
+
+/**
+ * The class is not prepared fully and at the current moment
+ * is substituted by game-level command, which emulates connection with server-side.
+ */
+export abstract class BaseServerCommand
+    <
+        ResponseType extends IServerResponseVO = IServerResponseVO,
+        RequestType extends IServerRequestVO = IServerRequestVO,
+    >
+    extends BaseAppCommand<ResponseType> {
+
+    protected serverModel: ServerModel = getInstance(ServerModel);
+    protected genericByTypeModel: GenericObjectsByTypeModel = getInstance(GenericObjectsByTypeModel);
+
+    constructor(protected requestData: RequestType) {
+        super()
+    }
+
+    protected notifyComplete(resolveData?: ResponseType, rejectErrorData?: any): void {
+        if (resolveData.errorCode) {
+            this.errorCode = resolveData.errorCode;
+        }
+        if (resolveData.time || resolveData.time === 0) {
+            this.serverModel.serverTime = resolveData.time;
+        }
+        if (resolveData.items) {
+            this.genericByTypeModel.commitItems(resolveData.items);
+        }
+
+        super.notifyComplete(resolveData, rejectErrorData);
+    }
+}

package/src/server/data/IServerRequestVO.ts

@@ -0,0 +1,12 @@
+import {IGenericObjectVO} from "@flashist/flibs";
+
+export interface IServerRequestVO {
+    requestId: string;
+    loginData?: string;
+
+    items?: IGenericObjectVO;
+
+    // This is needed because since some typescript version it's not possible
+    // to use object with fields, not described in an interface
+    [key: string]: any;
+}

package/src/server/data/IServerResponseVO.ts

@@ -0,0 +1,15 @@
+import {IGenericObjectVO} from "@flashist/flibs";
+
+export interface IServerResponseVO {
+    id: string;
+
+    errorCode?: string;
+    errorMessage?: string;
+
+    time?: number;
+    items?: IGenericObjectVO[];
+
+    // This is needed because since some typescript version it's not possible
+    // to use object with fields, not described in an interface
+    [key: string]: any;
+}

package/src/server/data/ServerErrorCode.ts

@@ -0,0 +1,3 @@
+;export const ServerErrorCode = {
+    UNKNOWN_REQUEST_ID: "unkownServerCodeId"
+}