mirror of
https://github.com/AsgardEternal/SquadJS.git
synced 2024-09-29 09:54:26 -05:00
220 lines
6.2 KiB
JavaScript
220 lines
6.2 KiB
JavaScript
import fs from 'fs';
|
|
import SquadLayers, {
|
|
SquadLayers as SquadLayersClass
|
|
} from './squad-layers.js';
|
|
|
|
export default class SquadLayerFilter extends SquadLayersClass {
|
|
constructor(layers, activeLayerFilter = null) {
|
|
super(layers);
|
|
|
|
if (activeLayerFilter === null) {
|
|
this.activeLayerFilter = null;
|
|
} else {
|
|
this.activeLayerFilter = {
|
|
historyResetTime: 5 * 60 * 60 * 1000,
|
|
layerHistoryTolerance: 8,
|
|
mapHistoryTolerance: 4,
|
|
gamemodeHistoryTolerance: {
|
|
// defaults as off
|
|
...activeLayerFilter.gamemodeHistoryTolerance
|
|
},
|
|
playerCountComplianceEnabled: true,
|
|
...activeLayerFilter
|
|
};
|
|
}
|
|
}
|
|
|
|
static buildFromList(layerNames, activeLayerFilter) {
|
|
return new SquadLayerFilter(layerNames, activeLayerFilter);
|
|
}
|
|
|
|
static buildFromDidYouMeanList(layerNames, activeLayerFilter) {
|
|
const layers = [];
|
|
for (const layerName of layerNames) {
|
|
const layer = SquadLayers.getLayerByDidYouMean(
|
|
layerName,
|
|
SquadLayers.getLayerNames()
|
|
);
|
|
if (layer) layers.push(layer);
|
|
}
|
|
return new SquadLayerFilter(layers, activeLayerFilter);
|
|
}
|
|
|
|
static buildFromFile(filename, activeLayerFilter, delimiter = '\n') {
|
|
const lines = fs
|
|
.readFileSync('./connectors/data/layers.json', 'utf8')
|
|
.split(delimiter);
|
|
const layers = [];
|
|
|
|
const validLayerNames = SquadLayers.getLayerNames();
|
|
|
|
for (const line of lines) {
|
|
if (validLayerNames.contains(line))
|
|
layers.push(SquadLayers.getLayerByLayerName(line));
|
|
}
|
|
return new SquadLayerFilter(layers, activeLayerFilter);
|
|
}
|
|
|
|
static buildFromFilter(filter = {}, activeLayerFilter) {
|
|
const whitelistedLayers = filter.whitelistedLayers || null;
|
|
const blacklistedLayers = filter.blacklistedLayers || null;
|
|
const whitelistedMaps = filter.whitelistedMaps || null;
|
|
const blacklistedMaps = filter.blacklistedMaps || null;
|
|
const whitelistedGamemodes = filter.whitelistedGamemodes || null;
|
|
const blacklistedGamemodes = filter.blacklistedGamemodes || ['Training'];
|
|
const flagCountMin = filter.flagCountMin || null;
|
|
const flagCountMax = filter.flagCountMax || null;
|
|
const hasCommander = filter.hasCommander || null;
|
|
const hasTanks = filter.hasTanks || null;
|
|
const hasHelicopters = filter.hasHelicopters || null;
|
|
|
|
const layers = [];
|
|
|
|
for (const layer of SquadLayers.getLayers()) {
|
|
// Whitelist / Blacklist Layers
|
|
if (
|
|
whitelistedLayers !== null &&
|
|
!whitelistedLayers.includes(layer.layer)
|
|
)
|
|
continue;
|
|
if (blacklistedLayers !== null && blacklistedLayers.includes(layer.layer))
|
|
continue;
|
|
|
|
// Whitelist / Blacklist Maps
|
|
if (whitelistedMaps !== null && !whitelistedMaps.includes(layer.map))
|
|
continue;
|
|
if (blacklistedMaps !== null && blacklistedMaps.includes(layer.map))
|
|
continue;
|
|
|
|
// Whitelist / Blacklist Gamemodes
|
|
if (
|
|
whitelistedGamemodes !== null &&
|
|
!whitelistedGamemodes.includes(layer.gamemode)
|
|
)
|
|
continue;
|
|
if (
|
|
blacklistedGamemodes !== null &&
|
|
blacklistedGamemodes.includes(layer.gamemode)
|
|
)
|
|
continue;
|
|
|
|
// Flag Count
|
|
if (flagCountMin !== null && layer.flagCount < flagCountMin) continue;
|
|
if (flagCountMax !== null && layer.flagCount > flagCountMax) continue;
|
|
|
|
// Other Properties
|
|
if (hasCommander !== null && layer.commander !== hasCommander) continue;
|
|
if (hasTanks !== null && (layer.tanks !== 'N/A') !== hasTanks) continue;
|
|
if (
|
|
hasHelicopters !== null &&
|
|
(layer.helicopters !== 'N/A') !== hasHelicopters
|
|
)
|
|
continue;
|
|
|
|
layers.push(layer);
|
|
}
|
|
|
|
return new SquadLayerFilter(layers, activeLayerFilter);
|
|
}
|
|
|
|
inLayerPool(layer) {
|
|
if (typeof layer === 'object') layer = layer.layer;
|
|
return super.getLayerNames().includes(layer);
|
|
}
|
|
|
|
isLayerHistoryCompliant(server, layer) {
|
|
if (this.activeLayerFilter === null) return true;
|
|
|
|
if (typeof layer === 'object') layer = layer.layer;
|
|
|
|
for (
|
|
let i = 0;
|
|
i <
|
|
Math.min(
|
|
server.layerHistory.length,
|
|
this.activeLayerFilter.layerHistoryTolerance
|
|
);
|
|
i++
|
|
) {
|
|
if (
|
|
new Date() - server.layerHistory[i].time >
|
|
this.activeLayerFilter.historyResetTime
|
|
)
|
|
return true;
|
|
if (server.layerHistory[i].layer === layer) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
isMapHistoryCompliant(server, layer) {
|
|
if (this.activeLayerFilter === null) return true;
|
|
|
|
if (typeof layer === 'string')
|
|
layer = SquadLayers.getLayerByLayerName(layer);
|
|
|
|
for (
|
|
let i = 0;
|
|
i <
|
|
Math.min(
|
|
server.layerHistory.length,
|
|
this.activeLayerFilter.mapHistoryTolerance
|
|
);
|
|
i++
|
|
) {
|
|
if (
|
|
new Date() - server.layerHistory[i].time >
|
|
this.activeLayerFilter.historyResetTime
|
|
)
|
|
return true;
|
|
if (server.layerHistory[i].map === layer.map) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
isGamemodeHistoryCompliant(server, layer) {
|
|
if (this.activeLayerFilter === null) return true;
|
|
|
|
if (typeof layer === 'string')
|
|
layer = SquadLayers.getLayerByLayerName(layer);
|
|
|
|
const gamemodeHistoryTolerance = this.activeLayerFilter
|
|
.gamemodeHistoryTolerance[layer.gamemode];
|
|
if (!gamemodeHistoryTolerance) return true;
|
|
|
|
for (
|
|
let i = 0;
|
|
i < Math.min(server.layerHistory.length, gamemodeHistoryTolerance);
|
|
i++
|
|
) {
|
|
if (
|
|
new Date() - server.layerHistory[i].time >
|
|
this.activeLayerFilter.historyResetTime
|
|
)
|
|
return true;
|
|
|
|
const historyLayer = SquadLayers.getLayerByLayerName(
|
|
server.layerHistory[i].layer
|
|
);
|
|
if (historyLayer && historyLayer.gamemode === layer.gamemode)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
isPlayerCountCompliant(server, layer) {
|
|
if (
|
|
this.activeLayerFilter === null ||
|
|
this.playerCountComplianceEnabled === false
|
|
)
|
|
return true;
|
|
|
|
if (typeof layer === 'string')
|
|
layer = SquadLayers.getLayerByLayerName(layer);
|
|
|
|
return !(
|
|
server.players.length > layer.estimatedSuitablePlayerCount.max ||
|
|
server.players.length < layer.estimatedSuitablePlayerCount.min
|
|
);
|
|
}
|
|
}
|