forked from Hri7566/mpp-server-dev2
770 lines
23 KiB
JavaScript
770 lines
23 KiB
JavaScript
const createKeccakHash = require('keccak');
|
|
const Crown = require('./Crown.js');
|
|
const Database = require('./Database.js');
|
|
const Logger = require('./Logger.js');
|
|
const Quota = require("./Quota.js");
|
|
const RoomSettings = require('./RoomSettings.js');
|
|
const ftc = require('fancy-text-converter');
|
|
const Notification = require('./Notification');
|
|
const Color = require('./Color');
|
|
const { getTimeColor } = require('./ColorEncoder.js');
|
|
const { InternalBot } = require('./InternalBot');
|
|
|
|
function ansiRegex({onlyFirst = false} = {}) {
|
|
const pattern = [
|
|
'[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
|
|
'(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))'
|
|
].join('|');
|
|
|
|
return new RegExp(pattern, onlyFirst ? undefined : 'g');
|
|
}
|
|
|
|
const LOGGER_PARTICIPANT = {
|
|
name: 'Logger',
|
|
color: '#72f1b8',
|
|
_id: 'logger',
|
|
id: 'logger'
|
|
}
|
|
|
|
const LOGGING_CHANNEL = 'lolwutsecretloggingchannel';
|
|
|
|
class Channel extends EventEmitter {
|
|
constructor(server, _id, settings, cl) {
|
|
super();
|
|
this.logger = new Logger(`Room - ${_id}`);
|
|
this._id = _id;
|
|
this.server = server;
|
|
this.crown;
|
|
this.crowndropped = false;
|
|
|
|
if (this.isLobby(this._id)) {
|
|
this.settings = new RoomSettings(this.server.lobbySettings);
|
|
// this.settings.lobby = true;
|
|
// this.settings.color = this.server.lobbySettings.color;
|
|
// this.settings.color2 = this.server.lobbySettings.color2;
|
|
} else {
|
|
this.settings = new RoomSettings(settings, 'user');
|
|
}
|
|
|
|
this.chatmsgs = [];
|
|
this.ppl = new Map();
|
|
this.connections = [];
|
|
this.bindEventListeners();
|
|
this.server.rooms.set(_id, this);
|
|
this.bans = new Map();
|
|
this.flags = {}
|
|
this.destroyed = false;
|
|
|
|
this.logger.log('Created');
|
|
|
|
if (this._id == LOGGING_CHANNEL) {
|
|
if (cl.user.hasFlag('admin')) {
|
|
delete this.crown;
|
|
|
|
Logger.buffer.forEach(str => {
|
|
this.chatmsgs.push({
|
|
m: 'a',
|
|
p: LOGGER_PARTICIPANT,
|
|
a: str.replace(ansiRegex(), '')
|
|
});
|
|
});
|
|
|
|
Logger.on('buffer update', (str) => {
|
|
this.chatmsgs.push({
|
|
m: 'a',
|
|
p: LOGGER_PARTICIPANT,
|
|
a: str.replace(ansiRegex(), '')
|
|
});
|
|
|
|
this.sendChatArray();
|
|
});
|
|
|
|
this.emit('update');
|
|
let c = new Color(LOGGER_PARTICIPANT.color);
|
|
c.add(-0x40, -0x40, -0x40);
|
|
this.settings = RoomSettings.changeSettings({
|
|
color: c.toHexa(),
|
|
chat: true,
|
|
crownsolo: true,
|
|
lobby: false,
|
|
owner_id: LOGGER_PARTICIPANT._id
|
|
}, true);
|
|
} else {
|
|
cl.setChannel('test/awkward');
|
|
}
|
|
} else {
|
|
Database.getRoomSettings(this._id, (err, set) => {
|
|
if (err) {
|
|
return;
|
|
}
|
|
|
|
this.settings = RoomSettings.changeSettings(this.settings, true);
|
|
this.chatmsgs = set.chat;
|
|
this.sendChatArray();
|
|
this.setData();
|
|
});
|
|
}
|
|
|
|
if (this.isLobby(this._id)) {
|
|
this.colorInterval = setInterval(() => {
|
|
this.setDefaultLobbyColorBasedOnDate();
|
|
}, 1000 * 60 * 5);
|
|
this.setDefaultLobbyColorBasedOnDate();
|
|
}
|
|
}
|
|
|
|
setChatArray(arr) {
|
|
this.chatmsgs = arr || [];
|
|
this.sendArray([{
|
|
m: 'c',
|
|
c: this.chatmsgs.slice(-1 * 32)
|
|
}]);
|
|
this.setData();
|
|
}
|
|
|
|
sendChatArray() {
|
|
this.connections.forEach(cl => {
|
|
cl.sendArray([{
|
|
m: 'c',
|
|
c: this.chatmsgs.slice(-1 * 32)
|
|
}]);
|
|
});
|
|
}
|
|
|
|
setDefaultLobbyColorBasedOnDate() {
|
|
let col = getTimeColor();
|
|
let col2 = new Color(col.r - 0x40, col.g - 0x40, col.b - 0x40);
|
|
|
|
this.settings.color = col.toHexa();
|
|
this.settings.color2 = col.toHexa();
|
|
|
|
for (let key in this.settings) {
|
|
this.server.lobbySettings[key] = this.settings[key];
|
|
}
|
|
|
|
this.emit('update');
|
|
}
|
|
|
|
join(cl, set) { //this stuff is complicated
|
|
let otheruser = this.connections.find((a) => a.user._id == cl.user._id)
|
|
if (!otheruser) {
|
|
// we don't exist yet
|
|
// create id hash
|
|
let participantId = createKeccakHash('keccak256').update((Math.random().toString() + cl.ip)).digest('hex').substr(0, 24);
|
|
|
|
// set id
|
|
cl.user.id = participantId;
|
|
cl.participantId = participantId;
|
|
|
|
// init quotas (TODO pass type of room in?)
|
|
cl.initParticipantQuotas();
|
|
|
|
// no users / already had crown? give crown
|
|
if (((this.connections.length == 0 && Array.from(this.ppl.values()).length == 0) && this.isLobby(this._id) == false) || this.crown && (this.crown.userId == cl.user._id || this.settings['owner_id'] == cl.user._id)) {
|
|
// user owns the room
|
|
// we need to switch the crown to them
|
|
//cl.quotas.a.setParams(Quota.PARAMS_A_CROWNED);
|
|
this.crown = new Crown(cl.participantId, cl.user._id);
|
|
|
|
this.crowndropped = false;
|
|
// this.settings = new RoomSettings(set, 'user');
|
|
} else {
|
|
//cl.quotas.a.setParams(Quota.PARAMS_A_NORMAL);
|
|
|
|
if (this.isLobby(this._id) && this.settings.lobby !== true) {
|
|
// fix lobby setting
|
|
this.settings.changeSettings({lobby: true});
|
|
// this.settings.visible = true;
|
|
// this.settings.crownsolo = false;
|
|
// this.settings.lobby = true;
|
|
// this.settings.color = this.server.lobbySettings.color;
|
|
// this.settings.color2 = this.server.lobbySettings.color2;
|
|
} else {
|
|
if (!this.isLobby) {
|
|
if (typeof(set) == 'undefined') {
|
|
if (typeof(this.settings) == 'undefined') {
|
|
this.settings = new RoomSettings(this.server.defaultRoomSettings, 'user');
|
|
} else {
|
|
this.settings = new RoomSettings(cl.channel.settings, 'user');
|
|
}
|
|
} else {
|
|
this.settings = new RoomSettings(set, 'user');
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
this.ppl.set(participantId, cl);
|
|
|
|
this.connections.push(cl);
|
|
|
|
cl.sendArray([{
|
|
m: "c",
|
|
c: this.chatmsgs.slice(-1 * 32)
|
|
}]);
|
|
|
|
// this.updateCh(cl, this.settings);
|
|
|
|
if (!cl.user.hasFlag("hidden", true)) {
|
|
this.sendArray([{
|
|
m: 'p',
|
|
_id: cl.user._id,
|
|
name: cl.user.name,
|
|
color: cl.user.color,
|
|
id: cl.participantId,
|
|
x: this.ppl.get(cl.participantId).x || 200,
|
|
y: this.ppl.get(cl.participantId).y || 100
|
|
}], cl, false);
|
|
}
|
|
|
|
this.updateCh(cl, this.settings);
|
|
} else {
|
|
cl.user.id = otheruser.participantId;
|
|
cl.participantId = otheruser.participantId;
|
|
cl.quotas = otheruser.quotas;
|
|
this.connections.push(cl);
|
|
cl.sendArray([{
|
|
m: "c",
|
|
c: this.chatmsgs.slice(-1 * 32)
|
|
}])
|
|
this.updateCh(cl, this.settings);
|
|
}
|
|
|
|
if (this.flags.spin == true) {
|
|
this.spin(cl);
|
|
}
|
|
}
|
|
|
|
spin(cl) { // speeeeeeen
|
|
let id = cl.user._id;
|
|
if (!id) id = "room";
|
|
this.Notification(id,
|
|
"",
|
|
``,
|
|
`<script>$("#piano").addClass("spin")</script>`,
|
|
1,
|
|
"#names",
|
|
"short"
|
|
);
|
|
}
|
|
|
|
stopSpin(cl) {
|
|
let id = cl.user._id;
|
|
if (!id) id = "room";
|
|
this.Notification(id,
|
|
"",
|
|
``,
|
|
`<script>$("#piano").removeClass("spin")</script>`,
|
|
1,
|
|
"#names",
|
|
"short"
|
|
);
|
|
}
|
|
|
|
remove(p) { // remove user
|
|
if (!p) return;
|
|
let otheruser = this.connections.filter((a) => a.user._id == p.user._id);
|
|
if (!(otheruser.length > 1)) {
|
|
this.ppl.delete(p.participantId);
|
|
this.connections.splice(this.connections.findIndex((a) => a.connectionid == p.connectionid), 1);
|
|
this.sendArray([{
|
|
m: "bye",
|
|
p: p.participantId
|
|
}], p, false);
|
|
if (this.crown)
|
|
if (this.crown.userId == p.user._id && !this.crowndropped) {
|
|
this.chown();
|
|
}
|
|
this.updateCh();
|
|
} else {
|
|
this.connections.splice(this.connections.findIndex((a) => a.connectionid == p.connectionid), 1);
|
|
}
|
|
|
|
}
|
|
|
|
updateCh(cl, set) { //update channel for all people in channel
|
|
if (Array.from(this.ppl.values()).length <= 0) {
|
|
setTimeout(() => {
|
|
this.destroy();
|
|
}, 13000);
|
|
}
|
|
|
|
this.connections.forEach((usr) => {
|
|
let u = this.fetchChannelData(usr, cl);
|
|
this.server.connections.get(usr.connectionid).sendArray([u]);
|
|
});
|
|
|
|
this.server.updateRoom(this.fetchChannelData());
|
|
}
|
|
|
|
updateParticipant(pid, options) {
|
|
let p;
|
|
|
|
Array.from(this.ppl).map(rpg => {
|
|
if (rpg[1].user._id == pid) p = rpg[1];
|
|
});
|
|
|
|
if (typeof(p) == 'undefined') return;
|
|
|
|
options.name ? p.user.name = options.name : {};
|
|
options._id ? p.user._id = options._id : {};
|
|
options.color ? p.user.color = options.color : {};
|
|
|
|
this.connections.filter((ofo) => ofo.participantId == p.participantId).forEach((usr) => {
|
|
options.name ? usr.user.name = options.name : {};
|
|
options._id ? usr.user._id = options._id : {};
|
|
options.color ? usr.user.color = options.color : {};
|
|
});
|
|
|
|
if (!p.hidden) {
|
|
this.sendArray([{
|
|
color: p.user.color,
|
|
id: p.participantId,
|
|
m: "p",
|
|
name: p.user.name,
|
|
x: p.x || 200,
|
|
y: p.y || 100,
|
|
_id: p.user._id
|
|
}]);
|
|
}
|
|
}
|
|
|
|
destroy() { //destroy room
|
|
if (this.destroyed) return;
|
|
if (this.ppl.size > 0) return;
|
|
if (this._id == "lobby") return;
|
|
this.destroyed = true;
|
|
this._id;
|
|
this.logger.log(`Deleted room ${this._id}`);
|
|
this.settings = undefined;
|
|
this.ppl;
|
|
this.connnections;
|
|
this.chatmsgs;
|
|
this.server.rooms.delete(this._id);
|
|
}
|
|
|
|
sendArray(arr, not, onlythisparticipant) {
|
|
this.connections.forEach((usr) => {
|
|
if (!not || (usr.participantId != not.participantId && !onlythisparticipant) || (usr.connectionid != not.connectionid && onlythisparticipant)) {
|
|
try {
|
|
let cl = this.server.connections.get(usr.connectionid);
|
|
if (!cl) return;
|
|
this.server.connections.get(usr.connectionid).sendArray(arr)
|
|
} catch (e) {
|
|
console.log(e);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
fetchChannelData(usr, cl) {
|
|
let chppl = [];
|
|
|
|
[...this.ppl.values()].forEach(c => {
|
|
if (cl) {
|
|
if (c.hidden == true && c.user._id !== cl.user._id) {
|
|
// client is hidden and we are that client
|
|
return;
|
|
} else if (c.user._id == cl.user._id) {
|
|
// let u = {
|
|
// _id: c.user._id,
|
|
// name: c.user.name + ' [HIDDEN]',
|
|
// color: c.user.color,
|
|
// id: c.participantId
|
|
// }
|
|
// chppl.push(u);
|
|
}
|
|
}
|
|
let u = {
|
|
_id: c.user._id,
|
|
name: c.user.name,
|
|
color: c.user.color,
|
|
id: c.participantId
|
|
}
|
|
chppl.push(u);
|
|
});
|
|
|
|
let data = {
|
|
m: "ch",
|
|
p: "ofo",
|
|
ch: {
|
|
count: chppl.length,
|
|
crown: this.crown,
|
|
settings: this.settings,
|
|
_id: this._id
|
|
},
|
|
ppl: chppl
|
|
}
|
|
|
|
if (cl) {
|
|
if (usr.connectionid == cl.connectionid) {
|
|
data.p = cl.participantId;
|
|
} else {
|
|
delete data.p;
|
|
}
|
|
} else {
|
|
delete data.p;
|
|
}
|
|
|
|
if (data.ch.crown == null) {
|
|
delete data.ch.crown;
|
|
} else {
|
|
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
verifyColor(strColor) {
|
|
var test2 = /^#[0-9A-F]{6}$/i.test(strColor);
|
|
if (test2 == true) {
|
|
return strColor;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
isLobby(_id) {
|
|
if (_id.startsWith("lobby")) {
|
|
if (_id == "lobby") {
|
|
return true;
|
|
}
|
|
|
|
let lobbynum = _id.split("lobby")[1];
|
|
if (!(parseInt(lobbynum).toString() == lobbynum)) return false;
|
|
|
|
for (let i in lobbynum) {
|
|
if (parseInt(lobbynum[i]) >= 0) {
|
|
if (parseInt(i) + 1 == lobbynum.length) return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
} else if (_id.startsWith("test/") || _id.toLowerCase().includes("grant")) {
|
|
if (_id == "test/") {
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
}
|
|
|
|
chown(id) {
|
|
let prsn = this.ppl.get(id);
|
|
if (prsn) {
|
|
this.crown = new Crown(id, prsn.user._id);
|
|
this.crowndropped = false;
|
|
} else {
|
|
if (this.crown) {
|
|
this.crown = new Crown(id, this.crown.userId);
|
|
this.crowndropped = true;
|
|
}
|
|
}
|
|
|
|
this.updateCh();
|
|
}
|
|
|
|
setCoords(p, x, y) {
|
|
if (p.participantId && this.ppl.get(p.participantId)) {
|
|
x ? this.ppl.get(p.participantId).x = x : {};
|
|
y ? this.ppl.get(p.participantId).y = y : {};
|
|
this.sendArray([{
|
|
m: "m",
|
|
id: p.participantId,
|
|
x: this.ppl.get(p.participantId).x,
|
|
y: this.ppl.get(p.participantId).y
|
|
}], p, false);
|
|
}
|
|
}
|
|
|
|
chat(p, msg) {
|
|
if (msg.message.length > 512) return;
|
|
|
|
let filter = ["AMIGHTYWIND", "CHECKLYHQ"];
|
|
let regexp = new RegExp("\\b(" + filter.join("|") + ")\\b", "i");
|
|
if (regexp.test(msg.message.split(' ').join(''))) return;
|
|
|
|
if (p.participantId == 0) {
|
|
let message = {};
|
|
|
|
message.m = "a";
|
|
message.t = Date.now();
|
|
message.a = msg.message;
|
|
|
|
message.p = {
|
|
color: "#ffffff",
|
|
id: "0",
|
|
name: "mpp",
|
|
_id: "0"
|
|
};
|
|
|
|
|
|
this.sendArray([message]);
|
|
|
|
this.chatmsgs.push(message);
|
|
this.setData();
|
|
return;
|
|
}
|
|
|
|
let prsn = this.ppl.get(p.participantId);
|
|
if (!prsn) return;
|
|
let message = {};
|
|
message.m = "a";
|
|
message.a = msg.message;
|
|
if (prsn.user.hasFlag('chat_curse_1')) {
|
|
if (prsn.user.flags['chat_curse_1'] != false) message.a = message.a.split(/[aeiou]/).join('o').split(/[AEIOU]/).join('O');
|
|
}
|
|
if (prsn.user.hasFlag('chat_curse_2')) {
|
|
|
|
}
|
|
message.p = {
|
|
color: p.user.color,
|
|
id: p.participantId,
|
|
name: p.user.name,
|
|
_id: p.user._id
|
|
};
|
|
|
|
message.t = Date.now();
|
|
|
|
this.sendArray([message]);
|
|
this.chatmsgs.push(message);
|
|
this.setData();
|
|
|
|
InternalBot.emit('receive message', message, prsn, this);
|
|
}
|
|
|
|
adminChat(str) {
|
|
this.chat({
|
|
participantId: 0
|
|
}, {
|
|
message: str
|
|
});
|
|
}
|
|
|
|
hasUser(id) {
|
|
return this.ppl.has(id);
|
|
}
|
|
|
|
playNote(cl, note) {
|
|
if (cl.user.hasFlag('mute', true)) {
|
|
return;
|
|
}
|
|
|
|
if (cl.user.hasFlag('mute')) {
|
|
if (Array.isArray(cl.user.flags['mute'])) {
|
|
if (cl.user.flags['mute'].includes(this._id)) return;
|
|
}
|
|
}
|
|
|
|
let vol;
|
|
|
|
if (cl.user.hasFlag('volume')) {
|
|
vol = Math.round(cl.user.flags["volume"]) / 100;
|
|
}
|
|
|
|
|
|
if (typeof vol == 'number') {
|
|
for (let no of note.n) {
|
|
if (no.v) {
|
|
if (vol == 0) {
|
|
no.v = vol;
|
|
} else {
|
|
no.v *= vol;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
this.sendArray([{
|
|
m: "n",
|
|
n: note.n,
|
|
p: cl.participantId,
|
|
t: note.t
|
|
}], cl, true);
|
|
}
|
|
|
|
kickban(_id, ms) {
|
|
ms = parseInt(ms);
|
|
|
|
if (ms >= (1000 * 60 * 60)) return;
|
|
if (ms < 0) return;
|
|
|
|
ms = Math.round(ms / 1000) * 1000;
|
|
|
|
let user = this.connections.find((usr) => usr.user._id == _id);
|
|
if (!user) return;
|
|
let asd = true;
|
|
let pthatbanned = this.ppl.get(this.crown.participantId);
|
|
|
|
this.connections.filter((usr) => usr.participantId == user.participantId).forEach((u) => {
|
|
user.bantime = Math.floor(Math.floor(ms / 1000) / 60);
|
|
user.bannedtime = Date.now();
|
|
user.msbanned = ms;
|
|
|
|
this.bans.set(user.user._id, user);
|
|
|
|
//if (this.crown && (this.crown.userId)) {
|
|
u.setChannel("test/awkward", {});
|
|
|
|
if (asd)
|
|
this.Notification(user.user._id,
|
|
"Notice",
|
|
`Banned from \"${this._id}\" for ${Math.floor(Math.floor(ms / 1000) / 60)} minutes.`,
|
|
"",
|
|
7000,
|
|
"#room",
|
|
"short"
|
|
)
|
|
if (asd)
|
|
this.Notification("room",
|
|
"Notice",
|
|
`${pthatbanned.user.name} banned ${user.user.name} from the channel for ${Math.floor(Math.floor(ms / 1000) / 60)} minutes.`,
|
|
"",
|
|
7000,
|
|
"#room",
|
|
"short"
|
|
)
|
|
if (this.crown && (this.crown.userId == _id)) {
|
|
this.Notification("room",
|
|
"Certificate of Award",
|
|
`Let it be known that ${user.user.name} kickbanned him/her self.`,
|
|
"",
|
|
7000,
|
|
"#room"
|
|
);
|
|
}
|
|
//}
|
|
|
|
})
|
|
}
|
|
|
|
unban(_id) {
|
|
this.connections.filter((usr) => usr.participantId == user.participantId).forEach(u => {
|
|
if (user.bantime) {
|
|
delete user.bantime;
|
|
}
|
|
|
|
if (user.bannedtime) {
|
|
delete user.bannedtime;
|
|
}
|
|
|
|
this.bans.delete(user.user._id);
|
|
});
|
|
}
|
|
|
|
Notification(who, title, text, html, duration, target, klass, id) {
|
|
new Notification({
|
|
id: id,
|
|
chat: undefined,
|
|
refresh: undefined,
|
|
title: title,
|
|
text: text,
|
|
html: html,
|
|
duration: duration,
|
|
target: target,
|
|
class: klass
|
|
}).send(who, this);
|
|
}
|
|
|
|
bindEventListeners() {
|
|
this.on("bye", participant => {
|
|
this.remove(participant);
|
|
});
|
|
|
|
this.on("m", msg => {
|
|
let p = this.ppl.get(msg.p);
|
|
if (!p) return;
|
|
this.setCoords(p, msg.x, msg.y);
|
|
});
|
|
|
|
this.on("a", (participant, msg) => {
|
|
this.chat(participant, msg);
|
|
});
|
|
|
|
this.on("update", (cl, set) => {
|
|
this.updateCh(cl, set);
|
|
});
|
|
|
|
this.on("remove crown", () => {
|
|
this.crown = undefined;
|
|
delete this.crown;
|
|
this.emit('update');
|
|
});
|
|
|
|
this.on("flag spin", spin => {
|
|
if (spin) {
|
|
for (let cl of this.connections) {
|
|
this.spin(cl);
|
|
}
|
|
} else {
|
|
for (let cl of this.connections) {
|
|
this.stopSpin(cl);
|
|
}
|
|
}
|
|
});
|
|
|
|
this.on("flag among us", amongus => {
|
|
if (amongus) {
|
|
this.startAmongUs();
|
|
} else {
|
|
this.stopAmongUs();
|
|
}
|
|
});
|
|
}
|
|
|
|
verifySet(_id, msg) {
|
|
if(typeof(msg.set) !== 'object') {
|
|
msg.set = {
|
|
visible: true,
|
|
color: this.server.defaultSettings.color, chat:true,
|
|
crownsolo:false
|
|
}
|
|
}
|
|
|
|
msg.set = RoomSettings.changeSettings(msg.set);
|
|
|
|
if (typeof(msg.set.lobby) !== 'undefined') {
|
|
if (msg.set.lobby == true) {
|
|
if (!this.isLobby(_id)) delete msg.set.lobby; // keep it nice and clean
|
|
} else {
|
|
if (this.isLobby(_id)) {
|
|
msg.set = this.server.lobbySettings;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
setData() {
|
|
Database.setRoomSettings(this._id, this.settings, this.chatmsgs);
|
|
}
|
|
|
|
hasFlag(flag, val) {
|
|
if (!val) return this.flags.hasOwnProperty(flag);
|
|
return this.flags.hasOwnProperty(flag) && this.flags[flag] == val;
|
|
}
|
|
|
|
async startAmongUs() {
|
|
if (!this.amongus) {
|
|
this.amongus = {}
|
|
}
|
|
|
|
if (this.amongus.started) return;
|
|
|
|
if (!this.amongus.started) {
|
|
this.amongus.started = true;
|
|
}
|
|
|
|
let imposter = this.connections[Math.floor(Math.random() * this.connections.length)];
|
|
imposter.user.setFlag("freeze_name", true);
|
|
}
|
|
|
|
stopAmongUs() {
|
|
this.amongus.started = false;
|
|
}
|
|
}
|
|
|
|
module.exports = Channel;
|