Function _update has 65 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    async _update(delta: number, tick: number): Promise<void> {
        const { terrainInfo, npcInfo, gameInfo, eventTimeInfo } = this._storeData;

        const rules = await this.getRules();

Function checkCondition has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

export const checkCondition = (
    data: Object,
    conditions: Object,
    condition: string,
    checkCallback: (Object, Object) => boolean,

• Read up
  Read up

Function commonReact has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

const commonReact = (data: Object, reaction: Object, action:{type: string, triggerBy: any, triggerTo: any, stamp: { seed: string, time: number }}): void => {
    const { peeledPropArray } = peelPropsString(reaction.attribute);

    let value = data;
    let accessProp = null;

Function getCorrectNode has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    static getCorrectNode(
        paths: Array<PathNode>,
    ): {
        node: PathNode | null,
        closedPaths: Array<PathNode>,

Function getCorrectPath has 27 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    getCorrectPath(startNode: PathNode): Array<Grid> {
        const pathNodes = startNode.getNeighbors();
        const scannedPaths: Array<PathNode> = [startNode];
        const correctPath = [];

Function _initMouseEvent has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    _initMouseEvent() {

        this._initControllerEvent();

        this._renderer.stage.mousedown = (e) => {

Function getCorrectNode has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    static getCorrectNode(
        paths: Array<PathNode>,
    ): {
        node: PathNode | null,
        closedPaths: Array<PathNode>,

• Read up
  Read up

Function commonReact has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

const commonReact = (data: Object, reaction: Object, action:{type: string, triggerBy: any, triggerTo: any, stamp: { seed: string, time: number }}): void => {
    const { peeledPropArray } = peelPropsString(reaction.attribute);

    let value = data;
    let accessProp = null;

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                            if (
                                trigger.triggerLimit &&
                                !eventTimeInfo.dataSet[trigger.name]
                            ) {
                                await this._store.dispatch({

Avoid deeply nested control flow statements.

Open

                            if (trigger.triggerLimit) {
                                await this._store.dispatch({
                                    type: RECORD_EVENT_TIME,
                                    name: trigger.name,
                                    time: tick + trigger.triggerLimit,

Avoid deeply nested control flow statements.

Open

                            if (!conditionInfo) {
                                continue;
                            }

Avoid deeply nested control flow statements.

Open

                            if(trigger.rate && !checkChanceByTicker({seed: gameInfo.seed, time: tick}, trigger.rate)){
                                continue;
                            }

Avoid deeply nested control flow statements.

Open

                            if (
                                eventTimeInfo.dataSet[trigger.name] &&
                                tick <
                                eventTimeInfo.dataSet[trigger.name].time
                            ) {

Consider simplifying this complex logical expression.

Open

                if (
                    (onlyDirect && triggerTo?.qinId !== data.qinId)
                    || blockers.includes(triggerBy.qinId)
                    || (!isAny && !types.includes(triggerBy.type) && !triggers.includes(triggerBy.qinId))
                ) {

Consider simplifying this complex logical expression.

Open

                if (
                    (onlyDirect && triggerTo?.qinId !== data.qinId)
                    || blockers.includes(triggerBy.qinId)
                    || (!isAny && !types.includes(triggerBy.type) && !triggers.includes(triggerBy.qinId))
                ) {

Consider simplifying this complex logical expression.

Open

                if (
                    (onlyDirect && triggerTo?.qinId !== data.qinId)
                    || blockers.includes(triggerBy.qinId)
                    || (!isAny && !types.includes(triggerBy.type) && !triggers.includes(triggerBy.qinId))
                ) {

Function getCorrectPath has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

    getCorrectPath(startNode: PathNode): Array<Grid> {
        const pathNodes = startNode.getNeighbors();
        const scannedPaths: Array<PathNode> = [startNode];
        const correctPath = [];

• Read up
  Read up

Function dynamicReact has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

const dynamicReact = (data: Object, reaction: Object, action:{type: string, triggerBy: any, triggerTo: any, stamp: { seed: string, time: number }}): void => {
    if (typeof reaction.rate !== 'undefined' && !checkChance(data, reaction, action.stamp)) {
        return;
    }

• Read up
  Read up

Function _prepareAssets has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    _prepareAssets(assetsSet: Array<AnimationAssetType>) {
        let loader = PIXI.Loader.shared;
        loader.reset();

        for (let assetsData of assetsSet) {

• Read up
  Read up