partey_workadventure/back/src/Model/GameRoom.ts

342 lines
12 KiB
TypeScript
Raw Normal View History

2021-06-24 10:09:10 +02:00
import { PointInterface } from "./Websocket/PointInterface";
import { Group } from "./Group";
import { User, UserSocket } from "./User";
import { PositionInterface } from "_Model/PositionInterface";
import { EmoteCallback, EntersCallback, LeavesCallback, MovesCallback } from "_Model/Zone";
import { PositionNotifier } from "./PositionNotifier";
import { Movable } from "_Model/Movable";
import { extractDataFromPrivateRoomId, extractRoomSlugPublicRoomId, isRoomAnonymous } from "./RoomIdentifier";
import { arrayIntersect } from "../Services/ArrayHelper";
import { EmoteEventMessage, JoinRoomMessage } from "../Messages/generated/messages_pb";
import { ProtobufUtils } from "../Model/Websocket/ProtobufUtils";
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;
export enum GameRoomPolicyTypes {
2020-12-11 12:23:50 +01:00
ANONYMOUS_POLICY = 1,
MEMBERS_ONLY_POLICY,
USE_TAGS_POLICY,
}
2020-10-06 15:37:00 +02:00
export class GameRoom {
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
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>;
private readonly admins: Set<Admin>;
2020-04-08 20:40:44 +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>();
private readonly positionNotifier: PositionNotifier;
public readonly roomId: string;
public readonly roomSlug: string;
2021-06-24 10:09:10 +02:00
public readonly worldSlug: string = "";
public readonly organizationSlug: string = "";
private versionNumber: number = 1;
private nextUserId: number = 1;
2021-06-24 10:09:10 +02:00
constructor(
roomId: string,
connectCallback: ConnectCallback,
disconnectCallback: DisconnectCallback,
minDistance: number,
groupRadius: number,
onEnters: EntersCallback,
onMoves: MovesCallback,
onLeaves: LeavesCallback,
onEmote: EmoteCallback
) {
this.roomId = roomId;
if (isRoomAnonymous(roomId)) {
this.roomSlug = extractRoomSlugPublicRoomId(this.roomId);
} else {
2021-06-24 10:09:10 +02:00
const { organizationSlug, worldSlug, roomSlug } = extractDataFromPrivateRoomId(this.roomId);
this.roomSlug = roomSlug;
this.organizationSlug = organizationSlug;
this.worldSlug = worldSlug;
}
this.users = new Map<number, User>();
2020-12-11 12:23:50 +01:00
this.usersByUuid = new Map<string, User>();
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;
this.minDistance = minDistance;
this.groupRadius = groupRadius;
// A zone is 10 sprites wide.
this.positionNotifier = new PositionNotifier(320, 320, onEnters, onMoves, onLeaves, onEmote);
2020-04-28 23:23:50 +02:00
}
2020-04-07 10:08:04 +02:00
public getGroups(): Group[] {
return Array.from(this.groups.values());
}
public getUsers(): Map<number, User> {
return this.users;
}
2021-06-24 10:09:10 +02:00
public getUserByUuid(uuid: string): User | undefined {
2020-12-11 12:23:50 +01:00
return this.usersByUuid.get(uuid);
}
2021-06-24 10:09:10 +02:00
public getUserById(id: number): User | undefined {
return this.users.get(id);
}
2021-06-24 10:09:10 +02:00
public join(socket: UserSocket, joinRoomMessage: JoinRoomMessage): User {
const positionMessage = joinRoomMessage.getPositionmessage();
if (positionMessage === undefined) {
2021-06-24 10:09:10 +02:00
throw new Error("Missing position message");
}
const position = ProtobufUtils.toPointInterface(positionMessage);
2021-06-24 10:09:10 +02:00
const user = new User(
this.nextUserId,
2021-01-15 03:19:58 +01:00
joinRoomMessage.getUseruuid(),
joinRoomMessage.getIpaddress(),
position,
false,
this.positionNotifier,
socket,
joinRoomMessage.getTagList(),
joinRoomMessage.getVisitcardurl(),
2021-01-15 03:19:58 +01:00
joinRoomMessage.getName(),
2021-04-02 21:21:11 +02:00
ProtobufUtils.toCharacterLayerObjects(joinRoomMessage.getCharacterlayerList()),
joinRoomMessage.getCompanion()
2021-01-15 03:19:58 +01:00
);
this.nextUserId++;
this.users.set(user.id, user);
2020-12-11 12:23:50 +01:00
this.usersByUuid.set(user.uuid, user);
this.updateUserGroup(user);
// Notify admins
for (const admin of this.admins) {
2021-01-15 03:19:58 +01:00
admin.sendUserJoin(user.uuid, user.name, user.IPAddress);
}
return user;
2020-04-07 10:08:04 +02:00
}
2021-06-24 10:09:10 +02:00
public leave(user: User) {
const userObj = this.users.get(user.id);
if (userObj === undefined) {
2021-06-24 10:09:10 +02:00
console.warn("User ", user.id, "does not belong to this game room! It should!");
}
2021-06-24 10:09:10 +02:00
if (userObj !== undefined && typeof userObj.group !== "undefined") {
this.leaveGroup(userObj);
}
this.users.delete(user.id);
2020-12-11 12:23:50 +01:00
this.usersByUuid.delete(user.uuid);
if (userObj !== undefined) {
2020-09-28 18:52:54 +02:00
this.positionNotifier.leave(userObj);
}
// Notify admins
for (const admin of this.admins) {
2021-06-24 10:09:10 +02:00
admin.sendUserLeft(user.uuid /*, user.name, user.IPAddress*/);
}
2020-04-29 01:40:32 +02:00
}
2020-06-29 19:14:54 +02:00
public isEmpty(): boolean {
return this.users.size === 0 && this.admins.size === 0;
2020-06-29 19:14:54 +02:00
}
2021-06-24 10:09:10 +02:00
public updatePosition(user: User, userPosition: PointInterface): void {
user.setPosition(userPosition);
2020-09-16 16:06:43 +02:00
this.updateUserGroup(user);
}
private updateUserGroup(user: User): void {
2020-09-24 10:05:16 +02:00
user.group?.updatePosition();
if (user.silent) {
return;
}
2020-09-16 16:06:43 +02:00
if (user.group === undefined) {
// If the user is not part of a group:
// should he join a group?
// If the user is moving, don't try to join
if (user.getPosition().moving) {
return;
}
2021-06-24 10:09:10 +02:00
const closestItem: User | Group | null = this.searchClosestAvailableUserOrGroup(user);
if (closestItem !== null) {
if (closestItem instanceof Group) {
// Let's join the group!
closestItem.join(user);
} else {
2021-06-24 10:09:10 +02:00
const closestUser: User = closestItem;
const group: Group = new Group(
this.roomId,
[user, closestUser],
this.connectCallback,
this.disconnectCallback,
this.positionNotifier
);
2020-06-29 22:13:07 +02:00
this.groups.add(group);
}
}
2020-04-28 23:23:50 +02:00
} else {
// If the user is part of a group:
// should he leave the group?
2020-10-06 15:37:00 +02:00
const distance = GameRoom.computeDistanceBetweenPositions(user.getPosition(), user.group.getPosition());
if (distance > this.groupRadius) {
this.leaveGroup(user);
}
}
}
2020-04-28 23:23:50 +02:00
setSilent(user: User, silent: boolean) {
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.
this.updatePosition(user, user.getPosition());
}
}
/**
* 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 {
const group = user.group;
2020-09-21 11:24:03 +02:00
if (group === undefined) {
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);
group.destroy();
2020-06-29 22:13:07 +02:00
if (!this.groups.has(group)) {
2021-06-24 10:09:10 +02:00
throw new Error(
"Could not find group " + group.getId() + " referenced by user " + user.id + " in World."
);
}
2020-06-29 22:13:07 +02:00
this.groups.delete(group);
//todo: is the group garbage collected?
} else {
group.updatePosition();
//this.positionNotifier.updatePosition(group, group.getPosition(), oldPosition);
}
}
/**
* Looks for the closest user that is:
* - close enough (distance <= minDistance)
* - not in a group
* - not silent
* OR
* - close enough to a group (distance <= groupRadius)
*/
2021-06-24 10:09:10 +02:00
private searchClosestAvailableUserOrGroup(user: User): User | Group | null {
let minimumDistanceFound: number = Math.max(this.minDistance, this.groupRadius);
2020-09-16 16:06:43 +02:00
let matchingItem: User | Group | null = null;
this.users.forEach((currentUser, userId) => {
// Let's only check users that are not part of a group
2021-06-24 10:09:10 +02:00
if (typeof currentUser.group !== "undefined") {
return;
}
2021-06-24 10:09:10 +02:00
if (currentUser === user) {
return;
}
if (currentUser.silent) {
return;
}
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
2021-06-24 10:09:10 +02:00
if (distance <= minimumDistanceFound && distance <= this.minDistance) {
minimumDistanceFound = distance;
matchingItem = currentUser;
}
});
this.groups.forEach((group: Group) => {
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());
2021-06-24 10:09:10 +02:00
if (distance <= minimumDistanceFound && distance <= this.groupRadius) {
minimumDistanceFound = distance;
matchingItem = group;
}
});
2020-04-08 20:40:44 +02:00
return matchingItem;
2020-04-08 20:40:44 +02:00
}
2021-06-24 10:09:10 +02:00
public static computeDistance(user1: User, user2: User): number {
const user1Position = user1.getPosition();
const user2Position = user2.getPosition();
2021-06-24 10:09:10 +02:00
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
2021-06-24 10:09:10 +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;
}
public addZoneListener(call: ZoneSocket, x: number, y: number): Set<Movable> {
return this.positionNotifier.addZoneListener(call, x, y);
}
public removeZoneListener(call: ZoneSocket, x: number, y: number): void {
return this.positionNotifier.removeZoneListener(call, x, y);
}
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);
}
}
public adminLeave(admin: Admin): void {
this.admins.delete(admin);
}
2021-06-24 10:09:10 +02:00
public incrementVersion(): number {
2021-06-24 10:09:10 +02:00
this.versionNumber++;
return this.versionNumber;
}
public emitEmoteEvent(user: User, emoteEventMessage: EmoteEventMessage) {
this.positionNotifier.emitEmoteEvent(user, emoteEventMessage);
}
2020-04-28 23:23:50 +02:00
}