mirror of
https://github.com/MrUnknownDE/VRCX.git
synced 2026-05-01 04:33:46 +02:00
1041 lines
35 KiB
JavaScript
1041 lines
35 KiB
JavaScript
import { reactive, ref, shallowRef, watch } from 'vue';
|
|
import { defineStore } from 'pinia';
|
|
import { toast } from 'vue-sonner';
|
|
import { useI18n } from 'vue-i18n';
|
|
import { useRouter } from 'vue-router';
|
|
|
|
import dayjs from 'dayjs';
|
|
|
|
import {
|
|
compareGameLogRows,
|
|
createJoinLeaveEntry,
|
|
createLocationEntry,
|
|
createPortalSpawnEntry,
|
|
createResourceLoadEntry,
|
|
findUserByDisplayName,
|
|
formatSeconds,
|
|
gameLogSearchFilter,
|
|
getGroupName,
|
|
parseInventoryFromUrl,
|
|
parseLocation,
|
|
parsePrintFromUrl,
|
|
replaceBioSymbols
|
|
} from '../../shared/utils';
|
|
import { AppDebug } from '../../service/appConfig';
|
|
import { createMediaParsers } from './mediaParsers';
|
|
import { database } from '../../service/database';
|
|
import { useAdvancedSettingsStore } from '../settings/advanced';
|
|
import { useFriendStore } from '../friend';
|
|
import { useGalleryStore } from '../gallery';
|
|
import { useGameStore } from '../game';
|
|
import { useGeneralSettingsStore } from '../settings/general';
|
|
import { useInstanceStore } from '../instance';
|
|
import { useLocationStore } from '../location';
|
|
import { useModalStore } from '../modal';
|
|
import { useNotificationStore } from '../notification';
|
|
import { usePhotonStore } from '../photon';
|
|
import { useSharedFeedStore } from '../sharedFeed';
|
|
import { useUiStore } from '../ui';
|
|
import { useUserStore } from '../user';
|
|
import { useVrStore } from '../vr';
|
|
import { useVrcxStore } from '../vrcx';
|
|
import { userRequest } from '../../api';
|
|
import { watchState } from '../../service/watchState';
|
|
|
|
import configRepository from '../../service/config';
|
|
import gameLogService from '../../service/gameLog.js';
|
|
|
|
import * as workerTimers from 'worker-timers';
|
|
|
|
export const useGameLogStore = defineStore('GameLog', () => {
|
|
const notificationStore = useNotificationStore();
|
|
const vrStore = useVrStore();
|
|
const locationStore = useLocationStore();
|
|
const friendStore = useFriendStore();
|
|
const instanceStore = useInstanceStore();
|
|
const userStore = useUserStore();
|
|
const uiStore = useUiStore();
|
|
const vrcxStore = useVrcxStore();
|
|
const advancedSettingsStore = useAdvancedSettingsStore();
|
|
const gameStore = useGameStore();
|
|
const generalSettingsStore = useGeneralSettingsStore();
|
|
const galleryStore = useGalleryStore();
|
|
const photonStore = usePhotonStore();
|
|
const sharedFeedStore = useSharedFeedStore();
|
|
const modalStore = useModalStore();
|
|
|
|
const router = useRouter();
|
|
const { t } = useI18n();
|
|
|
|
const state = reactive({
|
|
lastLocationAvatarList: new Map()
|
|
});
|
|
|
|
const gameLogTableData = shallowRef([]);
|
|
const gameLogTable = ref({
|
|
loading: false,
|
|
search: '',
|
|
filter: [],
|
|
pageSize: 20,
|
|
pageSizeLinked: true,
|
|
vip: false
|
|
});
|
|
|
|
const nowPlaying = ref({
|
|
url: '',
|
|
name: '',
|
|
length: 0,
|
|
startTime: 0,
|
|
offset: 0,
|
|
elapsed: 0,
|
|
percentage: 0,
|
|
remainingText: '',
|
|
playing: false,
|
|
thumbnailUrl: ''
|
|
});
|
|
|
|
const lastVideoUrl = ref('');
|
|
|
|
const lastResourceloadUrl = ref('');
|
|
|
|
watch(
|
|
() => watchState.isLoggedIn,
|
|
() => {
|
|
gameLogTableData.value = [];
|
|
},
|
|
{ flush: 'sync' }
|
|
);
|
|
|
|
watch(
|
|
router.currentRoute,
|
|
(value) => {
|
|
if (value.name === 'game-log') {
|
|
initGameLogTable();
|
|
} else {
|
|
gameLogTableData.value = [];
|
|
}
|
|
},
|
|
{ immediate: true }
|
|
);
|
|
|
|
watch(
|
|
() => watchState.isFavoritesLoaded,
|
|
(isFavoritesLoaded) => {
|
|
if (isFavoritesLoaded && gameLogTable.value.vip) {
|
|
gameLogTableLookup(); // re-apply VIP filter after friends are loaded
|
|
}
|
|
}
|
|
);
|
|
|
|
watch(
|
|
() => watchState.isFriendsLoaded,
|
|
(isFriendsLoaded) => {
|
|
if (isFriendsLoaded) {
|
|
tryLoadPlayerList();
|
|
}
|
|
},
|
|
{ flush: 'sync' }
|
|
);
|
|
|
|
/**
|
|
*
|
|
*/
|
|
async function init() {
|
|
gameLogTable.value.filter = JSON.parse(
|
|
await configRepository.getString('VRCX_gameLogTableFilters', '[]')
|
|
);
|
|
gameLogTable.value.vip = await configRepository.getBool(
|
|
'VRCX_gameLogTableVIPFilter',
|
|
false
|
|
);
|
|
}
|
|
|
|
init();
|
|
|
|
/**
|
|
*
|
|
* @param entry
|
|
*/
|
|
function insertGameLogSorted(entry) {
|
|
const arr = gameLogTableData.value;
|
|
if (arr.length === 0) {
|
|
gameLogTableData.value = [entry];
|
|
return;
|
|
}
|
|
if (compareGameLogRows(entry, arr[0]) < 0) {
|
|
gameLogTableData.value = [entry, ...arr];
|
|
return;
|
|
}
|
|
if (compareGameLogRows(entry, arr[arr.length - 1]) > 0) {
|
|
gameLogTableData.value = [...arr, entry];
|
|
return;
|
|
}
|
|
for (let i = 1; i < arr.length; i++) {
|
|
if (compareGameLogRows(entry, arr[i]) < 0) {
|
|
gameLogTableData.value = [
|
|
...arr.slice(0, i),
|
|
entry,
|
|
...arr.slice(i)
|
|
];
|
|
return;
|
|
}
|
|
}
|
|
gameLogTableData.value = [...arr, entry];
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
function clearNowPlaying() {
|
|
nowPlaying.value = {
|
|
url: '',
|
|
name: '',
|
|
length: 0,
|
|
startTime: 0,
|
|
offset: 0,
|
|
elapsed: 0,
|
|
percentage: 0,
|
|
remainingText: '',
|
|
playing: false,
|
|
thumbnailUrl: ''
|
|
};
|
|
vrStore.updateVrNowPlaying();
|
|
}
|
|
|
|
function resetLastMediaUrls() {
|
|
lastVideoUrl.value = '';
|
|
lastResourceloadUrl.value = '';
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param data
|
|
*/
|
|
function setNowPlaying(data) {
|
|
const ctx = structuredClone(data);
|
|
if (nowPlaying.value.url !== ctx.videoUrl) {
|
|
if (!ctx.userId && ctx.displayName) {
|
|
ctx.userId =
|
|
findUserByDisplayName(
|
|
userStore.cachedUsers,
|
|
ctx.displayName
|
|
)?.id ?? '';
|
|
}
|
|
notificationStore.queueGameLogNoty(ctx);
|
|
addGameLog(ctx);
|
|
database.addGamelogVideoPlayToDatabase(ctx);
|
|
|
|
let displayName = '';
|
|
if (ctx.displayName) {
|
|
displayName = ` (${ctx.displayName})`;
|
|
}
|
|
const name = `${ctx.videoName}${displayName}`;
|
|
nowPlaying.value = {
|
|
url: ctx.videoUrl,
|
|
name,
|
|
length: ctx.videoLength,
|
|
startTime: Date.parse(ctx.created_at) / 1000,
|
|
offset: ctx.videoPos,
|
|
elapsed: 0,
|
|
percentage: 0,
|
|
remainingText: '',
|
|
playing: false,
|
|
thumbnailUrl: ctx.thumbnailUrl
|
|
};
|
|
} else {
|
|
nowPlaying.value = {
|
|
...nowPlaying.value,
|
|
length: ctx.videoLength,
|
|
offset: ctx.videoPos,
|
|
elapsed: 0,
|
|
percentage: 0,
|
|
remainingText: '',
|
|
thumbnailUrl: ctx.thumbnailUrl
|
|
};
|
|
if (ctx.updatedAt && ctx.videoPos) {
|
|
nowPlaying.value.startTime =
|
|
Date.parse(ctx.updatedAt) / 1000 - ctx.videoPos;
|
|
} else {
|
|
nowPlaying.value.startTime =
|
|
Date.parse(ctx.created_at) / 1000 - ctx.videoPos;
|
|
}
|
|
}
|
|
vrStore.updateVrNowPlaying();
|
|
if (!nowPlaying.value.playing && ctx.videoLength > 0) {
|
|
nowPlaying.value.playing = true;
|
|
updateNowPlaying();
|
|
}
|
|
}
|
|
|
|
const {
|
|
addGameLogVideo,
|
|
addGameLogPyPyDance,
|
|
addGameLogVRDancing,
|
|
addGameLogZuwaZuwaDance,
|
|
addGameLogLSMedia,
|
|
addGameLogPopcornPalace
|
|
} = createMediaParsers({
|
|
nowPlaying,
|
|
setNowPlaying,
|
|
clearNowPlaying,
|
|
userStore,
|
|
advancedSettingsStore
|
|
});
|
|
|
|
/**
|
|
*
|
|
*/
|
|
function updateNowPlaying() {
|
|
const np = nowPlaying.value;
|
|
if (!nowPlaying.value.playing) {
|
|
return;
|
|
}
|
|
|
|
const now = Date.now() / 1000;
|
|
np.elapsed = Math.round((now - np.startTime) * 10) / 10;
|
|
if (np.elapsed >= np.length) {
|
|
clearNowPlaying();
|
|
return;
|
|
}
|
|
np.remainingText = formatSeconds(np.length - np.elapsed);
|
|
np.percentage = Math.round(((np.elapsed * 100) / np.length) * 10) / 10;
|
|
vrStore.updateVrNowPlaying();
|
|
workerTimers.setTimeout(() => updateNowPlaying(), 1000);
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
async function tryLoadPlayerList() {
|
|
// TODO: make this work again
|
|
if (!gameStore.isGameRunning) {
|
|
return;
|
|
}
|
|
console.log('Loading player list from game log...');
|
|
let ctx;
|
|
let i;
|
|
const data = await database.getGamelogDatabase();
|
|
if (data.length === 0) {
|
|
return;
|
|
}
|
|
let length = 0;
|
|
for (i = data.length - 1; i > -1; i--) {
|
|
ctx = data[i];
|
|
if (ctx.type === 'Location') {
|
|
locationStore.setLastLocation({
|
|
date: Date.parse(ctx.created_at),
|
|
location: ctx.location,
|
|
name: ctx.worldName,
|
|
playerList: new Map(),
|
|
friendList: new Map()
|
|
});
|
|
length = i;
|
|
break;
|
|
}
|
|
}
|
|
if (length > 0) {
|
|
for (i = length + 1; i < data.length; i++) {
|
|
ctx = data[i];
|
|
if (ctx.type === 'OnPlayerJoined') {
|
|
if (!ctx.userId) {
|
|
ctx.userId =
|
|
findUserByDisplayName(
|
|
userStore.cachedUsers,
|
|
ctx.displayName
|
|
)?.id ?? '';
|
|
}
|
|
const userMap = {
|
|
displayName: ctx.displayName,
|
|
userId: ctx.userId,
|
|
joinTime: Date.parse(ctx.created_at),
|
|
lastAvatar: ''
|
|
};
|
|
locationStore.lastLocation.playerList.set(
|
|
ctx.userId,
|
|
userMap
|
|
);
|
|
if (friendStore.friends.has(ctx.userId)) {
|
|
locationStore.lastLocation.friendList.set(
|
|
ctx.userId,
|
|
userMap
|
|
);
|
|
}
|
|
}
|
|
if (ctx.type === 'OnPlayerLeft') {
|
|
locationStore.lastLocation.playerList.delete(ctx.userId);
|
|
locationStore.lastLocation.friendList.delete(ctx.userId);
|
|
}
|
|
}
|
|
locationStore.lastLocation.playerList.forEach((ref1) => {
|
|
if (
|
|
ref1.userId &&
|
|
typeof ref1.userId === 'string' &&
|
|
!userStore.cachedUsers.has(ref1.userId)
|
|
) {
|
|
userRequest.getUser({ userId: ref1.userId });
|
|
}
|
|
});
|
|
|
|
locationStore.updateCurrentUserLocation();
|
|
instanceStore.updateCurrentInstanceWorld();
|
|
vrStore.updateVRLastLocation();
|
|
instanceStore.getCurrentInstanceUserList();
|
|
userStore.applyUserDialogLocation();
|
|
instanceStore.applyWorldDialogInstances();
|
|
instanceStore.applyGroupDialogInstances();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param row
|
|
*/
|
|
function gameLogIsFriend(row) {
|
|
if (typeof row.isFriend !== 'undefined') {
|
|
return row.isFriend;
|
|
}
|
|
if (!row.userId) {
|
|
return false;
|
|
}
|
|
return friendStore.friends.has(row.userId);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param row
|
|
*/
|
|
function gameLogIsFavorite(row) {
|
|
if (typeof row.isFavorite !== 'undefined') {
|
|
return row.isFavorite;
|
|
}
|
|
if (!row.userId) {
|
|
return false;
|
|
}
|
|
return friendStore.localFavoriteFriends.has(row.userId);
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
async function gameLogTableLookup() {
|
|
await configRepository.setString(
|
|
'VRCX_gameLogTableFilters',
|
|
JSON.stringify(gameLogTable.value.filter)
|
|
);
|
|
await configRepository.setBool(
|
|
'VRCX_gameLogTableVIPFilter',
|
|
gameLogTable.value.vip
|
|
);
|
|
gameLogTable.value.loading = true;
|
|
try {
|
|
let vipList = [];
|
|
if (gameLogTable.value.vip) {
|
|
vipList = Array.from(friendStore.localFavoriteFriends.values());
|
|
}
|
|
const search = gameLogTable.value.search.trim();
|
|
let rows = [];
|
|
if (search) {
|
|
rows = await database.searchGameLogDatabase(
|
|
search,
|
|
gameLogTable.value.filter,
|
|
vipList,
|
|
vrcxStore.searchLimit
|
|
);
|
|
} else {
|
|
rows = await database.lookupGameLogDatabase(
|
|
gameLogTable.value.filter,
|
|
vipList
|
|
);
|
|
}
|
|
|
|
for (const row of rows) {
|
|
row.isFriend = gameLogIsFriend(row);
|
|
row.isFavorite = gameLogIsFavorite(row);
|
|
}
|
|
gameLogTableData.value = rows;
|
|
} finally {
|
|
gameLogTable.value.loading = false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param entry
|
|
*/
|
|
function addGameLog(entry) {
|
|
entry.isFriend = gameLogIsFriend(entry);
|
|
entry.isFavorite = gameLogIsFavorite(entry);
|
|
|
|
// If the VIP friend filter is enabled, logs from other friends will be ignored.
|
|
if (
|
|
gameLogTable.value.vip &&
|
|
!friendStore.localFavoriteFriends.has(entry.userId) &&
|
|
(entry.type === 'OnPlayerJoined' ||
|
|
entry.type === 'OnPlayerLeft' ||
|
|
entry.type === 'VideoPlay' ||
|
|
entry.type === 'PortalSpawn' ||
|
|
entry.type === 'External')
|
|
) {
|
|
return;
|
|
}
|
|
if (
|
|
entry.type === 'LocationDestination' ||
|
|
entry.type === 'AvatarChange' ||
|
|
entry.type === 'ChatBoxMessage' ||
|
|
(entry.userId === userStore.currentUser.id &&
|
|
(entry.type === 'OnPlayerJoined' ||
|
|
entry.type === 'OnPlayerLeft'))
|
|
) {
|
|
return;
|
|
}
|
|
if (
|
|
gameLogTable.value.filter.length > 0 &&
|
|
!gameLogTable.value.filter.includes(entry.type)
|
|
) {
|
|
return;
|
|
}
|
|
if (!gameLogSearch(entry)) {
|
|
return;
|
|
}
|
|
insertGameLogSorted(entry);
|
|
sweepGameLog();
|
|
uiStore.notifyMenu('game-log');
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param input
|
|
*/
|
|
async function addGamelogLocationToDatabase(input) {
|
|
const groupName = await getGroupName(input.location);
|
|
const entry = {
|
|
...input,
|
|
groupName
|
|
};
|
|
database.addGamelogLocationToDatabase(entry);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param row
|
|
*/
|
|
function gameLogSearch(row) {
|
|
return gameLogSearchFilter(row, gameLogTable.value.search);
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
function sweepGameLog() {
|
|
const j = gameLogTableData.value.length;
|
|
if (j > vrcxStore.maxTableSize + 50) {
|
|
gameLogTableData.value = gameLogTableData.value.slice(0, -50);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param gameLog
|
|
* @param location
|
|
*/
|
|
function addGameLogEntry(gameLog, location) {
|
|
let entry = undefined;
|
|
if (advancedSettingsStore.gameLogDisabled) {
|
|
return;
|
|
}
|
|
let userId = String(gameLog.userId || '');
|
|
if (!userId && gameLog.displayName) {
|
|
userId =
|
|
findUserByDisplayName(
|
|
userStore.cachedUsers,
|
|
gameLog.displayName
|
|
)?.id ?? '';
|
|
}
|
|
switch (gameLog.type) {
|
|
case 'location-destination':
|
|
if (gameStore.isGameRunning) {
|
|
// needs to be added before OnPlayerLeft entries from LocationReset
|
|
addGameLog({
|
|
created_at: gameLog.dt,
|
|
type: 'LocationDestination',
|
|
location: gameLog.location
|
|
});
|
|
locationStore.lastLocationReset(gameLog.dt);
|
|
locationStore.setLastLocationLocation('traveling');
|
|
locationStore.setLastLocationDestination(gameLog.location);
|
|
locationStore.setLastLocationDestinationTime(
|
|
Date.parse(gameLog.dt)
|
|
);
|
|
state.lastLocationAvatarList.clear();
|
|
instanceStore.removeQueuedInstance(gameLog.location);
|
|
locationStore.updateCurrentUserLocation();
|
|
clearNowPlaying();
|
|
instanceStore.updateCurrentInstanceWorld();
|
|
userStore.applyUserDialogLocation();
|
|
instanceStore.applyWorldDialogInstances();
|
|
instanceStore.applyGroupDialogInstances();
|
|
}
|
|
break;
|
|
case 'location':
|
|
instanceStore.addInstanceJoinHistory(
|
|
locationStore.lastLocation.location,
|
|
gameLog.dt
|
|
);
|
|
const worldName = replaceBioSymbols(gameLog.worldName);
|
|
if (gameStore.isGameRunning) {
|
|
locationStore.lastLocationReset(gameLog.dt);
|
|
clearNowPlaying();
|
|
locationStore.setLastLocation({
|
|
date: Date.parse(gameLog.dt),
|
|
location: gameLog.location,
|
|
name: worldName,
|
|
playerList: new Map(),
|
|
friendList: new Map()
|
|
});
|
|
instanceStore.removeQueuedInstance(gameLog.location);
|
|
locationStore.updateCurrentUserLocation();
|
|
vrStore.updateVRLastLocation();
|
|
instanceStore.updateCurrentInstanceWorld();
|
|
userStore.applyUserDialogLocation();
|
|
instanceStore.applyWorldDialogInstances();
|
|
instanceStore.applyGroupDialogInstances();
|
|
}
|
|
instanceStore.addInstanceJoinHistory(
|
|
gameLog.location,
|
|
gameLog.dt
|
|
);
|
|
const L = parseLocation(gameLog.location);
|
|
entry = createLocationEntry(
|
|
gameLog.dt,
|
|
gameLog.location,
|
|
L.worldId,
|
|
worldName
|
|
);
|
|
getGroupName(gameLog.location).then((groupName) => {
|
|
entry.groupName = groupName;
|
|
});
|
|
addGamelogLocationToDatabase(entry);
|
|
break;
|
|
case 'player-joined':
|
|
const joinTime = Date.parse(gameLog.dt);
|
|
const userMap = {
|
|
displayName: gameLog.displayName,
|
|
userId,
|
|
joinTime,
|
|
lastAvatar: ''
|
|
};
|
|
locationStore.lastLocation.playerList.set(userId, userMap);
|
|
const ref = userStore.cachedUsers.get(userId);
|
|
if (!userId) {
|
|
console.error('Missing userId:', gameLog.displayName);
|
|
} else if (userId === userStore.currentUser.id) {
|
|
// skip
|
|
} else if (
|
|
friendStore.friends.has(userId) &&
|
|
typeof ref !== 'undefined'
|
|
) {
|
|
locationStore.lastLocation.friendList.set(userId, userMap);
|
|
if (
|
|
ref.location !== locationStore.lastLocation.location &&
|
|
ref.travelingToLocation !==
|
|
locationStore.lastLocation.location
|
|
) {
|
|
// fix $location_at with private
|
|
ref.$location_at = joinTime;
|
|
}
|
|
} else if (typeof ref !== 'undefined') {
|
|
// set $location_at to join time if user isn't a friend
|
|
ref.$location_at = joinTime;
|
|
} else {
|
|
if (AppDebug.debugGameLog || AppDebug.debugWebRequests) {
|
|
console.log('Fetching user from gameLog:', userId);
|
|
}
|
|
userRequest.getUser({ userId });
|
|
}
|
|
vrStore.updateVRLastLocation();
|
|
instanceStore.getCurrentInstanceUserList();
|
|
entry = createJoinLeaveEntry(
|
|
'OnPlayerJoined',
|
|
gameLog.dt,
|
|
gameLog.displayName,
|
|
location,
|
|
userId
|
|
);
|
|
database.addGamelogJoinLeaveToDatabase(entry);
|
|
break;
|
|
case 'player-left':
|
|
const ref1 = locationStore.lastLocation.playerList.get(userId);
|
|
if (typeof ref1 === 'undefined') {
|
|
break;
|
|
}
|
|
const time = dayjs(gameLog.dt) - ref1.joinTime;
|
|
locationStore.lastLocation.playerList.delete(userId);
|
|
locationStore.lastLocation.friendList.delete(userId);
|
|
state.lastLocationAvatarList.delete(gameLog.displayName);
|
|
photonStore.photonLobbyAvatars.delete(userId);
|
|
vrStore.updateVRLastLocation();
|
|
instanceStore.getCurrentInstanceUserList();
|
|
entry = createJoinLeaveEntry(
|
|
'OnPlayerLeft',
|
|
gameLog.dt,
|
|
gameLog.displayName,
|
|
location,
|
|
userId,
|
|
time
|
|
);
|
|
database.addGamelogJoinLeaveToDatabase(entry);
|
|
break;
|
|
case 'portal-spawn':
|
|
if (vrcxStore.ipcEnabled && gameStore.isGameRunning) {
|
|
break;
|
|
}
|
|
entry = createPortalSpawnEntry(gameLog.dt, location);
|
|
database.addGamelogPortalSpawnToDatabase(entry);
|
|
break;
|
|
case 'video-play':
|
|
gameLog.videoUrl = decodeURI(gameLog.videoUrl);
|
|
if (lastVideoUrl.value === gameLog.videoUrl) {
|
|
break;
|
|
}
|
|
lastVideoUrl.value = gameLog.videoUrl;
|
|
addGameLogVideo(gameLog, location, userId);
|
|
break;
|
|
case 'video-sync':
|
|
const timestamp = gameLog.timestamp.replace(/,/g, '');
|
|
if (nowPlaying.value.playing) {
|
|
nowPlaying.value.offset = parseInt(timestamp, 10);
|
|
}
|
|
break;
|
|
case 'resource-load-string':
|
|
case 'resource-load-image':
|
|
if (
|
|
!generalSettingsStore.logResourceLoad ||
|
|
lastResourceloadUrl.value === gameLog.resourceUrl
|
|
) {
|
|
break;
|
|
}
|
|
lastResourceloadUrl.value = gameLog.resourceUrl;
|
|
entry = createResourceLoadEntry(
|
|
gameLog.type,
|
|
gameLog.dt,
|
|
gameLog.resourceUrl,
|
|
location
|
|
);
|
|
database.addGamelogResourceLoadToDatabase(entry);
|
|
break;
|
|
case 'screenshot':
|
|
// entry = {
|
|
// created_at: gameLog.dt,
|
|
// type: 'Event',
|
|
// data: `Screenshot Processed: ${gameLog.screenshotPath.replace(
|
|
// /^.*[\\/]/,
|
|
// ''
|
|
// )}`
|
|
// };
|
|
// database.addGamelogEventToDatabase(entry);
|
|
|
|
vrcxStore.processScreenshot(gameLog.screenshotPath);
|
|
break;
|
|
case 'api-request':
|
|
if (AppDebug.debugWebRequests) {
|
|
console.log('API Request:', gameLog.url);
|
|
}
|
|
// const userId = '';
|
|
// try {
|
|
// const url = new URL(gameLog.url);
|
|
// const urlParams = new URLSearchParams(gameLog.url);
|
|
// if (url.pathname.substring(0, 13) === '/api/1/users/') {
|
|
// const pathArray = url.pathname.split('/');
|
|
// userId = pathArray[4];
|
|
// } else if (urlParams.has('userId')) {
|
|
// userId = urlParams.get('userId');
|
|
// }
|
|
// } catch (err) {
|
|
// console.error(err);
|
|
// }
|
|
// if (!userId) {
|
|
// break;
|
|
// }
|
|
|
|
if (advancedSettingsStore.saveInstanceEmoji) {
|
|
const inv = parseInventoryFromUrl(gameLog.url);
|
|
if (inv) {
|
|
galleryStore.queueCheckInstanceInventory(
|
|
inv.inventoryId,
|
|
inv.userId
|
|
);
|
|
}
|
|
}
|
|
if (advancedSettingsStore.saveInstancePrints) {
|
|
const printId = parsePrintFromUrl(gameLog.url);
|
|
if (printId) {
|
|
galleryStore.queueSavePrintToFile(printId);
|
|
}
|
|
}
|
|
break;
|
|
case 'avatar-change':
|
|
if (!gameStore.isGameRunning) {
|
|
break;
|
|
}
|
|
let avatarName = state.lastLocationAvatarList.get(
|
|
gameLog.displayName
|
|
);
|
|
if (
|
|
photonStore.photonLoggingEnabled ||
|
|
avatarName === gameLog.avatarName
|
|
) {
|
|
break;
|
|
}
|
|
if (!avatarName) {
|
|
avatarName = gameLog.avatarName;
|
|
state.lastLocationAvatarList.set(
|
|
gameLog.displayName,
|
|
avatarName
|
|
);
|
|
break;
|
|
}
|
|
avatarName = gameLog.avatarName;
|
|
state.lastLocationAvatarList.set(
|
|
gameLog.displayName,
|
|
avatarName
|
|
);
|
|
entry = {
|
|
created_at: gameLog.dt,
|
|
type: 'AvatarChange',
|
|
userId,
|
|
name: avatarName,
|
|
displayName: gameLog.displayName
|
|
};
|
|
break;
|
|
case 'vrcx':
|
|
// VideoPlay(PyPyDance) "https://jd.pypy.moe/api/v1/videos/jr1NX4Jo8GE.mp4",0.1001,239.606,"0905 : [J-POP] 【まなこ】金曜日のおはよう 踊ってみた (vernities)"
|
|
const type = gameLog.data.substr(0, gameLog.data.indexOf(' '));
|
|
if (type === 'VideoPlay(PyPyDance)') {
|
|
addGameLogPyPyDance(gameLog, location);
|
|
} else if (type === 'VideoPlay(VRDancing)') {
|
|
addGameLogVRDancing(gameLog, location);
|
|
} else if (type === 'VideoPlay(ZuwaZuwaDance)') {
|
|
addGameLogZuwaZuwaDance(gameLog, location);
|
|
} else if (type === 'LSMedia') {
|
|
addGameLogLSMedia(gameLog, location);
|
|
} else if (type === 'VideoPlay(PopcornPalace)') {
|
|
addGameLogPopcornPalace(gameLog, location);
|
|
}
|
|
break;
|
|
case 'photon-id':
|
|
if (!gameStore.isGameRunning || !watchState.isFriendsLoaded) {
|
|
break;
|
|
}
|
|
const photonId = parseInt(gameLog.photonId, 10);
|
|
const ref2 = photonStore.photonLobby.get(photonId);
|
|
if (typeof ref2 === 'undefined') {
|
|
const foundUser = findUserByDisplayName(
|
|
userStore.cachedUsers,
|
|
gameLog.displayName
|
|
);
|
|
if (foundUser) {
|
|
photonStore.photonLobby.set(photonId, foundUser);
|
|
photonStore.photonLobbyCurrent.set(photonId, foundUser);
|
|
}
|
|
const ctx1 = {
|
|
displayName: gameLog.displayName
|
|
};
|
|
photonStore.photonLobby.set(photonId, ctx1);
|
|
photonStore.photonLobbyCurrent.set(photonId, ctx1);
|
|
instanceStore.getCurrentInstanceUserList();
|
|
}
|
|
break;
|
|
case 'notification':
|
|
// entry = {
|
|
// created_at: gameLog.dt,
|
|
// type: 'Notification',
|
|
// data: gameLog.json
|
|
// };
|
|
break;
|
|
case 'event':
|
|
entry = {
|
|
created_at: gameLog.dt,
|
|
type: 'Event',
|
|
data: gameLog.event
|
|
};
|
|
database.addGamelogEventToDatabase(entry);
|
|
break;
|
|
case 'vrc-quit':
|
|
if (!gameStore.isGameRunning) {
|
|
break;
|
|
}
|
|
if (advancedSettingsStore.vrcQuitFix) {
|
|
const bias = Date.parse(gameLog.dt) + 3000;
|
|
if (bias < Date.now()) {
|
|
console.log('QuitFix: Bias too low, not killing VRC');
|
|
break;
|
|
}
|
|
AppApi.QuitGame().then((processCount) => {
|
|
if (processCount > 1) {
|
|
console.log(
|
|
'QuitFix: More than 1 process running, not killing VRC'
|
|
);
|
|
} else if (processCount === 1) {
|
|
console.log('QuitFix: Killed VRC');
|
|
} else {
|
|
console.log(
|
|
'QuitFix: Nothing to kill, no VRC process running'
|
|
);
|
|
}
|
|
});
|
|
}
|
|
break;
|
|
case 'openvr-init':
|
|
gameStore.setIsGameNoVR(false);
|
|
configRepository.setBool('isGameNoVR', gameStore.isGameNoVR);
|
|
vrStore.updateOpenVR();
|
|
break;
|
|
case 'desktop-mode':
|
|
gameStore.setIsGameNoVR(true);
|
|
configRepository.setBool('isGameNoVR', gameStore.isGameNoVR);
|
|
vrStore.updateOpenVR();
|
|
break;
|
|
case 'udon-exception':
|
|
if (generalSettingsStore.udonExceptionLogging) {
|
|
console.log('UdonException', gameLog.data);
|
|
}
|
|
// entry = {
|
|
// created_at: gameLog.dt,
|
|
// type: 'Event',
|
|
// data: gameLog.data
|
|
// };
|
|
// database.addGamelogEventToDatabase(entry);
|
|
break;
|
|
case 'sticker-spawn':
|
|
if (!advancedSettingsStore.saveInstanceStickers) {
|
|
break;
|
|
}
|
|
|
|
galleryStore.trySaveStickerToFile(
|
|
gameLog.displayName,
|
|
gameLog.userId,
|
|
gameLog.inventoryId
|
|
);
|
|
break;
|
|
}
|
|
if (typeof entry !== 'undefined') {
|
|
sharedFeedStore.addEntry(entry);
|
|
notificationStore.queueGameLogNoty(entry);
|
|
addGameLog(entry);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
async function getGameLogTable() {
|
|
await database.initTables();
|
|
const dateTill = await database.getLastDateGameLogDatabase();
|
|
updateGameLog(dateTill);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param dateTill
|
|
*/
|
|
async function updateGameLog(dateTill) {
|
|
await gameLogService.setDateTill(dateTill);
|
|
await new Promise((resolve) => {
|
|
workerTimers.setTimeout(resolve, 10000);
|
|
});
|
|
let location = '';
|
|
for (const gameLog of await gameLogService.getAll()) {
|
|
if (gameLog.type === 'location') {
|
|
location = gameLog.location;
|
|
}
|
|
addGameLogEntry(gameLog, location);
|
|
}
|
|
}
|
|
|
|
// use in C#
|
|
/**
|
|
*
|
|
* @param json
|
|
*/
|
|
function addGameLogEvent(json) {
|
|
const rawLogs = JSON.parse(json);
|
|
const gameLog = gameLogService.parseRawGameLog(
|
|
rawLogs[1],
|
|
rawLogs[2],
|
|
rawLogs.slice(3)
|
|
);
|
|
if (
|
|
AppDebug.debugGameLog &&
|
|
gameLog.type !== 'photon-id' &&
|
|
gameLog.type !== 'api-request' &&
|
|
gameLog.type !== 'udon-exception'
|
|
) {
|
|
console.log('gameLog:', gameLog);
|
|
}
|
|
addGameLogEntry(gameLog, locationStore.lastLocation.location);
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
async function disableGameLogDialog() {
|
|
if (gameStore.isGameRunning) {
|
|
toast.error(t('message.gamelog.vrchat_must_be_closed'));
|
|
return;
|
|
}
|
|
if (!advancedSettingsStore.gameLogDisabled) {
|
|
modalStore
|
|
.confirm({
|
|
description: t('confirm.disable_gamelog'),
|
|
title: t('confirm.title')
|
|
})
|
|
.then(({ ok }) => {
|
|
if (!ok) return;
|
|
advancedSettingsStore.setGameLogDisabled();
|
|
})
|
|
.catch(() => {});
|
|
} else {
|
|
advancedSettingsStore.setGameLogDisabled();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
async function initGameLogTable() {
|
|
gameLogTable.value.loading = true;
|
|
const rows = await database.lookupGameLogDatabase(
|
|
gameLogTable.value.filter,
|
|
[]
|
|
);
|
|
for (const row of rows) {
|
|
row.isFriend = gameLogIsFriend(row);
|
|
row.isFavorite = gameLogIsFavorite(row);
|
|
}
|
|
gameLogTableData.value = rows;
|
|
gameLogTable.value.loading = false;
|
|
}
|
|
|
|
return {
|
|
state,
|
|
|
|
nowPlaying,
|
|
gameLogTable,
|
|
gameLogTableData,
|
|
lastVideoUrl,
|
|
lastResourceloadUrl,
|
|
|
|
clearNowPlaying,
|
|
resetLastMediaUrls,
|
|
tryLoadPlayerList,
|
|
gameLogIsFriend,
|
|
gameLogIsFavorite,
|
|
gameLogTableLookup,
|
|
addGameLog,
|
|
addGamelogLocationToDatabase,
|
|
getGameLogTable,
|
|
addGameLogEvent,
|
|
disableGameLogDialog
|
|
};
|
|
});
|