416 lines
No EOL
16 KiB
JavaScript
416 lines
No EOL
16 KiB
JavaScript
const path = require('path')
|
|
const { Command } = require(path.join(__dirname, `../Lib/Classes.js`))
|
|
const Localization = require(path.join(__dirname, `../Configuration/Localization-${process.env.LOCALE}.json`)).lookup
|
|
const Games = require(path.join(__dirname, `../Configuration/Localization-${process.env.LOCALE}.json`)).Games
|
|
const config = require(path.join(__dirname, `../Configuration/NSMConfiguration.json`))
|
|
const Utils = new (require(path.join(__dirname, '../Utils/Utils.js')))()
|
|
const mathjs = require('mathjs')
|
|
const wait = require('delay')
|
|
|
|
class Plugin {
|
|
constructor(Server, Manager, Managers) {
|
|
this.Server = Server
|
|
this.Manager = Manager
|
|
this.Managers = Managers
|
|
this.init()
|
|
}
|
|
init() {
|
|
(() => {
|
|
let command = new Command()
|
|
.setName('calculator')
|
|
.setAlias('calc')
|
|
.addParam({
|
|
index: 0,
|
|
name: 'expression',
|
|
join: true
|
|
})
|
|
.addCallback(async (Player, params, args, options, funcs) => {
|
|
try {
|
|
var result = mathjs.evaluate(params.expression)
|
|
result ? funcs.Tell( Utils.formatString(Localization['COMMAND_CALC_RESULT'], { result: result.toString() }, '%')[0] ) : funcs.Tell(Utils.formatString(Localization['COMMAND_CALC_RESULT'], { result: Localization['COMMAND_CALC_FAIL'] }, '%')[0])
|
|
}
|
|
catch (e) {
|
|
funcs.Tell(Utils.formatString(Localization['COMMAND_CALC_RESULT'], { result: Localization['COMMAND_CALC_FAIL'] }, '%')[0])
|
|
}
|
|
})
|
|
|
|
this.Manager.Commands.add(command)
|
|
})(this);
|
|
|
|
(() => {
|
|
let command = new Command()
|
|
.setName('toggle')
|
|
.setAlias('t')
|
|
.addParam({
|
|
index: 0,
|
|
name: 'setting'
|
|
})
|
|
.addCallback(async (Player, params, args, options, funcs) => {
|
|
let settingsMeta = ['location']
|
|
if (!settingsMeta.includes(params.setting.toLocaleLowerCase())) {
|
|
Player.Tell(Localization['SETTING_NOT_EXIST'])
|
|
return
|
|
}
|
|
|
|
var setting = await this.Server.DB.metaService.getPersistentMeta(params.setting, Player.ClientId)
|
|
|
|
this.Server.DB.metaService.addPersistentMeta(params.setting.toLocaleLowerCase(), !(setting && setting.Value == '1'), Player.ClientId)
|
|
|
|
switch (params.setting.toLocaleLowerCase()) {
|
|
case 'location':
|
|
Player.Tell(Utils.formatString(Localization['SETTING_TOGGLE_FORMAT'], {setting: Utils.capitalizeFirstLetter(params.setting), value: !(setting && setting.Value == '1') ? '^1hidden' : '^2shown'}, '%')[0])
|
|
break
|
|
}
|
|
})
|
|
|
|
this.Manager.Commands.add(command)
|
|
})(this);
|
|
|
|
(() => {
|
|
let command = new Command({
|
|
isMiddleware: true
|
|
})
|
|
.addCallback(async (Player, params, args, options, funcs, next) => {
|
|
if (!config.socialMedia) {
|
|
next()
|
|
return
|
|
}
|
|
|
|
var sc = config.socialMedia.find((a) => a[0].toLocaleLowerCase() == args[0].toLocaleLowerCase())
|
|
|
|
if (!sc) {
|
|
next()
|
|
return
|
|
}
|
|
|
|
funcs.Tell(Utils.formatString(Localization['COMMAND_LINKS_FORMAT'], {name: sc[0], url: sc[1]}, '%')[0])
|
|
})
|
|
|
|
this.Manager.Commands.add(command)
|
|
})(this);
|
|
|
|
(() => {
|
|
let command = new Command({
|
|
name: 'reports',
|
|
alias: 'reps',
|
|
permission: 'ROLE_MODERATOR'
|
|
})
|
|
.addParam({
|
|
index: 0,
|
|
name: 'page',
|
|
optional: true
|
|
})
|
|
.setPermission('ROLE_MODERATOR')
|
|
.addCallback(async (Player, params, args, options, funcs) => {
|
|
if (params.page == 'clear') {
|
|
this.Server.DB.clearReports()
|
|
Player.Tell(Localization['COMMAND_REPORTS_CLEAR'])
|
|
return
|
|
}
|
|
|
|
var Reports = Utils.chunkArray(await this.Server.DB.getActiveReports(), Player.inGame ? 4 : 15)
|
|
|
|
if (!Reports.length) {
|
|
Player.Tell(Localization['COMMAND_NO_RESULT'])
|
|
return
|
|
}
|
|
|
|
var page = params.page ? Math.max(1, Math.min(parseInt(params.page), Reports.length)) : 1
|
|
|
|
await Player.Tell(Utils.formatString(Localization['COMMAND_LIST_PAGE'], {max: Reports.length, current: page}, '%')[0])
|
|
Player.inGame && await wait(300)
|
|
|
|
for (var i = 0; i < Reports[page - 1].length; i++) {
|
|
var TargetName = await this.Server.DB.getName(Reports[page - 1][i].TargetId)
|
|
var OriginName = await this.Server.DB.getName(Reports[page - 1][i].OriginId)
|
|
|
|
Player.Tell(Utils.formatString(Localization['COMMAND_REPORTS_TELL'], {Origin: OriginName, Target: TargetName, Reason: Reports[page - 1][i].Reason}, '%')[0])
|
|
|
|
Player.inGame && await wait(300)
|
|
}
|
|
|
|
})
|
|
|
|
this.Manager.Commands.add(command)
|
|
})(this);
|
|
|
|
(() => {
|
|
let command = new Command()
|
|
.setName('report')
|
|
.setAlias('rep')
|
|
.setInGame(true)
|
|
/* .addParams([
|
|
{
|
|
index: 0,
|
|
name: 'target'
|
|
},
|
|
{
|
|
index: 1,
|
|
name: 'reason',
|
|
join: true
|
|
}
|
|
])*/
|
|
.addException(Utils.formatString(Localization['COMMAND_REPORT_COOLDOWN'], {time: 5}, '%')[0], (Player) => {
|
|
return !Player.Data.lastReport || (new Date() - Player.Data.lastReport) / 1000 > 300
|
|
})
|
|
.addCallback( async (Player, params, args, options, funcs) => {
|
|
|
|
Player.Tell("To ^1report^7, take ^3video/photo evidences^7 & create a ^6Discord ^2Ticket^7.")
|
|
return
|
|
|
|
var Client = await this.Server.getClient(params.target)
|
|
|
|
|
|
if (!Client) {
|
|
Player.Tell(Localization['COMMAND_CLIENT_NOT_FOUND'])
|
|
return
|
|
}
|
|
|
|
this.Server.DB.addReport(Player.ClientId, Client.ClientId, params.reason)
|
|
|
|
Player.Data.lastReport = new Date()
|
|
Player.Tell(Localization['COMMAND_REPORT_SUCCESS'])
|
|
|
|
this.Server.emit('report', Player, Client, params.reason)
|
|
|
|
this.Server.tellStaffGlobal(Utils.formatString(Localization['COMMAND_REPORT_TELL'], {Origin: Player.Name, Hostname: Player.Server.HostnameRaw,Target: Client.Name, Reason: params.reason}, '%')[0])
|
|
})
|
|
|
|
this.Manager.Commands.add(command)
|
|
})(this);
|
|
|
|
(() => {
|
|
let command = new Command()
|
|
.setName('staff')
|
|
.addCallback(async (Player, params, args, options, funcs) => {
|
|
var staff = []
|
|
this.Managers.forEach(Manager => {
|
|
staff = staff.concat(Manager.Server.getStaffMembers())
|
|
})
|
|
if (!staff.length) {
|
|
funcs.Tell(Localization['COMMAND_STAFF_NO_RESULT'])
|
|
return
|
|
}
|
|
for (var i = 0; i < staff.length; i++) {
|
|
funcs.Tell(Utils.formatString(Localization['COMMAND_STAFF_FORMAT'], {
|
|
Name: staff[i].Name,
|
|
Level: staff[i].PermissionLevel,
|
|
Role: Utils.getRoleFrom(staff[i].PermissionLevel, 1).Name,
|
|
ClientId: staff[i].ClientId,
|
|
Hostname: staff[i].Server.HostnameRaw
|
|
}, '%')[0])
|
|
Player.inGame && await wait(500)
|
|
}
|
|
})
|
|
|
|
this.Manager.Commands.add(command)
|
|
})(this);
|
|
|
|
(() => {
|
|
let command = new Command()
|
|
.setName('eval')
|
|
.addParam({
|
|
index: 0,
|
|
name: 'js',
|
|
join: true
|
|
})
|
|
.setPermission('ROLE_OWNER')
|
|
.addCallback(async (Player, params, args, options, funcs) => {
|
|
try {
|
|
console.log(params.js)
|
|
eval(params.js)
|
|
}
|
|
catch (e) {
|
|
Player.Tell(e.toString())
|
|
}
|
|
})
|
|
|
|
if (process.env.NODE_ENV == 'dev')
|
|
this.Manager.Commands.add(command)
|
|
})(this);
|
|
|
|
(() => {
|
|
let command = new Command()
|
|
.setName('stats')
|
|
.addParam({
|
|
index: 0,
|
|
name: 'client',
|
|
join: true,
|
|
optional: true
|
|
})
|
|
.addCallback(async (Player, params, args, options, funcs) => {
|
|
var Target = !params.client ? Player : await this.Server.getClient(params.client)
|
|
|
|
if (!Target) {
|
|
Player.Tell(Localization.COMMAND_CLIENT_NOT_FOUND)
|
|
return
|
|
}
|
|
|
|
var ClientId = Target.ClientId
|
|
var Stats = await this.Server.DB.getPlayerStatsTotal(ClientId)
|
|
var Client = await this.Server.DB.getClient(ClientId)
|
|
if (Stats)
|
|
funcs.Tell(Localization.COMMAND_STATS_FORMAT
|
|
.replace('%PLAYEDTIME%', Utils.time2str(Stats.PlayedTime * 60))
|
|
.replace('%PERFORMANCE%', Stats.Performance.toFixed(2))
|
|
.replace('%NAME%', Client.Name)
|
|
.replace('%KILLS%', Stats.Kills)
|
|
.replace('%DEATHS%', Stats.Deaths)
|
|
.replace('%KDR%',(Stats.Kills / Math.max(Stats.Deaths, 1)).toFixed(2)))
|
|
else funcs.Tell(Localization.COMMAND_CLIENT_NOT_FOUND)
|
|
})
|
|
|
|
this.Manager.Commands.add(command)
|
|
})(this);
|
|
|
|
(() => {
|
|
let command = new Command()
|
|
.setName('uptime')
|
|
.setAlias('ut')
|
|
.setInGame(true)
|
|
.addCallback(async (Player, params, args, options, funcs) => {
|
|
funcs.Tell(Utils.formatString(Localization['COMMAND_UPTIME_FORMAT'], {uptime: Utils.time2str(this.Server.uptime)}, '%')[0])
|
|
})
|
|
|
|
this.Manager.Commands.add(command)
|
|
})(this);
|
|
|
|
(() => {
|
|
let command = new Command()
|
|
.setName('status')
|
|
.addCallback(async (Player, params, args, options, funcs) => {
|
|
funcs.Tell(Utils.formatString(Localization['COMMAND_SUMMARY_FORMAT'], {
|
|
totalClients: await this.Server.DB.getAllClients(),
|
|
totalServers: this.Managers.filter(m => m.Server.Rcon.isRunning).length,
|
|
clientsToday: (await this.Server.DB.getLastConnections()).length,
|
|
uniqueToday: (await this.Server.DB.getLastUniques()).length,
|
|
onlineClients: this.Managers.reduce((a, {Server}) => a + Server.getClients().length, 0),
|
|
totalSlots: this.Managers.reduce((a, {Server}) => a + Server.Clients.length, 0)
|
|
}, '%')[0])
|
|
})
|
|
|
|
this.Manager.Commands.add(command)
|
|
})(this);
|
|
|
|
(() => {
|
|
let command = new Command()
|
|
.setName('rotation')
|
|
.setAlias('rr')
|
|
.setInGame(true)
|
|
.addCallback(async (Player, params, args, options, funcs) => {
|
|
var buffer = ""
|
|
|
|
this.Server.mapRotation.forEach((map, i) => {
|
|
buffer += Utils.va("%s%s%s",
|
|
map == this.Server.Mapname ? '^3' : '^5',
|
|
this.Server.getMap(map) ? this.Server.getMap(map).Alias : map,
|
|
i < this.Server.mapRotation.length - 1 ? '^7, ' : ''
|
|
)
|
|
})
|
|
|
|
funcs.Tell(buffer)
|
|
})
|
|
|
|
this.Manager.Commands.add(command)
|
|
})(this);
|
|
|
|
(() => {
|
|
let command = new Command()
|
|
.setName('chat')
|
|
.setInGame(true)
|
|
.addParam({
|
|
name: 'server',
|
|
optional: true,
|
|
join: true
|
|
})
|
|
.addCallback(async (Player, params) => {
|
|
if (!params.server) {
|
|
if (Player.Session.Data.serverChat) {
|
|
Player.Session.Data.serverChat.Broadcast(Utils.formatString(Localization['SERVERCHAT_DISCONNECTED'], {
|
|
Name: Player.Name
|
|
}, '%')[0])
|
|
}
|
|
|
|
Player.Session.Data.serverChat = undefined
|
|
Player.Tell(Localization['SERVERCHAT_DISABLED'])
|
|
return
|
|
}
|
|
|
|
var Manager = this.Managers.find(Manager => Utils.cleanIncludes(Manager.Server.Hostname, params.server))
|
|
|
|
if (!Manager) {
|
|
Player.Tell(Localization['SERVER_NOT_FOUND'])
|
|
return
|
|
}
|
|
|
|
if (Player.Session.Data.serverChat && Player.Session.Data.serverChat.Id != Manager.Server.Id) {
|
|
Player.Session.Data.serverChat.Broadcast(Utils.formatString(Localization['SERVERCHAT_DISCONNECTED'], {
|
|
Name: Player.Name
|
|
}, '%')[0])
|
|
}
|
|
|
|
Player.Session.Data.serverChat = Manager.Server
|
|
|
|
Manager.Server.Broadcast(Utils.formatString(Localization['SERVERCHAT_CONNECTED'], {
|
|
Name: Player.Name
|
|
}, '%')[0])
|
|
|
|
Player.Tell(Utils.formatString(Localization['SERVERCHAT_ENABLED'], {
|
|
Hostname: Manager.Server.Hostname
|
|
}, '%')[0])
|
|
})
|
|
|
|
this.Manager.Commands.add(command)
|
|
})(this);
|
|
|
|
(() => {
|
|
let command = new Command()
|
|
.setName('rules')
|
|
.addParam({
|
|
name: 'page',
|
|
optional: true
|
|
})
|
|
.addCallback(async (Player, params) => {
|
|
if (!this.Server.config.rules) {
|
|
Player.Tell(Localization['COMMAND_RULES_UNDEFINED'])
|
|
return
|
|
}
|
|
|
|
const size = Player.inGame ? 4 : 15
|
|
const chunkedRules = Utils.chunkArray(this.Server.config.rules, size)
|
|
|
|
const page = Math.max(0, Math.min(params.page ? parseInt(params.page) - 1 : 0, chunkedRules.length))
|
|
const rules = chunkedRules[page]
|
|
|
|
Player.Tell(Utils.formatString(Localization['COMMAND_LIST_PAGE'], {
|
|
current: page + 1,
|
|
max: chunkedRules.length
|
|
}, '%')[0])
|
|
|
|
Player.inGame && await wait(300)
|
|
|
|
for (var i = 0; i < rules.length; i++) {
|
|
Player.Tell(Utils.va(Localization['COMMAND_RULES_FORMAT'], size * page + i + 1, rules[i]))
|
|
|
|
Player.inGame && await wait(500)
|
|
}
|
|
})
|
|
|
|
this.Manager.Commands.add(command)
|
|
})(this);
|
|
|
|
(() => {
|
|
let command = new Command()
|
|
.setName('resetstats')
|
|
.setAlias('rs')
|
|
.addCallback(async (Player, params, args, options, funcs) => {
|
|
await this.Server.DB.resetStats(Player.ClientId)
|
|
funcs.Tell(Localization['COMMAND_RESETSTATS_RESET'])
|
|
})
|
|
|
|
this.Manager.Commands.add(command)
|
|
})(this);
|
|
}
|
|
}
|
|
|
|
module.exports = Plugin |