@quenty/conditions 1.0.1-canary.256.8cd6f5a.0

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+## 1.0.1-canary.256.8cd6f5a.0 (2022-03-27)
+
+
+### Features
+
+* Add conditions package ([354f533](https://github.com/Quenty/NevermoreEngine/commit/354f5332c1d63b858ff984509ce2ae9820e1a70f))

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2014-2021 Quenty
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,34 @@
+## Conditions
+<div align="center">
+  <a href="http://quenty.github.io/NevermoreEngine/">
+    <img src="https://github.com/Quenty/NevermoreEngine/actions/workflows/docs.yml/badge.svg" alt="Documentation status" />
+  </a>
+  <a href="https://discord.gg/mhtGUS8">
+    <img src="https://img.shields.io/discord/385151591524597761?color=5865F2&label=discord&logo=discord&logoColor=white" alt="Discord" />
+  </a>
+  <a href="https://github.com/Quenty/NevermoreEngine/actions">
+    <img src="https://github.com/Quenty/NevermoreEngine/actions/workflows/build.yml/badge.svg" alt="Build and release status" />
+  </a>
+</div>
+
+Adornee based conditional system that is sufficiently generic to script gameplay.
+
+<div align="center"><a href="https://quenty.github.io/NevermoreEngine/api/AdorneeConditionUtils">View docs →</a></div>
+
+## Installation
+```
+npm install @quenty/conditions --save
+```
+
+## Design challenges
+
+The issue for conditions is they must be scriptable enough that anything can implement them, including external consumers, but flexibile enough that any gameplay can be constructed with them.
+
+Additionally, we want to observe conditions for an adornee over specifically having them on a loop, so we want to definitely leverage Observables/Rx here.
+
+Finally, there's a networking component here, where we want to define code once, but network it across many places. But we're also latency sensitive for conditions, that is, we should be able to deny actions as soon as they occur on the client.
+
+## Design results
+
+For this reason, we end up with basically just a way to bind functions to a folder. Thus, we're scriptable. To allow replication/avoid duplicate implementation at the server/client layer we'll add another layer here where we'll bind conditions to the client/server.
+

package/default.project.json

@@ -0,0 +1,6 @@
+{
+  "name": "conditions",
+  "tree": {
+    "$path": "src"
+  }
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@quenty/conditions",
+  "version": "1.0.1-canary.256.8cd6f5a.0",
+  "description": "Adornee based conditional system that is sufficiently generic to script gameplay.",
+  "keywords": [
+    "Roblox",
+    "Nevermore",
+    "Lua",
+    "Conditions",
+    "Rx"
+  ],
+  "bugs": {
+    "url": "https://github.com/Quenty/NevermoreEngine/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Quenty/NevermoreEngine.git",
+    "directory": "src/conditions/"
+  },
+  "funding": {
+    "type": "patreon",
+    "url": "https://www.patreon.com/quenty"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@quenty/attributeutils": "5.1.1-canary.256.8cd6f5a.0",
+    "@quenty/brio": "5.1.1-canary.256.8cd6f5a.0",
+    "@quenty/instanceutils": "4.1.1-canary.256.8cd6f5a.0",
+    "@quenty/loader": "4.0.1-canary.256.8cd6f5a.0",
+    "@quenty/maid": "2.2.1-canary.256.8cd6f5a.0",
+    "@quenty/rx": "4.1.1-canary.256.8cd6f5a.0",
+    "@quenty/statestack": "5.2.1-canary.256.8cd6f5a.0",
+    "@quenty/tie": "1.0.1-canary.256.8cd6f5a.0"
+  },
+  "contributors": [
+    "Quenty"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "8cd6f5a870e3e400eb53d147873062111e6ae8ed"
+}

package/src/Shared/AdorneeConditionUtils.lua

@@ -0,0 +1,506 @@
+--[=[
+	Utility library that defines a generalized interface for scriptable conditions. These conditions are rooted in [Rx] and
+	can be scripted by a variety of systems. For example, we may have conditions on what ammo we can consume, or whether
+	or not an action can be activated.
+
+	This library provides an interface for this to happen in. Conditions are marshalled through a BindableFunction and
+	must be defined on both the client and server. However, these conditions can be reactive. It would be very simple
+	to create a condition that also just links to a bool value if conditions should be only on the server.
+
+	```lua
+	local conditionFolder = AdorneeConditionUtils.createConditionContainer()
+	conditionFolder.Parent = workspace
+
+	local orGroup = AdorneeConditionUtils.createOrConditionGroup()
+	orGroup.Parent = conditionFolder
+
+	AdorneeConditionUtils.createRequiredProperty("Name", "Allowed").Parent = orGroup
+
+	local andGroup = AdorneeConditionUtils.createAndConditionGroup()
+	andGroup.Parent = orGroup
+
+	AdorneeConditionUtils.createRequiredProperty("Name", "Allow").Parent = andGroup
+	AdorneeConditionUtils.createRequiredAttribute("IsEnabled", true).Parent = andGroup
+
+	local testInst = Instance.new("Folder")
+	testInst.Name = "Deny"
+	testInst:SetAttribute("IsEnabled", false)
+	testInst.Parent = workspace
+
+	AdorneeConditionUtils.observeConditionsMet(conditionFolder, testInst):Subscribe(function(isAllowed)
+		print("Is allowed", isAllowed)
+	end) --> Is allowed false
+
+	task.delay(0.1, function()
+		testInst.Name = "Allowed" --> Is allowed true
+	end)
+	```
+
+	@class AdorneeConditionUtils
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local CollectionService = game:GetService("CollectionService")
+local RunService = game:GetService("RunService")
+
+local Maid = require("Maid")
+local Observable = require("Observable")
+local Rx = require("Rx")
+local RxAttributeUtils = require("RxAttributeUtils")
+local RxBrioUtils = require("RxBrioUtils")
+local RxInstanceUtils = require("RxInstanceUtils")
+local StateStack = require("StateStack")
+local TieUtils = require("TieUtils")
+local AttributeUtils = require("AttributeUtils")
+
+local VALUE_WHEN_EMPTY_ATTRIBUTE = "ValueWhenEmpty"
+local DEFAULT_VALUE_WHEN_EMPTY_WHEN_UNDEFINED = true
+
+local AdorneeConditionUtils = {}
+
+--[=[
+	Observes whether conditions are met or not.
+
+	```lua
+	AdorneeConditionUtils.observeConditionsMet(gun.AmmoAllowedConditions, ammo):Subscribe(function(allowed)
+		if allowed then
+			print("Can use this ammo to refill this gun")
+		end
+	end)
+	```
+
+	@param conditionObj -- Condition to invoke
+	@param adornee -- Adornee to check conditions on
+	@return Observable<boolean>
+]=]
+function AdorneeConditionUtils.observeConditionsMet(conditionObj: BindableFunction, adornee: Instance)
+	assert(typeof(conditionObj) == "Instance" and conditionObj:IsA("BindableFunction"), "Bad conditionObj")
+	assert(typeof(adornee) == "Instance", "Bad adornee")
+
+	return AdorneeConditionUtils._getObservableFromConditionObj(conditionObj, adornee)
+end
+
+--[=[
+	Promises a query result of whether conditions are met or not. Unlike the observable, this will return
+	a result once all combinations are met.
+
+	@param conditionObj -- Condition to invoke
+	@param adornee -- Adornee to check conditions on
+	@param cancelToken CancelToken?
+	@return Promise<boolean>
+]=]
+function AdorneeConditionUtils.promiseQueryConditionsMet(conditionObj: BindableFunction, adornee: Instance, cancelToken)
+	assert(typeof(conditionObj) == "Instance" and conditionObj:IsA("BindableFunction"), "Bad condition")
+	assert(typeof(adornee) == "Instance", "Bad adornee")
+
+	return Rx.toPromise(AdorneeConditionUtils.observeConditionsMet(conditionObj, adornee, cancelToken))
+end
+
+--[=[
+	Creates a new condition container which conditions can be parented to. By default this is an
+	"and" container, that is, all conditions underneath this container must be met for something to be allowed.
+
+	@return BindableFunction
+]=]
+function AdorneeConditionUtils.createConditionContainer(): BindableFunction
+	local container = AdorneeConditionUtils.createAndConditionGroup()
+	container.Name = "Condition" .. AdorneeConditionUtils.getConditionNamePostfix()
+
+	-- allow by default
+	AdorneeConditionUtils.setValueWhenEmpty(container, true)
+
+	return container
+end
+
+--[=[
+	Creates a new adornee condition
+	@param observeCallback function
+	@return BindableFunction
+]=]
+function AdorneeConditionUtils.create(observeCallback): BindableFunction
+	assert(type(observeCallback) == "function", "Bad observeCallback")
+
+	local condition = Instance.new("BindableFunction")
+	condition.Name = "CustomAdorneeCondition" .. AdorneeConditionUtils.getConditionNamePostfix()
+	condition.OnInvoke = TieUtils.encodeCallback(observeCallback)
+
+	CollectionService:AddTag(condition, AdorneeConditionUtils.getRequiredTag())
+
+	return condition
+end
+
+--[=[
+	Creates a new condition that a property is a set value.
+	@param propertyName string
+	@param requiredValue any
+	@return BindableFunction
+]=]
+function AdorneeConditionUtils.createRequiredProperty(propertyName: string, requiredValue: any): BindableFunction
+	assert(type(propertyName) == "string", "Bad propertyName")
+
+	local condition = AdorneeConditionUtils.create(function(adornee: Instance)
+		return RxInstanceUtils.observeProperty(adornee, propertyName):Pipe({
+			Rx.map(function(value)
+				return value == requiredValue
+			end);
+		})
+	end)
+	condition.Name = ("RequiredProperty%s_%s_%s"):format(
+		AdorneeConditionUtils.getConditionNamePostfix(),
+		tostring(propertyName),
+		tostring(requiredValue))
+
+	return condition
+end
+
+--[=[
+	Creates a new condition that an attribute must be set to the current value
+	@param attributeName string
+	@param attributeValue any
+	@return BindableFunction
+]=]
+function AdorneeConditionUtils.createRequiredAttribute(attributeName: string, attributeValue: any): BindableFunction
+	assert(type(attributeName) == "string", "Bad attributeName")
+
+	local condition = AdorneeConditionUtils.create(function(adornee: Instance)
+		return RxAttributeUtils.observeAttribute(adornee, attributeName):Pipe({
+			Rx.map(function(value)
+				return value == attributeValue
+			end);
+		})
+	end)
+
+	condition.Name = ("RequiredAttribute%s_%s_%s"):format(
+		AdorneeConditionUtils.getConditionNamePostfix(),
+		tostring(attributeName),
+		tostring(attributeValue))
+	return condition
+end
+
+--[=[
+	Creates a new condition that a tie interface must be implemented for the object
+	@param tieInterfaceDefinition TieDefinition
+	@return BindableFunction
+]=]
+function AdorneeConditionUtils.createRequiredTieInterface(tieInterfaceDefinition): BindableFunction
+	assert(tieInterfaceDefinition, "Bad tieInterfaceDefinition")
+
+	local condition = AdorneeConditionUtils.create(function(adornee: Instance)
+		return tieInterfaceDefinition:ObserveIsImplemented(adornee)
+	end)
+
+	condition.Name = ("RequiredInterface%s_%s"):format(
+		AdorneeConditionUtils.getConditionNamePostfix(),
+		tieInterfaceDefinition:GetName())
+
+	return condition
+end
+
+--[=[
+	Creates a new "or" condition group where conditions are "or"ed together.
+	Conditions should be parented underneath this BindableFunction.
+	@return BindableFunction
+]=]
+function AdorneeConditionUtils.createOrConditionGroup(): BindableFunction
+	local container
+	container = AdorneeConditionUtils.create(function(adornee: Instance)
+		assert(container, "Should not be invoking this on construction before container is assigned")
+
+		return AdorneeConditionUtils._observeConditionObservablesBrio(container, adornee)
+			:Pipe({
+				AdorneeConditionUtils._mapToOr(AdorneeConditionUtils.observeValueWhenEmpty(container))
+			})
+	end)
+
+	container.Name = ("OrConditionGroup%s"):format(AdorneeConditionUtils.getConditionNamePostfix())
+	AdorneeConditionUtils.setValueWhenEmpty(container, true)
+
+	return container
+end
+
+--[=[
+	Creates a new "and" condition group where conditions are "and"ed together.
+	Conditions should be parented underneath this BindableFunction.
+	@return BindableFunction
+]=]
+function AdorneeConditionUtils.createAndConditionGroup(): BindableFunction
+	local container
+	container = AdorneeConditionUtils.create(function(adornee: Instance)
+		assert(container, "Should not be invoking this on construction before container is assigned")
+
+		return AdorneeConditionUtils._observeConditionObservablesBrio(container, adornee)
+			:Pipe({
+				AdorneeConditionUtils._mapToAnd(AdorneeConditionUtils.observeValueWhenEmpty(container))
+			})
+	end)
+
+	container.Name = ("AndConditionGroup%s"):format(AdorneeConditionUtils.getConditionNamePostfix())
+	AdorneeConditionUtils.setValueWhenEmpty(container, true)
+
+	return container
+end
+
+--[=[
+	Conditions must be tagged with a specific tag to make sure we don't invoke random code,
+	or code on the wrong host.
+
+	@return string
+]=]
+function AdorneeConditionUtils.getRequiredTag(): string
+	if RunService:IsClient() then
+		return "AdorneeConditionClient"
+	else
+		return "AdorneeCondition"
+	end
+end
+
+--[=[
+	Gets the postfix for the condition name to make it clear to users
+	if this condition is on the server or the client.
+
+	@return string
+]=]
+function AdorneeConditionUtils.getConditionNamePostfix(): string
+	if RunService:IsClient() then
+		return "Client"
+	else
+		return "Server"
+	end
+end
+
+--[=[
+	Sets the default value if we have no value
+
+	@param container BindableFunction
+	@param value boolean -- Value to default to
+]=]
+function AdorneeConditionUtils.setValueWhenEmpty(container, value)
+	assert(typeof(container) == "Instance", "Bad container")
+	assert(type(value) == "boolean", "Bad value")
+
+	container:SetAttribute(VALUE_WHEN_EMPTY_ATTRIBUTE, value)
+end
+
+--[=[
+	Gets the default value on a container when empty
+
+	@param container BindableFunction
+	@return boolean
+]=]
+function AdorneeConditionUtils.getValueWhenEmpty(container: BindableFunction)
+	assert(typeof(container) == "Instance", "Bad container")
+
+	return AttributeUtils.getAttribute(container, VALUE_WHEN_EMPTY_ATTRIBUTE, DEFAULT_VALUE_WHEN_EMPTY_WHEN_UNDEFINED)
+end
+
+--[=[
+	Sets the default value if we have no value
+	@param container BindableFunction
+	@return Observable<boolean>
+]=]
+function AdorneeConditionUtils.observeValueWhenEmpty(container: BindableFunction)
+	assert(typeof(container) == "Instance", "Bad container")
+
+	return RxAttributeUtils.observeAttribute(container, VALUE_WHEN_EMPTY_ATTRIBUTE, DEFAULT_VALUE_WHEN_EMPTY_WHEN_UNDEFINED)
+end
+
+--[[
+	Maps the given object to "and"
+]]
+function AdorneeConditionUtils._mapToAnd(observeValueWhenEmpty)
+	assert(observeValueWhenEmpty, "Bad observeValueWhenEmpty")
+
+	return function(source)
+		assert(source, "No source")
+
+		return Observable.new(function(sub)
+			local topMaid = Maid.new()
+
+			local isDisabled = StateStack.new(false)
+			topMaid:GiveTask(isDisabled)
+
+			local activeSourceCount = Instance.new("IntValue")
+			activeSourceCount.Value = 0
+			topMaid:GiveTask(activeSourceCount)
+
+			local totalState = Instance.new("BoolValue")
+			totalState.Value = false
+			topMaid:GiveTask(totalState)
+
+			local valueWhenEmpty = Instance.new("BoolValue")
+			valueWhenEmpty.Value = DEFAULT_VALUE_WHEN_EMPTY_WHEN_UNDEFINED
+			topMaid:GiveTask(observeValueWhenEmpty:Subscribe(function(defaultValue)
+				valueWhenEmpty.Value = defaultValue
+			end))
+
+			local function update()
+				if activeSourceCount.Value == 0 then
+					totalState.Value = valueWhenEmpty.Value
+				else
+					totalState.Value = not isDisabled:GetState()
+				end
+			end
+			topMaid:GiveTask(valueWhenEmpty.Changed:Connect(update))
+			topMaid:GiveTask(activeSourceCount.Changed:Connect(update))
+			topMaid:GiveTask(isDisabled.Changed:Connect(update))
+			update()
+
+			topMaid:GiveTask(source:Subscribe(function(observableBrio)
+				if observableBrio:IsDead() then
+					return
+				end
+
+				local observable = observableBrio:GetValue()
+				local observableMaid = observableBrio:ToMaid()
+
+				activeSourceCount.Value = activeSourceCount.Value + 1
+				observableMaid:GiveTask(function()
+					activeSourceCount.Value = activeSourceCount.Value - 1
+				end)
+
+				observableMaid:GiveTask(observable:Subscribe(function(state)
+					if state then
+						observableMaid._state = nil
+					else
+						observableMaid._state = isDisabled:PushState(true)
+					end
+				end))
+
+			end), sub:GetFailComplete())
+
+			topMaid:GiveTask(totalState.Changed:Connect(function()
+				sub:Fire(totalState.Value)
+			end))
+			sub:Fire(totalState.Value)
+
+			return topMaid
+		end)
+	end
+end
+
+--[[
+	Maps the given object to "or"
+]]
+function AdorneeConditionUtils._mapToOr(observeValueWhenEmpty)
+	assert(observeValueWhenEmpty, "Bad observeValueWhenEmpty")
+
+	return function(source)
+		assert(source, "No source")
+
+		return Observable.new(function(sub)
+			local topMaid = Maid.new()
+
+			local isEnabled = StateStack.new(false)
+			topMaid:GiveTask(isEnabled)
+
+			local activeSourceCount = Instance.new("IntValue")
+			activeSourceCount.Value = 0
+			topMaid:GiveTask(activeSourceCount)
+
+			local totalState = Instance.new("BoolValue")
+			totalState.Value = false
+			topMaid:GiveTask(totalState)
+
+			local valueWhenEmpty = Instance.new("BoolValue")
+			valueWhenEmpty.Value = DEFAULT_VALUE_WHEN_EMPTY_WHEN_UNDEFINED
+			topMaid:GiveTask(observeValueWhenEmpty:Subscribe(function(defaultValue)
+				valueWhenEmpty.Value = defaultValue
+			end))
+
+			local function update()
+				if activeSourceCount.Value == 0 then
+					totalState.Value = valueWhenEmpty.Value
+				else
+					totalState.Value = isEnabled:GetState()
+				end
+			end
+			topMaid:GiveTask(valueWhenEmpty.Changed:Connect(update))
+			topMaid:GiveTask(activeSourceCount.Changed:Connect(update))
+			topMaid:GiveTask(isEnabled.Changed:Connect(update))
+			update()
+
+			topMaid:GiveTask(source:Subscribe(function(observableBrio)
+				if observableBrio:IsDead() then
+					return
+				end
+
+				local observable = observableBrio:GetValue()
+				local observableMaid = observableBrio:ToMaid()
+
+				activeSourceCount.Value = activeSourceCount.Value + 1
+				observableMaid:GiveTask(function()
+					activeSourceCount.Value = activeSourceCount.Value - 1
+				end)
+
+				observableMaid:GiveTask(observable:Subscribe(function(state)
+					if state then
+						observableMaid._state = isEnabled:PushState(true)
+					else
+						observableMaid._state = nil
+					end
+				end))
+
+			end), sub:GetFailComplete())
+
+			topMaid:GiveTask(totalState.Changed:Connect(function()
+				sub:Fire(totalState.Value)
+			end))
+			sub:Fire(totalState.Value)
+
+			return topMaid
+		end)
+	end
+end
+
+--[[
+	Observes all of the conditions under a given parent
+
+	@return Observable<Observable<boolean>>
+]]
+function AdorneeConditionUtils._observeConditionObservablesBrio(parent: Instance, adornee: Instance)
+	assert(typeof(parent) == "Instance", "Bad parent")
+	assert(typeof(adornee) == "Instance", "Bad adornee")
+
+	return RxInstanceUtils.observeChildrenBrio(parent, function(child)
+		return child:IsA("BindableFunction") and CollectionService:HasTag(child, AdorneeConditionUtils.getRequiredTag())
+	end)
+		:Pipe({
+			RxBrioUtils.map(function(conditionObj)
+				return AdorneeConditionUtils._getObservableFromConditionObj(conditionObj, adornee)
+			end);
+		});
+end
+
+--[[
+	Tries to extract the condition observable from a given condition. This invokes the bindable
+	and will warn if the invocation yields.
+
+	@return Observable<boolean>
+]]
+function AdorneeConditionUtils._getObservableFromConditionObj(conditionObj: Instance, adornee: Instance)
+	local observable
+	local current
+	task.spawn(function()
+		current = coroutine.running()
+		observable = TieUtils.invokeEncodedBindableFunction(conditionObj, adornee)
+	end)
+
+	-- TODO: Allow yielding here
+	if coroutine.status(current) ~= "dead" then
+		warn(("[AdorneeConditionUtils.observeAllowed] - Getting condition yielded from %q")
+			:format(conditionObj:GetFullName()))
+		return Rx.EMPTY
+	end
+
+	-- TODO: Allow non-observables.
+	if not (observable and Observable.isObservable(observable)) then
+		warn(("[AdorneeConditionUtils.observeAllowed] - Failed to get observable from %q. Got %q")
+			:format(conditionObj:GetFullName(), tostring(observable)))
+		return Rx.EMPTY
+	end
+
+	return observable
+end
+
+return AdorneeConditionUtils

package/src/node_modules.project.json

@@ -0,0 +1,7 @@
+{
+  "name": "node_modules",
+  "globIgnorePaths": [ "**/.package-lock.json" ],
+  "tree": {
+    "$path": { "optional": "../node_modules" }
+  }
+}

package/test/default.project.json

@@ -0,0 +1,21 @@
+{
+  "name": "ConditionTest",
+  "tree": {
+    "$className": "DataModel",
+    "ServerScriptService": {
+      "conditions": {
+        "$path": ".."
+      },
+      "Script": {
+        "$path": "scripts/Server"
+      }
+    },
+    "StarterPlayer": {
+      "StarterPlayerScripts": {
+        "Main": {
+          "$path": "scripts/Client"
+        }
+      }
+    }
+  }
+}

package/test/scripts/Client/ClientMain.client.lua

@@ -0,0 +1,13 @@
+--[[
+	@class ClientMain
+]]
+local packages = game:GetService("ReplicatedStorage"):WaitForChild("Packages")
+
+local serviceBag = require(packages.ServiceBag).new()
+serviceBag:GetService(packages.AimLockServiceClient)
+
+-- Start game
+serviceBag:Init()
+serviceBag:Start()
+
+serviceBag:GetService(packages.AimLockServiceClient):SetUserControlsEnabled(true)

package/test/scripts/Server/ServerMain.server.lua

@@ -0,0 +1,66 @@
+--[[
+	@class ServerMain
+]]
+local ServerScriptService = game:GetService("ServerScriptService")
+
+local loader = ServerScriptService:FindFirstChild("LoaderUtils", true).Parent
+local packages = require(loader).bootstrapGame(ServerScriptService.conditions)
+
+local AdorneeConditionUtils = require(packages.AdorneeConditionUtils)
+local TieDefinition = require(packages.TieDefinition)
+local AttributeValue = require(packages.AttributeValue)
+
+do
+	local conditionFolder = AdorneeConditionUtils.createConditionContainer()
+	conditionFolder.Parent = workspace
+
+	local orGroup = AdorneeConditionUtils.createOrConditionGroup()
+	orGroup.Parent = conditionFolder
+
+	AdorneeConditionUtils.createRequiredProperty("Name", "Allowed").Parent = orGroup
+
+	local andGroup = AdorneeConditionUtils.createAndConditionGroup()
+	andGroup.Parent = orGroup
+
+	AdorneeConditionUtils.createRequiredProperty("Name", "Allow").Parent = andGroup
+	AdorneeConditionUtils.createRequiredAttribute("IsEnabled", true).Parent = andGroup
+
+	local testInst = Instance.new("Folder")
+	testInst.Name = "Deny"
+	testInst:SetAttribute("IsEnabled", false)
+	testInst.Parent = workspace
+
+	AdorneeConditionUtils.observeConditionsMet(conditionFolder, testInst):Subscribe(function(isAllowed)
+		print("Is allowed", isAllowed)
+	end)
+
+	task.delay(0.1, function()
+		testInst.Name = "Allowed"
+	end)
+end
+
+-- Test tie integration
+do
+	local door = Instance.new("Folder")
+	door.Name = "Door"
+	door.Parent = workspace
+
+
+	local openableInterface = TieDefinition.new("Openable", {
+		IsOpen = TieDefinition.Types.PROPERTY;
+	})
+	openableInterface:Implement(door, {
+		IsOpen = AttributeValue.new(door, "IsOpen", false);
+	})
+
+	local canOpenCondition = AdorneeConditionUtils.createConditionContainer()
+	canOpenCondition.Name = "CanOpenCondition"
+	canOpenCondition.Parent = workspace
+
+	AdorneeConditionUtils.createRequiredTieInterface(openableInterface).Parent = canOpenCondition
+	AdorneeConditionUtils.createRequiredAttribute("IsOpen", false).Parent = canOpenCondition
+
+	AdorneeConditionUtils.observeConditionsMet(canOpenCondition, door):Subscribe(function(isAllowed)
+		print("Is door opening allowed", isAllowed)
+	end)
+end