2020-04-07 10:08:04 +02:00
|
|
|
import {PointInterface} from "./Websocket/PointInterface";
|
|
|
|
import {Group} from "./Group";
|
2020-11-13 18:00:22 +01:00
|
|
|
import {User, UserSocket} from "./User";
|
2020-04-29 22:41:48 +02:00
|
|
|
import {PositionInterface} from "_Model/PositionInterface";
|
2020-10-06 15:37:00 +02:00
|
|
|
import {EntersCallback, LeavesCallback, MovesCallback} from "_Model/Zone";
|
2020-09-15 16:21:41 +02:00
|
|
|
import {PositionNotifier} from "./PositionNotifier";
|
2020-09-16 16:06:43 +02:00
|
|
|
import {Movable} from "_Model/Movable";
|
2020-10-14 16:00:25 +02:00
|
|
|
import {extractDataFromPrivateRoomId, extractRoomSlugPublicRoomId, isRoomAnonymous} from "./RoomIdentifier";
|
|
|
|
import {arrayIntersect} from "../Services/ArrayHelper";
|
2020-11-13 18:00:22 +01:00
|
|
|
import {JoinRoomMessage} from "../Messages/generated/messages_pb";
|
|
|
|
import {ProtobufUtils} from "../Model/Websocket/ProtobufUtils";
|
2020-12-10 17:46:15 +01:00
|
|
|
import {ZoneSocket} from "src/RoomManager";
|
|
|
|
import {Admin} from "../Model/Admin";
|
2020-04-07 10:08:04 +02:00
|
|
|
|
2020-09-29 16:01:22 +02:00
|
|
|
export type ConnectCallback = (user: User, group: Group) => void;
|
|
|
|
export type DisconnectCallback = (user: User, group: Group) => void;
|
2020-05-03 16:08:04 +02:00
|
|
|
|
2020-10-14 16:00:25 +02:00
|
|
|
export enum GameRoomPolicyTypes {
|
2020-12-11 12:23:50 +01:00
|
|
|
ANONYMOUS_POLICY = 1,
|
2020-10-14 16:00:25 +02:00
|
|
|
MEMBERS_ONLY_POLICY,
|
|
|
|
USE_TAGS_POLICY,
|
|
|
|
}
|
|
|
|
|
2020-10-06 15:37:00 +02:00
|
|
|
export class GameRoom {
|
2020-05-14 23:19:48 +02:00
|
|
|
private readonly minDistance: number;
|
|
|
|
private readonly groupRadius: number;
|
2020-04-08 20:40:44 +02:00
|
|
|
|
2020-04-07 10:08:04 +02:00
|
|
|
// Users, sorted by ID
|
2020-09-18 13:57:38 +02:00
|
|
|
private readonly users: Map<number, User>;
|
2020-12-11 12:23:50 +01:00
|
|
|
private readonly usersByUuid: Map<string, User>;
|
2020-06-29 22:13:07 +02:00
|
|
|
private readonly groups: Set<Group>;
|
2020-12-10 17:46:15 +01:00
|
|
|
private readonly admins: Set<Admin>;
|
2020-04-08 20:40:44 +02:00
|
|
|
|
2020-05-14 23:19:48 +02:00
|
|
|
private readonly connectCallback: ConnectCallback;
|
|
|
|
private readonly disconnectCallback: DisconnectCallback;
|
2020-04-07 10:08:04 +02:00
|
|
|
|
2020-07-27 22:36:07 +02:00
|
|
|
private itemsState: Map<number, unknown> = new Map<number, unknown>();
|
|
|
|
|
2020-09-15 16:21:41 +02:00
|
|
|
private readonly positionNotifier: PositionNotifier;
|
2020-10-14 16:00:25 +02:00
|
|
|
public readonly roomId: string;
|
|
|
|
public readonly roomSlug: string;
|
|
|
|
public readonly worldSlug: string = '';
|
|
|
|
public readonly organizationSlug: string = '';
|
2021-04-01 16:43:12 +02:00
|
|
|
private versionNumber:number = 1;
|
2020-11-13 18:00:22 +01:00
|
|
|
private nextUserId: number = 1;
|
2020-10-14 16:00:25 +02:00
|
|
|
|
|
|
|
constructor(roomId: string,
|
|
|
|
connectCallback: ConnectCallback,
|
2020-05-03 17:47:54 +02:00
|
|
|
disconnectCallback: DisconnectCallback,
|
2020-05-03 16:56:19 +02:00
|
|
|
minDistance: number,
|
2020-05-08 00:35:36 +02:00
|
|
|
groupRadius: number,
|
2020-09-16 16:06:43 +02:00
|
|
|
onEnters: EntersCallback,
|
|
|
|
onMoves: MovesCallback,
|
|
|
|
onLeaves: LeavesCallback)
|
2020-04-07 10:08:04 +02:00
|
|
|
{
|
2020-10-14 16:00:25 +02:00
|
|
|
this.roomId = roomId;
|
2020-10-22 16:15:30 +02:00
|
|
|
|
2021-04-01 16:43:12 +02:00
|
|
|
if (isRoomAnonymous(roomId)) {
|
2020-10-14 16:00:25 +02:00
|
|
|
this.roomSlug = extractRoomSlugPublicRoomId(this.roomId);
|
|
|
|
} else {
|
|
|
|
const {organizationSlug, worldSlug, roomSlug} = extractDataFromPrivateRoomId(this.roomId);
|
|
|
|
this.roomSlug = roomSlug;
|
|
|
|
this.organizationSlug = organizationSlug;
|
|
|
|
this.worldSlug = worldSlug;
|
|
|
|
}
|
2020-10-22 16:15:30 +02:00
|
|
|
|
|
|
|
|
2020-09-18 13:57:38 +02:00
|
|
|
this.users = new Map<number, User>();
|
2020-12-11 12:23:50 +01:00
|
|
|
this.usersByUuid = new Map<string, User>();
|
2020-12-10 17:46:15 +01:00
|
|
|
this.admins = new Set<Admin>();
|
2020-06-29 22:13:07 +02:00
|
|
|
this.groups = new Set<Group>();
|
2020-04-07 10:08:04 +02:00
|
|
|
this.connectCallback = connectCallback;
|
|
|
|
this.disconnectCallback = disconnectCallback;
|
2020-05-03 16:56:19 +02:00
|
|
|
this.minDistance = minDistance;
|
|
|
|
this.groupRadius = groupRadius;
|
2020-09-15 16:21:41 +02:00
|
|
|
// A zone is 10 sprites wide.
|
2020-09-16 16:06:43 +02:00
|
|
|
this.positionNotifier = new PositionNotifier(320, 320, onEnters, onMoves, onLeaves);
|
2020-04-28 23:23:50 +02:00
|
|
|
}
|
2020-04-07 10:08:04 +02:00
|
|
|
|
2020-05-13 23:11:10 +02:00
|
|
|
public getGroups(): Group[] {
|
2020-06-29 22:10:23 +02:00
|
|
|
return Array.from(this.groups.values());
|
2020-05-13 23:11:10 +02:00
|
|
|
}
|
|
|
|
|
2020-09-18 13:57:38 +02:00
|
|
|
public getUsers(): Map<number, User> {
|
2020-05-19 19:11:12 +02:00
|
|
|
return this.users;
|
|
|
|
}
|
|
|
|
|
2020-12-11 12:23:50 +01:00
|
|
|
public getUserByUuid(uuid: string): User|undefined {
|
|
|
|
return this.usersByUuid.get(uuid);
|
|
|
|
}
|
|
|
|
|
2020-11-13 18:00:22 +01:00
|
|
|
public join(socket : UserSocket, joinRoomMessage: JoinRoomMessage): User {
|
|
|
|
const positionMessage = joinRoomMessage.getPositionmessage();
|
|
|
|
if (positionMessage === undefined) {
|
|
|
|
throw new Error('Missing position message');
|
|
|
|
}
|
|
|
|
const position = ProtobufUtils.toPointInterface(positionMessage);
|
|
|
|
|
2021-01-15 03:19:58 +01:00
|
|
|
const user = new User(this.nextUserId,
|
|
|
|
joinRoomMessage.getUseruuid(),
|
|
|
|
joinRoomMessage.getIpaddress(),
|
|
|
|
position,
|
|
|
|
false,
|
|
|
|
this.positionNotifier,
|
|
|
|
socket,
|
|
|
|
joinRoomMessage.getTagList(),
|
|
|
|
joinRoomMessage.getName(),
|
2021-04-02 21:21:11 +02:00
|
|
|
ProtobufUtils.toCharacterLayerObjects(joinRoomMessage.getCharacterlayerList()),
|
|
|
|
joinRoomMessage.getCompanion()
|
2021-01-15 03:19:58 +01:00
|
|
|
);
|
2020-11-13 18:00:22 +01:00
|
|
|
this.nextUserId++;
|
|
|
|
this.users.set(user.id, user);
|
2020-12-11 12:23:50 +01:00
|
|
|
this.usersByUuid.set(user.uuid, user);
|
2020-09-25 15:25:06 +02:00
|
|
|
this.updateUserGroup(user);
|
2020-12-10 17:46:15 +01:00
|
|
|
|
|
|
|
// Notify admins
|
|
|
|
for (const admin of this.admins) {
|
2021-01-15 03:19:58 +01:00
|
|
|
admin.sendUserJoin(user.uuid, user.name, user.IPAddress);
|
2020-12-10 17:46:15 +01:00
|
|
|
}
|
|
|
|
|
2020-11-13 18:00:22 +01:00
|
|
|
return user;
|
2020-04-07 10:08:04 +02:00
|
|
|
}
|
|
|
|
|
2020-11-13 18:00:22 +01:00
|
|
|
public leave(user : User){
|
|
|
|
const userObj = this.users.get(user.id);
|
2020-05-14 23:19:48 +02:00
|
|
|
if (userObj === undefined) {
|
2020-11-13 18:00:22 +01:00
|
|
|
console.warn('User ', user.id, 'does not belong to this game room! It should!');
|
2020-05-14 23:19:48 +02:00
|
|
|
}
|
2020-04-29 23:18:42 +02:00
|
|
|
if (userObj !== undefined && typeof userObj.group !== 'undefined') {
|
2020-05-14 23:19:48 +02:00
|
|
|
this.leaveGroup(userObj);
|
2020-04-29 23:18:42 +02:00
|
|
|
}
|
2020-11-13 18:00:22 +01:00
|
|
|
this.users.delete(user.id);
|
2020-12-11 12:23:50 +01:00
|
|
|
this.usersByUuid.delete(user.uuid);
|
2020-09-15 16:21:41 +02:00
|
|
|
|
|
|
|
if (userObj !== undefined) {
|
2020-09-28 18:52:54 +02:00
|
|
|
this.positionNotifier.leave(userObj);
|
2020-09-15 16:21:41 +02:00
|
|
|
}
|
2020-12-10 17:46:15 +01:00
|
|
|
|
|
|
|
// Notify admins
|
|
|
|
for (const admin of this.admins) {
|
2021-01-18 15:07:40 +01:00
|
|
|
admin.sendUserLeft(user.uuid/*, user.name, user.IPAddress*/);
|
2020-12-10 17:46:15 +01:00
|
|
|
}
|
2020-04-29 01:40:32 +02:00
|
|
|
}
|
|
|
|
|
2020-06-29 19:14:54 +02:00
|
|
|
public isEmpty(): boolean {
|
2020-12-10 17:46:15 +01:00
|
|
|
return this.users.size === 0 && this.admins.size === 0;
|
2020-06-29 19:14:54 +02:00
|
|
|
}
|
|
|
|
|
2020-11-13 18:00:22 +01:00
|
|
|
public updatePosition(user : User, userPosition: PointInterface): void {
|
2020-09-25 15:25:06 +02:00
|
|
|
user.setPosition(userPosition);
|
2020-09-16 16:06:43 +02:00
|
|
|
|
2020-09-25 15:25:06 +02:00
|
|
|
this.updateUserGroup(user);
|
|
|
|
}
|
2020-09-15 16:21:41 +02:00
|
|
|
|
2020-09-25 15:25:06 +02:00
|
|
|
private updateUserGroup(user: User): void {
|
2020-09-24 10:05:16 +02:00
|
|
|
user.group?.updatePosition();
|
2020-04-09 23:26:19 +02:00
|
|
|
|
2020-08-31 14:03:40 +02:00
|
|
|
if (user.silent) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-09-16 16:06:43 +02:00
|
|
|
if (user.group === undefined) {
|
2020-04-09 23:26:19 +02:00
|
|
|
// If the user is not part of a group:
|
|
|
|
// should he join a group?
|
2020-10-22 16:15:30 +02:00
|
|
|
|
|
|
|
// If the user is moving, don't try to join
|
|
|
|
if (user.getPosition().moving) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-09-16 16:06:43 +02:00
|
|
|
const closestItem: User|Group|null = this.searchClosestAvailableUserOrGroup(user);
|
2020-04-09 23:26:19 +02:00
|
|
|
|
2020-04-29 22:41:48 +02:00
|
|
|
if (closestItem !== null) {
|
|
|
|
if (closestItem instanceof Group) {
|
|
|
|
// Let's join the group!
|
|
|
|
closestItem.join(user);
|
|
|
|
} else {
|
2020-09-16 16:06:43 +02:00
|
|
|
const closestUser : User = closestItem;
|
2020-10-30 15:23:50 +01:00
|
|
|
const group: Group = new Group(this.roomId,[
|
2020-04-09 23:26:19 +02:00
|
|
|
user,
|
|
|
|
closestUser
|
2020-09-25 13:48:02 +02:00
|
|
|
], this.connectCallback, this.disconnectCallback, this.positionNotifier);
|
2020-06-29 22:13:07 +02:00
|
|
|
this.groups.add(group);
|
2020-04-09 23:26:19 +02:00
|
|
|
}
|
|
|
|
}
|
2020-04-28 23:23:50 +02:00
|
|
|
|
|
|
|
} else {
|
|
|
|
// If the user is part of a group:
|
2020-04-29 23:12:55 +02:00
|
|
|
// should he leave the group?
|
2020-10-06 15:37:00 +02:00
|
|
|
const distance = GameRoom.computeDistanceBetweenPositions(user.getPosition(), user.group.getPosition());
|
2020-05-03 16:56:19 +02:00
|
|
|
if (distance > this.groupRadius) {
|
2020-04-29 23:12:55 +02:00
|
|
|
this.leaveGroup(user);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-04-28 23:23:50 +02:00
|
|
|
|
2020-11-13 18:00:22 +01:00
|
|
|
setSilent(user: User, silent: boolean) {
|
2020-08-31 14:03:40 +02:00
|
|
|
if (user.silent === silent) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
user.silent = silent;
|
|
|
|
if (silent && user.group !== undefined) {
|
|
|
|
this.leaveGroup(user);
|
|
|
|
}
|
|
|
|
if (!silent) {
|
|
|
|
// If we are back to life, let's trigger a position update to see if we can join some group.
|
2020-11-13 18:00:22 +01:00
|
|
|
this.updatePosition(user, user.getPosition());
|
2020-08-31 14:03:40 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-29 23:12:55 +02:00
|
|
|
/**
|
|
|
|
* Makes a user leave a group and closes and destroy the group if the group contains only one remaining person.
|
|
|
|
*
|
|
|
|
* @param user
|
|
|
|
*/
|
2020-09-16 16:06:43 +02:00
|
|
|
private leaveGroup(user: User): void {
|
2020-06-09 15:54:54 +02:00
|
|
|
const group = user.group;
|
2020-09-21 11:24:03 +02:00
|
|
|
if (group === undefined) {
|
2020-04-29 23:12:55 +02:00
|
|
|
throw new Error("The user is part of no group");
|
|
|
|
}
|
|
|
|
group.leave(user);
|
|
|
|
if (group.isEmpty()) {
|
2020-09-16 16:06:43 +02:00
|
|
|
this.positionNotifier.leave(group);
|
2020-04-29 23:12:55 +02:00
|
|
|
group.destroy();
|
2020-06-29 22:13:07 +02:00
|
|
|
if (!this.groups.has(group)) {
|
2020-06-29 22:10:23 +02:00
|
|
|
throw new Error("Could not find group "+group.getId()+" referenced by user "+user.id+" in World.");
|
2020-04-29 23:12:55 +02:00
|
|
|
}
|
2020-06-29 22:13:07 +02:00
|
|
|
this.groups.delete(group);
|
2020-10-30 15:23:50 +01:00
|
|
|
//todo: is the group garbage collected?
|
2020-05-08 00:35:36 +02:00
|
|
|
} else {
|
2020-09-25 13:48:02 +02:00
|
|
|
group.updatePosition();
|
|
|
|
//this.positionNotifier.updatePosition(group, group.getPosition(), oldPosition);
|
2020-04-09 23:26:19 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Looks for the closest user that is:
|
2020-05-03 16:56:19 +02:00
|
|
|
* - close enough (distance <= minDistance)
|
|
|
|
* - not in a group
|
2020-08-31 14:03:40 +02:00
|
|
|
* - not silent
|
2020-05-03 16:56:19 +02:00
|
|
|
* OR
|
|
|
|
* - close enough to a group (distance <= groupRadius)
|
2020-04-09 23:26:19 +02:00
|
|
|
*/
|
2020-09-16 16:06:43 +02:00
|
|
|
private searchClosestAvailableUserOrGroup(user: User): User|Group|null
|
2020-04-09 23:26:19 +02:00
|
|
|
{
|
2020-05-03 16:56:19 +02:00
|
|
|
let minimumDistanceFound: number = Math.max(this.minDistance, this.groupRadius);
|
2020-09-16 16:06:43 +02:00
|
|
|
let matchingItem: User | Group | null = null;
|
2020-05-03 16:56:19 +02:00
|
|
|
this.users.forEach((currentUser, userId) => {
|
2020-04-29 22:41:48 +02:00
|
|
|
// Let's only check users that are not part of a group
|
|
|
|
if (typeof currentUser.group !== 'undefined') {
|
|
|
|
return;
|
|
|
|
}
|
2020-04-09 23:26:19 +02:00
|
|
|
if(currentUser === user) {
|
|
|
|
return;
|
|
|
|
}
|
2020-08-31 14:03:40 +02:00
|
|
|
if (currentUser.silent) {
|
|
|
|
return;
|
|
|
|
}
|
2020-04-09 23:26:19 +02:00
|
|
|
|
2020-10-06 15:37:00 +02:00
|
|
|
const distance = GameRoom.computeDistance(user, currentUser); // compute distance between peers.
|
2020-04-28 23:23:50 +02:00
|
|
|
|
2020-05-03 16:56:19 +02:00
|
|
|
if(distance <= minimumDistanceFound && distance <= this.minDistance) {
|
2020-04-29 22:41:48 +02:00
|
|
|
minimumDistanceFound = distance;
|
|
|
|
matchingItem = currentUser;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2020-05-03 16:56:19 +02:00
|
|
|
this.groups.forEach((group: Group) => {
|
2020-04-29 22:41:48 +02:00
|
|
|
if (group.isFull()) {
|
|
|
|
return;
|
2020-04-08 20:40:44 +02:00
|
|
|
}
|
2020-10-06 15:37:00 +02:00
|
|
|
const distance = GameRoom.computeDistanceBetweenPositions(user.getPosition(), group.getPosition());
|
2020-05-03 16:56:19 +02:00
|
|
|
if(distance <= minimumDistanceFound && distance <= this.groupRadius) {
|
2020-04-29 22:41:48 +02:00
|
|
|
minimumDistanceFound = distance;
|
|
|
|
matchingItem = group;
|
|
|
|
}
|
|
|
|
});
|
2020-04-08 20:40:44 +02:00
|
|
|
|
2020-04-29 22:41:48 +02:00
|
|
|
return matchingItem;
|
2020-04-08 20:40:44 +02:00
|
|
|
}
|
|
|
|
|
2020-09-16 16:06:43 +02:00
|
|
|
public static computeDistance(user1: User, user2: User): number
|
2020-04-08 20:40:44 +02:00
|
|
|
{
|
2020-09-25 15:25:06 +02:00
|
|
|
const user1Position = user1.getPosition();
|
|
|
|
const user2Position = user2.getPosition();
|
|
|
|
return Math.sqrt(Math.pow(user2Position.x - user1Position.x, 2) + Math.pow(user2Position.y - user1Position.y, 2));
|
2020-04-08 20:40:44 +02:00
|
|
|
}
|
2020-04-07 10:08:04 +02:00
|
|
|
|
2020-04-29 22:41:48 +02:00
|
|
|
public static computeDistanceBetweenPositions(position1: PositionInterface, position2: PositionInterface): number
|
|
|
|
{
|
|
|
|
return Math.sqrt(Math.pow(position2.x - position1.x, 2) + Math.pow(position2.y - position1.y, 2));
|
|
|
|
}
|
|
|
|
|
2020-07-27 22:36:07 +02:00
|
|
|
public setItemState(itemId: number, state: unknown) {
|
|
|
|
this.itemsState.set(itemId, state);
|
|
|
|
}
|
|
|
|
|
|
|
|
public getItemsState(): Map<number, unknown> {
|
|
|
|
return this.itemsState;
|
|
|
|
}
|
|
|
|
|
2020-11-13 18:00:22 +01:00
|
|
|
public addZoneListener(call: ZoneSocket, x: number, y: number): Set<Movable> {
|
|
|
|
return this.positionNotifier.addZoneListener(call, x, y);
|
2020-09-15 16:21:41 +02:00
|
|
|
}
|
2020-10-14 16:00:25 +02:00
|
|
|
|
2020-11-13 18:00:22 +01:00
|
|
|
public removeZoneListener(call: ZoneSocket, x: number, y: number): void {
|
|
|
|
return this.positionNotifier.removeZoneListener(call, x, y);
|
2020-10-14 16:00:25 +02:00
|
|
|
}
|
2020-12-10 17:46:15 +01:00
|
|
|
|
|
|
|
public adminJoin(admin: Admin): void {
|
|
|
|
this.admins.add(admin);
|
|
|
|
|
|
|
|
// Let's send all connected users
|
|
|
|
for (const user of this.users.values()) {
|
2021-01-15 03:19:58 +01:00
|
|
|
admin.sendUserJoin(user.uuid, user.name, user.IPAddress);
|
2020-12-10 17:46:15 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public adminLeave(admin: Admin): void {
|
|
|
|
this.admins.delete(admin);
|
|
|
|
}
|
2021-04-01 16:43:12 +02:00
|
|
|
|
|
|
|
public incrementVersion(): number {
|
|
|
|
this.versionNumber++
|
|
|
|
return this.versionNumber;
|
|
|
|
}
|
2020-04-28 23:23:50 +02:00
|
|
|
}
|