work on __resource -> fxmanifest and RDR compatibility

resources/[system]/[builders]/webpack/__resource.lua

@@ -1,3 +0,0 @@
-dependency 'yarn'
---server_only 'yes'
-server_script 'webpack_builder.js'

resources/[system]/[builders]/webpack/fxmanifest.lua

@@ -0,0 +1,5 @@
+dependency 'yarn'
+server_script 'webpack_builder.js'
+
+fx_version 'adamant'
+game 'common'

resources/[system]/[builders]/yarn/__resource.lua

@@ -1,2 +0,0 @@
---server_only 'yes'
-server_script 'yarn_builder.js'

resources/[system]/[builders]/yarn/fxmanifest.lua

@@ -0,0 +1,4 @@
+fx_version 'adamant'
+game 'common'
+
+server_script 'yarn_builder.js'

resources/[system]/[builders]/yarn/yarn_builder.js

@@ -41,7 +41,7 @@ const yarnBuildTask = {
 			currentBuildingModule = resourceName;
 			const process = child_process.fork(
 				require.resolve('./yarn_cli.js'),
-				['install'],
+				['install', '--ignore-scripts'],
 				{
 					cwd: path.resolve(GetResourcePath(resourceName))
 				});

resources/[system]/hardcap/__resource.lua

@@ -1,2 +0,0 @@
-client_script 'client.lua'
-server_script 'server.lua'

resources/[system]/hardcap/fxmanifest.lua

@@ -0,0 +1,6 @@
+client_script 'client.lua'
+server_script 'server.lua'
+
+fx_version 'adamant'
+games { 'gta5', 'rdr3' }
+rdr3_warning 'I acknowledge that this is a prerelease build of RedM, and I am aware my resources *will* become incompatible once RedM ships.'

resources/[system]/rconlog/__resource.lua

@@ -1,2 +0,0 @@
-client_script 'rconlog_client.lua'
-server_script 'rconlog_server.lua'

resources/[system]/rconlog/fxmanifest.lua

@@ -0,0 +1,7 @@
+client_script 'rconlog_client.lua'
+server_script 'rconlog_server.lua'
+
+fx_version 'adamant'
+games { 'gta5', 'rdr3' }
+
+rdr3_warning 'I acknowledge that this is a prerelease build of RedM, and I am aware my resources *will* become incompatible once RedM ships.'

resources/[system]/scoreboard/fxmanifest.lua

@@ -15,4 +15,7 @@ files {
     'html/res/futurastd-medium.woff',
     'html/res/futurastd-medium.ttf',
     'html/res/futurastd-medium.svg',
-}
+}
+
+fx_version 'adamant'
+game 'gta5'

resources/[system]/scoreboard/scoreboard.lua

@@ -8,7 +8,7 @@ Citizen.CreateThread(function()
         if IsControlPressed(0, 27)--[[ INPUT_PHONE ]] then
             if not listOn then
                 local players = {}
-                ptable = GetPlayers()
+                local ptable = GetActivePlayers()
                 for _, i in ipairs(ptable) do
                     local wantedLevel = GetPlayerWantedLevel(i)
                     r, g, b = GetPlayerRgbColour(i)
@@ -35,18 +35,6 @@ Citizen.CreateThread(function()
     end
 end)
 
-function GetPlayers()
-    local players = {}
-
-    for i = 0, 31 do
-        if NetworkIsPlayerActive(i) then
-            table.insert(players, i)
-        end
-    end
-
-    return players
-end
-
 function sanitize(txt)
     local replacements = {
         ['&' ] = '&', 

resources/[system]/sessionmanager-rdr3/.gitignore

@@ -0,0 +1,2 @@
+node_modules/
+yarn.lock

resources/[system]/sessionmanager-rdr3/fxmanifest.lua

@@ -0,0 +1,8 @@
+fx_version 'adamant'
+game 'common'
+
+dependencies {
+	'yarn'
+}
+
+server_script 'sm_server.js'

resources/[system]/sessionmanager-rdr3/package.json

@@ -0,0 +1,6 @@
+{
+  "private": true,
+  "dependencies": {
+	"@citizenfx/protobufjs": "6.8.8"
+  }
+}

resources/[system]/sessionmanager-rdr3/rline.proto

@@ -0,0 +1,169 @@
+syntax = "proto3";
+package rline;
+
+message RpcErrorData {
+	string ErrorCodeString = 1;
+	int32 ErrorCode = 2;
+	string DomainString = 3;
+	int32 DomainCode = 4;
+	bytes DataEx = 5;
+};
+
+message RpcError {
+	int32 ErrorCode = 1;
+	string ErrorMessage = 2;
+	RpcErrorData Data = 3;
+};
+
+message RpcHeader {
+	string RequestId = 1;
+	string MethodName = 2;
+	RpcError Error = 3;
+	string srcTid = 4;
+};
+
+message RpcMessage {
+	RpcHeader Header = 1;
+	bytes Content = 2;
+};
+
+message RpcResponseContainer {
+	bytes Content = 1;
+};
+
+message RpcResponseMessage {
+	RpcHeader Header = 1;
+	RpcResponseContainer Container = 2;
+};
+
+message TokenStuff {
+	string tkn = 1;
+};
+
+message InitSessionResponse {
+	bytes sesid = 1;
+	TokenStuff token = 2;
+};
+
+message MpGamerHandleDto {
+	string gh = 1;
+};
+
+message MpPeerAddressDto {
+	string addr = 1;
+};
+
+message InitPlayer2_Parameters {
+	MpGamerHandleDto gh = 1;
+	MpPeerAddressDto peerAddress = 2;
+	int32 discriminator = 3;
+	int32 seamlessType = 4;
+	uint32 connectionReason = 5;
+};
+
+message InitPlayerResult {
+	uint32 code = 1;
+};
+
+message Restriction {
+	int32 u1 = 1;
+	int32 u2 = 2;
+	int32 u3 = 3;
+}
+
+message GetRestrictionsData {
+	repeated Restriction restriction = 1;
+	repeated string unk2 = 2;
+};
+
+message GetRestrictionsResult {
+	GetRestrictionsData data = 1;
+};
+
+message PlayerIdSto {
+	int32 acctId = 1;
+	int32 platId = 2;
+};
+
+message MpSessionRequestIdDto {
+	PlayerIdSto requestor = 1;
+	int32 index = 2;
+	int32 hash = 3;
+};
+
+message QueueForSession_Seamless_Parameters {
+	MpSessionRequestIdDto requestId = 1;
+	uint32 optionFlags = 2;
+	int32 x = 3;
+	int32 y = 4;
+};
+
+message QueueForSessionResult {
+	uint32 code = 1;
+};
+
+message QueueEntered_Parameters {
+	uint32 queueGroup = 1;
+	MpSessionRequestIdDto requestId = 2;
+	uint32 optionFlags = 3;
+};
+
+message GuidDto {
+	fixed64 a = 1;
+	fixed64 b = 2;
+};
+
+message MpTransitionIdDto {
+	GuidDto value = 1;
+};
+
+message MpSessionIdDto {
+	GuidDto value = 1;
+};
+
+message SessionSubcommandEnterSession {
+	int32 index = 1;
+	int32 hindex = 2;
+	uint32 sessionFlags = 3;
+	uint32 mode = 4;
+	int32 size = 5;
+	int32 teamIndex = 6;
+	MpTransitionIdDto transitionId = 7;
+	uint32 sessionManagerType = 8;
+	int32 slotCount = 9;
+};
+
+message SessionSubcommandLeaveSession {
+	uint32 reason = 1;
+};
+
+message SessionSubcommandAddPlayer {
+	PlayerIdSto id = 1;
+	MpGamerHandleDto gh = 2;
+	MpPeerAddressDto addr = 3;
+	int32 index = 4;
+};
+
+message SessionSubcommandRemovePlayer {
+	PlayerIdSto id = 1;
+};
+
+message SessionSubcommandHostChanged {
+	int32 index = 1;
+};
+
+message SessionCommand {
+	uint32 cmd = 1;
+	string cmdname = 2;
+	SessionSubcommandEnterSession EnterSession = 3;
+	SessionSubcommandLeaveSession LeaveSession = 4;
+	SessionSubcommandAddPlayer AddPlayer = 5;
+	SessionSubcommandRemovePlayer RemovePlayer = 6;
+	SessionSubcommandHostChanged HostChanged = 7;
+};
+
+message scmds_Parameters {
+	MpSessionIdDto sid = 1;
+	int32 ncmds = 2;
+	repeated SessionCommand cmds = 3;
+};

resources/[system]/sessionmanager-rdr3/sm_server.js

@@ -0,0 +1,276 @@
+const protobuf = require("@citizenfx/protobufjs");
+
+const playerDatas = {};
+let slotsUsed = 0;
+
+function assignSlotId() {
+	for (let i = 0; i < 32; i++) {
+		if (!(slotsUsed & (1 << i))) {
+			slotsUsed |= (1 << i);
+			return i;
+		}
+	}
+	
+	return -1;
+}
+
+let hostIndex = -1;
+
+protobuf.load(GetResourcePath(GetCurrentResourceName()) + "/rline.proto", function(err, root) {
+	if (err) {
+		console.log(err);
+		return;
+	}
+	
+	const RpcMessage = root.lookupType("rline.RpcMessage");
+	const RpcResponseMessage = root.lookupType("rline.RpcResponseMessage");
+	const InitSessionResponse = root.lookupType("rline.InitSessionResponse");
+	const InitPlayer2_Parameters = root.lookupType("rline.InitPlayer2_Parameters");
+	const InitPlayerResult = root.lookupType("rline.InitPlayerResult");
+	const GetRestrictionsResult = root.lookupType("rline.GetRestrictionsResult");
+	const QueueForSession_Seamless_Parameters = root.lookupType("rline.QueueForSession_Seamless_Parameters");
+	const QueueForSessionResult = root.lookupType("rline.QueueForSessionResult");
+	const QueueEntered_Parameters = root.lookupType("rline.QueueEntered_Parameters");
+	const scmds_Parameters = root.lookupType("rline.scmds_Parameters");
+
+	function toArrayBuffer(buf) {
+		var ab = new ArrayBuffer(buf.length);
+		var view = new Uint8Array(ab);
+		for (var i = 0; i < buf.length; ++i) {
+			view[i] = buf[i];
+		}
+		return ab;
+	}
+
+	function emitMsg(target, data) {
+		emitNet('__cfx_internal:pbRlScSession', target, toArrayBuffer(data));
+	}
+
+	function emitSessionCmds(target, cmd, cmdname, msg) {
+		const stuff = {};
+		stuff[cmdname] = msg;
+	
+		emitMsg(target, RpcMessage.encode({
+			Header: {
+				MethodName: 'scmds'
+			},
+			Content: scmds_Parameters.encode({
+				sid: {
+					value: {
+						a: 2,
+						b: 2
+					}
+				},
+				ncmds: 1,
+				cmds: [
+					{
+						cmd,
+						cmdname,
+						...stuff
+					}
+				]
+			}).finish()
+		}).finish());
+	}
+
+	function emitAddPlayer(target, msg) {
+		emitSessionCmds(target, 2, 'AddPlayer', msg);
+	}
+	
+	function emitRemovePlayer(target, msg) {
+		emitSessionCmds(target, 3, 'RemovePlayer', msg);
+	}
+	
+	function emitHostChanged(target, msg) {
+		emitSessionCmds(target, 5, 'HostChanged', msg);
+	}
+	
+	onNet('playerDropped', () => {
+		try {
+			const oData = playerDatas[source];
+			delete playerDatas[source];
+
+			if (oData && hostIndex === oData.slot) {
+				const pda = Object.entries(playerDatas);
+				
+				if (pda.length > 0) {
+					hostIndex = pda[0][1].slot | 0; // TODO: actually use <=31 slot index *and* check for id
+					
+					for (const [ id, data ] of Object.entries(playerDatas)) {
+						emitHostChanged(id, {
+							index: hostIndex
+						});
+					}
+				} else {
+					hostIndex = -1;
+				}
+			}
+			
+			if (!oData) {
+				return;
+			}
+			
+			if (oData.slot > -1) {
+				slotsUsed &= ~(1 << oData.slot);
+			}
+		
+			for (const [ id, data ] of Object.entries(playerDatas)) {
+				emitRemovePlayer(id, {
+					id: oData.id
+				});
+			}
+		} catch (e) {
+			console.log(e);
+			console.log(e.stack);
+		}
+	});
+	
+	function makeResponse(type, data) {
+		return {
+			Header: {
+			},
+			Container: {
+				Content: type.encode(data).finish()
+			}
+		};
+	}
+
+	const handlers = {
+		async InitSession(source, data) {
+			return makeResponse(InitSessionResponse, {
+				sesid: Buffer.alloc(16),
+				/*token: {
+					tkn: 'ACSTOKEN token="meow",signature="meow"'
+				}*/
+			});
+		},
+		
+		async InitPlayer2(source, data) {
+			const req = InitPlayer2_Parameters.decode(data);
+			
+			playerDatas[source] = {
+				gh: req.gh,
+				peerAddress: req.peerAddress,
+				discriminator: req.discriminator,
+				slot: -1
+			};
+			
+			return makeResponse(InitPlayerResult, {
+				code: 0
+			});
+		},
+		
+		async GetRestrictions(source, data) {
+			return makeResponse(GetRestrictionsResult, {
+				data: {
+				
+				}
+			});
+		},
+		
+		async ConfirmSessionEntered(source, data) {
+			return {};
+		},
+		
+		async QueueForSession_Seamless(source, data) {
+			const req = QueueForSession_Seamless_Parameters.decode(data);
+			
+			playerDatas[source].req = req.requestId;
+			playerDatas[source].id = req.requestId.requestor;
+			playerDatas[source].slot = assignSlotId();
+			
+			setTimeout(() => {
+				emitMsg(source, RpcMessage.encode({
+					Header: {
+						MethodName: 'QueueEntered'
+					},
+					Content: QueueEntered_Parameters.encode({
+						queueGroup: 69,
+						requestId: req.requestId,
+						optionFlags: req.optionFlags
+					}).finish()
+				}).finish());
+				
+				if (hostIndex === -1) {
+					hostIndex = playerDatas[source].slot | 0;
+				}
+				
+				emitSessionCmds(source, 0, 'EnterSession', {
+					index: playerDatas[source].slot | 0,
+					hindex: hostIndex,
+					sessionFlags: 0,
+					mode: 0,
+					size: Object.entries(playerDatas).filter(a => a[1].id).length,
+					//size: 2,
+					//size: Object.entries(playerDatas).length,
+					teamIndex: 0,
+					transitionId: {
+						value: {
+							a: 0,//2,
+							b: 0
+						}
+					},
+					sessionManagerType: 0,
+					slotCount: 32
+				});
+				
+				setTimeout(() => {
+					// tell player about everyone, and everyone about player
+					const meData = playerDatas[source];
+					
+					const aboutMe = {
+						id: meData.id,
+						gh: meData.gh,
+						addr: meData.peerAddress,
+						index: playerDatas[source].slot | 0
+					};
+					
+					for (const [ id, data ] of Object.entries(playerDatas)) {
+						if (id == source || !data.id) continue;
+					
+						emitAddPlayer(source, {
+							id: data.id,
+							gh: data.gh,
+							addr: data.peerAddress,
+							index: data.slot | 0
+						});
+						
+						emitAddPlayer(id, aboutMe);
+					}
+				}, 150);
+			}, 50);
+			
+			return makeResponse(QueueForSessionResult, {
+				code: 1
+			});
+		},
+	};
+
+	async function handleMessage(source, method, data) {
+		if (handlers[method]) {
+			return await handlers[method](source, data);
+		}
+
+		return {};
+	}
+	
+	onNet('__cfx_internal:pbRlScSession', async (data) => {
+		const s = source;
+		
+		try {
+			const message = RpcMessage.decode(new Uint8Array(data));
+			const response = await handleMessage(s, message.Header.MethodName, message.Content);
+			
+			if (!response || !response.Header) {
+				return;
+			}
+			
+			response.Header.RequestId = message.Header.RequestId;
+			
+			emitMsg(s, RpcResponseMessage.encode(response).finish());
+		} catch (e) {
+			console.log(e);
+			console.log(e.stack);
+		}
+	});
+});