@quenty/rogue-properties 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 RogueProperty package ([87114a1](https://github.com/Quenty/NevermoreEngine/commit/87114a11e33015e4eccf7d907ac2fce2e2d889c0))

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,35 @@
+## RogueProperties
+<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>
+
+<div align="center"><a href="https://quenty.github.io/NevermoreEngine/api/RogueProperty">View docs →</a></div>
+
+Roguelike properties which can be modified by external provides -- and that modification can be attributed to a source.
+
+## Installation
+```
+npm install @quenty/rogueproperties --save
+```
+
+## Design goals
+We need a property system for a rogue-like or MMORPG style game that offers the following attributes.
+
+1. Modifiable - Can modify a base property in a variety of ways (additive, multiplicative, et cetera)
+2. Attributable - Can attribute the source of final computation, especially for UI.
+3. Extensible - Can combine properties
+4. Grounded in Roblox datamodel - Source of truth exists in Roblox so other people can modify it
+5. Performant - Needs to run fast
+6. Agnostic to server/client - Needs to be able to centralize in datatable.
+7. Scriptable - Need to be able to apply weird scripts to data.
+8. Levelable - Can scale with level!
+9. Usable for other people - The computed value is just .Value under the object!
+

package/default.project.json

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

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@quenty/rogue-properties",
+  "version": "1.0.1-canary.256.8cd6f5a.0",
+  "description": "Roguelike properties which can be modified by external provides",
+  "keywords": [
+    "Roblox",
+    "Nevermore",
+    "Lua"
+  ],
+  "bugs": {
+    "url": "https://github.com/Quenty/NevermoreEngine/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Quenty/NevermoreEngine.git",
+    "directory": "src/rogue-properties/"
+  },
+  "funding": {
+    "type": "patreon",
+    "url": "https://www.patreon.com/quenty"
+  },
+  "license": "MIT",
+  "contributors": [
+    "Quenty"
+  ],
+  "dependencies": {
+    "@quenty/baseobject": "4.1.1-canary.256.8cd6f5a.0",
+    "@quenty/binder": "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/jsonutils": "4.1.1-canary.256.8cd6f5a.0",
+    "@quenty/linkutils": "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/rxbinderutils": "5.1.1-canary.256.8cd6f5a.0",
+    "@quenty/servicebag": "4.1.1-canary.256.8cd6f5a.0",
+    "@quenty/signal": "2.1.1-canary.256.8cd6f5a.0",
+    "@quenty/table": "2.1.2-canary.256.8cd6f5a.0",
+    "@quenty/valuebaseutils": "4.1.1-canary.256.8cd6f5a.0",
+    "@quentystudios/t": "^1.2.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "8cd6f5a870e3e400eb53d147873062111e6ae8ed"
+}

package/src/Shared/Definition/RoguePropertyDefinition.lua

@@ -0,0 +1,97 @@
+--[=[
+	@class RoguePropertyDefinition
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local BaseObject = require("BaseObject")
+local RogueProperty = require("RogueProperty")
+local ServiceBag = require("ServiceBag")
+local RoguePropertyUtils = require("RoguePropertyUtils")
+
+local RoguePropertyDefinition = setmetatable({}, BaseObject)
+RoguePropertyDefinition.ClassName = "RoguePropertyDefinition"
+RoguePropertyDefinition.__index = RoguePropertyDefinition
+
+function RoguePropertyDefinition.new(name, defaultValue, roguePropertyTableDefinition)
+	local self = setmetatable(BaseObject.new(), RoguePropertyDefinition)
+
+	assert(defaultValue ~= nil, "Bad defaultValue")
+
+	self._name = assert(name, "Bad name")
+	self._defaultValue = defaultValue
+	self._valueType = typeof(self._defaultValue)
+	self._storageType = self:_computeStorageInstanceType()
+	self._roguePropertyTableDefinition = roguePropertyTableDefinition or nil
+	self._encodedDefaultValue = RoguePropertyUtils.encodeProperty(self, self._defaultValue)
+
+	return self
+end
+
+--[=[
+	@param serviceBag ServiceBag
+	@param adornee Instance
+	@return RogueProperty
+]=]
+function RoguePropertyDefinition:Get(serviceBag, adornee)
+	assert(ServiceBag.isServiceBag(serviceBag), "Bad serviceBag")
+	assert(typeof(adornee) == "Instance", "Bad adornee")
+
+	return RogueProperty.new(adornee, serviceBag, self)
+end
+
+
+function RoguePropertyDefinition:GetPropertyTableDefinition()
+	return self._roguePropertyTableDefinition
+end
+
+--[=[
+	Gets the name of the rogue property
+	@return string
+]=]
+function RoguePropertyDefinition:GetName(): string
+	return self._name
+end
+
+--[=[
+	Gets the default value for the property
+	@return TProperty
+]=]
+function RoguePropertyDefinition:GetDefaultValue()
+	return self._defaultValue
+end
+
+function RoguePropertyDefinition:GetValueType()
+	return self._valueType
+end
+
+function RoguePropertyDefinition:GetStorageInstanceType()
+	return self._storageType
+end
+
+function RoguePropertyDefinition:GetEncodedDefaultValue()
+	return rawget(self, "_encodedDefaultValue")
+end
+
+function RoguePropertyDefinition:_computeStorageInstanceType()
+	if self._valueType == "string" or self._valueType == "table" then
+		return "StringValue"
+	elseif self._valueType == "number" then
+		return "NumberValue"
+	elseif self._valueType == "boolean" then
+		return "BoolValue"
+	elseif self._valueType == "Color3" then
+		return "Color3Value"
+	elseif self._valueType == "BrickColor" then
+		return "BrickColorValue"
+	elseif self._valueType == "Vector3" then
+		return "Vector3Value"
+	elseif self._valueType == "CFrame" then
+		return "CFrameValue"
+	else
+		error(("Unknown valueType %q"):format(tostring(self._valueType)))
+	end
+end
+
+
+return RoguePropertyDefinition

package/src/Shared/Definition/RoguePropertyTableDefinition.lua

@@ -0,0 +1,139 @@
+--[=[
+	This holds the definition for a variety of tables.
+	@class RoguePropertyTableDefinition
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local RoguePropertyTable = require("RoguePropertyTable")
+local ServiceBag = require("ServiceBag")
+local RoguePropertyDefinition = require("RoguePropertyDefinition")
+local RxInstanceUtils = require("RxInstanceUtils")
+local RoguePropertyService = require("RoguePropertyService")
+
+local RoguePropertyTableDefinition = {}
+RoguePropertyTableDefinition.ClassName = "RoguePropertyTableDefinition"
+RoguePropertyTableDefinition.__index = RoguePropertyTableDefinition
+
+function RoguePropertyTableDefinition.new(tableName: string, propertyDefinition: {[string]: any})
+	local self = setmetatable({}, RoguePropertyTableDefinition)
+
+	assert(type(tableName) == "string", "Bad tableName")
+	assert(type(propertyDefinition) == "table", "Bad propertyDefinition")
+
+	self._tableName = tableName
+	self._definitionMap = {}
+
+	for key, defaultValue in pairs(propertyDefinition) do
+		self._definitionMap[key] = RoguePropertyDefinition.new(key, defaultValue, self)
+	end
+
+	return self
+end
+
+--[=[
+	Gets the name of the rogue property table
+	@return string
+]=]
+function RoguePropertyTableDefinition:GetName(): string
+	return self._tableName
+end
+
+function RoguePropertyTableDefinition:GetDefinitionMap()
+	return self._definitionMap
+end
+
+--[=[
+	Gets the RoguePropertyDefinition if it exists
+	@param propertyName
+	@return RoguePropertyDefinition?
+]=]
+function RoguePropertyTableDefinition:GetDefinition(propertyName: string)
+	assert(type(propertyName) == "string", "Bad propertyName")
+
+	local definitions = rawget(self, "_definitionMap")
+	return definitions[propertyName]
+end
+
+--[=[
+	Gets a new property table for a given object, which can compute the modified
+	value of the adornee. This will initialize the properties on the server.
+
+	@param serviceBag ServiceBag
+	@param adornee Instance
+	@return RoguePropertyTable
+]=]
+function RoguePropertyTableDefinition:GetPropertyTable(serviceBag, adornee)
+	assert(ServiceBag.isServiceBag(serviceBag), "Bad serviceBag")
+	assert(typeof(adornee) == "Instance", "Bad adornee")
+
+	return RoguePropertyTable.new(adornee, serviceBag, self)
+end
+
+--[=[
+	Observes the current container while it exists for the given adornee.
+
+	@param serviceBag ServiceBag
+	@param adornee Instance
+	@return Observable<Brio<Folder>>
+]=]
+function RoguePropertyTableDefinition:ObserveContainerBrio(serviceBag, adornee)
+	assert(ServiceBag.isServiceBag(serviceBag), "Bad serviceBag")
+	assert(typeof(adornee) == "Instance", "Bad adornee")
+
+	-- TODO: Optimize so we aren't duplcating this logic each time we index a property
+	if serviceBag:GetService(RoguePropertyService):CanInitializeProperties() then
+		self:_ensureContainer(adornee)
+	end
+
+	return RxInstanceUtils.observeLastNamedChildBrio(adornee, "Folder", self._tableName)
+end
+
+--[=[
+	Gets the current container for the given adornee.
+	@param serviceBag ServiceBag
+	@param adornee Instance
+	@return Folder?
+]=]
+function RoguePropertyTableDefinition:GetContainer(serviceBag, adornee)
+	assert(ServiceBag.isServiceBag(serviceBag), "Bad serviceBag")
+	assert(typeof(adornee) == "Instance", "Bad adornee")
+
+	if serviceBag:GetService(RoguePropertyService):CanInitializeProperties() then
+		return self:_ensureContainer(adornee)
+	else
+		return adornee:FindFirstChild(self._tableName)
+	end
+end
+
+function RoguePropertyTableDefinition:_ensureContainer(adornee)
+	local existing = adornee:FindFirstChild(self._tableName)
+	if existing then
+		return existing
+	end
+
+	local folder = Instance.new("Folder")
+	folder.Name = self._tableName
+	folder.Parent = adornee
+	return folder
+end
+
+function RoguePropertyTableDefinition:__index(index)
+	assert(type(index) == "string", "Bad index")
+
+	if index == "_definitionMap" then
+		return rawget(self, "_definitionMap")
+	elseif RoguePropertyTableDefinition[index] then
+		return RoguePropertyTableDefinition[index]
+	else
+		local definitions = rawget(self, "_definitionMap")
+
+		if definitions[index] then
+			return definitions[index]
+		else
+			error(("Bad definition %q"):format(tostring(index)))
+		end
+	end
+end
+
+return RoguePropertyTableDefinition

package/src/Shared/Modifiers/Additive/RogueAdditive.lua

@@ -0,0 +1,34 @@
+--[=[
+	@class RogueAdditive
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local BaseObject = require("BaseObject")
+local RxValueBaseUtils = require("RxValueBaseUtils")
+
+local RogueAdditive = setmetatable({}, BaseObject)
+RogueAdditive.ClassName = "RogueAdditive"
+RogueAdditive.__index = RogueAdditive
+
+function RogueAdditive.new(obj, serviceBag)
+	local self = setmetatable(BaseObject.new(obj), RogueAdditive)
+
+	self._serviceBag = assert(serviceBag, "No serviceBag")
+
+	return self
+end
+
+function RogueAdditive:GetObject()
+	return self._obj
+end
+
+function RogueAdditive:ObserveAdditive()
+	return RxValueBaseUtils.observeValue(self._obj)
+end
+
+function RogueAdditive:GetAdditive()
+	return self._obj.Value
+end
+
+return RogueAdditive

package/src/Shared/Modifiers/Additive/RogueAdditiveProvider.lua

@@ -0,0 +1,91 @@
+--[=[
+	@class RogueAdditiveProvider
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local Rx = require("Rx")
+local RxBinderUtils = require("RxBinderUtils")
+local RxBrioUtils = require("RxBrioUtils")
+local RogueBindersShared = require("RogueBindersShared")
+local BinderUtils = require("BinderUtils")
+local RoguePropertyModifierUtils = require("RoguePropertyModifierUtils")
+local RoguePropertyService = require("RoguePropertyService")
+
+local RogueAdditiveProvider = {}
+
+function RogueAdditiveProvider:Init(serviceBag)
+	assert(not self._serviceBag, "Already initialized")
+	self._serviceBag = assert(serviceBag, "No serviceBag")
+
+	-- Internal
+	self._roguePropetyService = self._serviceBag:GetService(RoguePropertyService)
+	self._rogueBinders = self._serviceBag:GetService(RogueBindersShared)
+
+	self._roguePropetyService:AddProvider(self)
+end
+
+function RogueAdditiveProvider:GetBinder()
+	return self._rogueBinders.RogueAdditive
+end
+
+function RogueAdditiveProvider:Create(additive, source)
+	assert(type(additive) == "number", "Bad additive")
+	assert(typeof(source) == "Instance" or source == nil, "Bad source")
+
+	local obj = Instance.new("NumberValue")
+	obj.Name = "Additive"
+	obj.Value = additive
+
+	if source then
+		RoguePropertyModifierUtils.createSourceLink(obj, source)
+	end
+
+	self._rogueBinders.RogueAdditive:Bind(obj)
+
+	return obj
+end
+
+function RogueAdditiveProvider:GetModifiedVersion(propObj, rogueProperty, baseValue)
+	if rogueProperty:GetDefinition():GetValueType() == "number" then
+		local value = baseValue
+
+		for _, item in pairs(self:_getAdditives(propObj)) do
+			value = value + item:GetAdditive()
+		end
+
+		return value
+	else
+		return baseValue
+	end
+end
+
+function RogueAdditiveProvider:ObserveModifiedVersion(propObj, rogueProperty, observeBaseValue)
+	if rogueProperty:GetDefinition():GetValueType() == "number" then
+		return RxBrioUtils.flatCombineLatest({
+			value = observeBaseValue;
+			multiplier = self:_observeMultipliers(propObj):Pipe({
+				RxBrioUtils.flatMapBrio(function(item)
+					return item:ObserveAdditive();
+				end); -- this gets us a list of multipliers which should mutate pretty frequently.
+				Rx.defaultsToNil;
+			});
+		}):Pipe({
+			Rx.map(function(state)
+				return self:GetModifiedVersion(propObj, rogueProperty, state.value)
+			end);
+		})
+	else
+		return observeBaseValue
+	end
+end
+
+function RogueAdditiveProvider:_observeMultipliers(propObj)
+	return RxBinderUtils.observeBoundChildClassBrio(self._rogueBinders.RogueAdditive, propObj)
+end
+
+function RogueAdditiveProvider:_getAdditives(propObj)
+	return BinderUtils.getChildren(self._rogueBinders.RogueAdditive, propObj)
+end
+
+return RogueAdditiveProvider

package/src/Shared/Modifiers/Multiplier/RogueMultiplier.lua

@@ -0,0 +1,34 @@
+--[=[
+	@class RogueMultiplier
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local BaseObject = require("BaseObject")
+local RxValueBaseUtils = require("RxValueBaseUtils")
+
+local RogueMultiplier = setmetatable({}, BaseObject)
+RogueMultiplier.ClassName = "RogueMultiplier"
+RogueMultiplier.__index = RogueMultiplier
+
+function RogueMultiplier.new(obj, serviceBag)
+	local self = setmetatable(BaseObject.new(obj), RogueMultiplier)
+
+	self._serviceBag = assert(serviceBag, "No serviceBag")
+
+	return self
+end
+
+function RogueMultiplier:ObserveMultiplier()
+	return RxValueBaseUtils.observeValue(self._obj)
+end
+
+function RogueMultiplier:GetMultiplier()
+	return self._obj.Value
+end
+
+function RogueMultiplier:GetObject()
+	return self._obj
+end
+
+return RogueMultiplier

package/src/Shared/Modifiers/Multiplier/RogueMultiplierProvider.lua

@@ -0,0 +1,91 @@
+--[=[
+	@class RogueMultiplierProvider
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local Rx = require("Rx")
+local RxBinderUtils = require("RxBinderUtils")
+local RxBrioUtils = require("RxBrioUtils")
+local RogueBindersShared = require("RogueBindersShared")
+local BinderUtils = require("BinderUtils")
+local RoguePropertyModifierUtils = require("RoguePropertyModifierUtils")
+local RoguePropertyService = require("RoguePropertyService")
+
+local RogueMultiplierProvider = {}
+
+function RogueMultiplierProvider:Init(serviceBag)
+	assert(not self._serviceBag, "Already initialized")
+	self._serviceBag = assert(serviceBag, "No serviceBag")
+
+	-- Internal
+	self._roguePropetyService = self._serviceBag:GetService(RoguePropertyService)
+	self._rogueBinders = self._serviceBag:GetService(RogueBindersShared)
+
+	self._roguePropetyService:AddProvider(self)
+end
+
+function RogueMultiplierProvider:GetBinder()
+	return self._rogueBinders.RogueMultiplier
+end
+
+function RogueMultiplierProvider:Create(multiplier, source)
+	assert(type(multiplier) == "number", "Bad multiplier")
+	assert(typeof(source) == "Instance" or source == nil, "Bad source")
+
+	local obj = Instance.new("NumberValue")
+	obj.Name = "Multiplier"
+	obj.Value = multiplier
+
+	if source then
+		RoguePropertyModifierUtils.createSourceLink(obj, source)
+	end
+
+	self._rogueBinders.RogueMultiplier:Bind(obj)
+
+	return obj
+end
+
+function RogueMultiplierProvider:GetModifiedVersion(propObj, rogueProperty, baseValue)
+	if rogueProperty:GetDefinition():GetValueType() == "number" then
+		local multiplier = 1
+
+		for _, item in pairs(self:_getMultipliers(propObj)) do
+			multiplier = multiplier*item:GetMultiplier()
+		end
+
+		return baseValue*multiplier
+	else
+		return baseValue
+	end
+end
+
+function RogueMultiplierProvider:ObserveModifiedVersion(propObj, rogueProperty, observeBaseValue)
+	if rogueProperty:GetDefinition():GetValueType() == "number" then
+		return RxBrioUtils.flatCombineLatest({
+			value = observeBaseValue;
+			multiplier = self:_observeMultipliers(propObj):Pipe({
+				RxBrioUtils.flatMapBrio(function(item)
+					return item:ObserveMultiplier();
+				end); -- this gets us a list of multipliers which should mutate pretty frequently.
+				Rx.defaultsToNil;
+			});
+		}):Pipe({
+			Rx.map(function(state)
+				return self:GetModifiedVersion(propObj, rogueProperty, state.value)
+			end);
+		})
+	else
+		return observeBaseValue
+	end
+end
+
+function RogueMultiplierProvider:_observeMultipliers(propObj)
+	return RxBinderUtils.observeBoundChildClassBrio(self._rogueBinders.RogueMultiplier, propObj)
+end
+
+function RogueMultiplierProvider:_getMultipliers(propObj)
+	return BinderUtils.getChildren(self._rogueBinders.RogueMultiplier, propObj)
+end
+
+return RogueMultiplierProvider

package/src/Shared/Modifiers/RoguePropertyModifierConstants.lua

@@ -0,0 +1,11 @@
+--[=[
+	@class RoguePropertyModifierConstants
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local Table = require("Table")
+
+return Table.readonly({
+	PROPERTY_SOURCE_LINK_NAME = "RoguePropertySourceLink";
+})

package/src/Shared/Modifiers/RoguePropertyModifierUtils.lua

@@ -0,0 +1,21 @@
+--[=[
+	@class RoguePropertyModifierUtils
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local LinkUtils = require("LinkUtils")
+local RoguePropertyModifierConstants = require("RoguePropertyModifierConstants")
+local RxLinkUtils = require("RxLinkUtils")
+
+local RoguePropertyModifierUtils = {}
+
+function RoguePropertyModifierUtils.createSourceLink(modifier, source)
+	return LinkUtils.createLink(RoguePropertyModifierConstants.PROPERTY_SOURCE_LINK_NAME, modifier, source)
+end
+
+function RoguePropertyModifierUtils.observeSourceLinksBrio(modifier)
+	return RxLinkUtils.observeValidLinksBrio(RoguePropertyModifierConstants.PROPERTY_SOURCE_LINK_NAME, modifier)
+end
+
+return RoguePropertyModifierUtils

package/src/Shared/Property/RogueProperty.lua

@@ -0,0 +1,219 @@
+--[=[
+	@class RogueProperty
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local RogueAdditiveProvider = require("RogueAdditiveProvider")
+local RogueMultiplierProvider = require("RogueMultiplierProvider")
+local RoguePropertyBinderGroups = require("RoguePropertyBinderGroups")
+local RoguePropertyModifierUtils = require("RoguePropertyModifierUtils")
+local RoguePropertyService = require("RoguePropertyService")
+local Rx = require("Rx")
+local RxBinderUtils = require("RxBinderUtils")
+local RxBrioUtils = require("RxBrioUtils")
+local RxInstanceUtils = require("RxInstanceUtils")
+local RxValueBaseUtils = require("RxValueBaseUtils")
+local ValueBaseUtils = require("ValueBaseUtils")
+local RoguePropertyUtils = require("RoguePropertyUtils")
+
+local RogueProperty = {}
+RogueProperty.ClassName = "RogueProperty"
+RogueProperty.__index = RogueProperty
+
+function RogueProperty.new(adornee, serviceBag, definition)
+	local self = setmetatable({}, RogueProperty)
+
+	self._serviceBag = assert(serviceBag, "No serviceBag")
+	self._roguePropertyBinderGroups = self._serviceBag:GetService(RoguePropertyBinderGroups)
+	self._roguePropertyService = self._serviceBag:GetService(RoguePropertyService)
+
+	self._adornee = assert(adornee, "Bad adornee")
+	self._definition = assert(definition, "Bad definition")
+
+	if self._roguePropertyService:CanInitializeProperties() then
+		self:_getBaseValueObject()
+	end
+
+	return self
+end
+
+function RogueProperty:_getBaseValueObject()
+	local parent
+	local tableDefinition = self._definition:GetPropertyTableDefinition()
+	if tableDefinition then
+		parent = tableDefinition:GetContainer(self._serviceBag, self._adornee)
+	else
+		parent = self._adornee
+	end
+
+	if not parent then
+		return nil
+	end
+
+	if self._roguePropertyService:CanInitializeProperties() then
+		return ValueBaseUtils.getOrCreateValue(
+			parent,
+			self._definition:GetStorageInstanceType(),
+			self._definition:GetName(),
+			self._definition:GetEncodedDefaultValue())
+	else
+		return parent:FindFirstChild(self._definition:GetName())
+	end
+end
+
+function RogueProperty:_observeBaseValueBrio()
+	local tableDefinition = self._definition:GetPropertyTableDefinition()
+	if tableDefinition then
+		return tableDefinition:ObserveContainerBrio(self._serviceBag, self._adornee)
+			:Pipe({
+				RxBrioUtils.switchMapBrio(function(container)
+					return RxInstanceUtils.observeLastNamedChildBrio(
+						container,
+						self._definition:GetStorageInstanceType(),
+						self._definition:GetName())
+				end);
+			})
+	else
+		return RxInstanceUtils.observeLastNamedChildBrio(self._adornee, self._definition:GetStorageInstanceType(), self._definition:GetName())
+	end
+end
+
+function RogueProperty:SetBaseValue(value)
+	local baseValue = self:_getBaseValueObject()
+	if baseValue then
+		baseValue.Value = self:_encodeValue(value)
+	else
+		warn("Failed to get the baseValue to parent")
+	end
+end
+
+function RogueProperty:GetValue()
+	local propObj = self:_getBaseValueObject()
+	if not propObj then
+		return self._definition:GetDefaultValue()
+	end
+
+	local current = self:_decodeValue(propObj.Value)
+
+	for _, item in pairs(self._roguePropertyService:GetProviders()) do
+		current = item:GetModifiedVersion(propObj, self, current)
+	end
+
+	return current
+end
+
+function RogueProperty:GetDefinition()
+	return self._definition
+end
+
+
+function RogueProperty:ObserveModifiersBrio()
+	return self:_observeBaseValueBrio()
+		:Pipe({
+			RxBrioUtils.flatMapBrio(function(baseValue)
+				if baseValue then
+					return RxBinderUtils.observeBoundChildClassesBrio(self._roguePropertyBinderGroups.RogueModifiers:GetBinders(), baseValue)
+				else
+					return Rx.EMPTY
+				end
+			end);
+		})
+end
+
+function RogueProperty:ObserveSourcesBrio()
+	return self:ObserveModifiersBrio()
+		:Pipe({
+			RxBrioUtils.flatMapBrio(function(rogueModifier)
+				return RoguePropertyModifierUtils.observeSourceLinksBrio(rogueModifier:GetObject())
+			end);
+		})
+end
+
+function RogueProperty:Observe()
+	return self._roguePropertyService:ObserveProviderList():Pipe({
+		RxBrioUtils.toBrio();
+		RxBrioUtils.switchMapBrio(function()
+			return self:_observeBaseValueBrio()
+		end);
+		RxBrioUtils.switchMapBrio(function(baseValue)
+			local current
+			if baseValue then
+				current = RxValueBaseUtils.observeValue(baseValue)
+
+				if self._definition:GetValueType() == "table" then
+					current = current:Pipe({
+						Rx.map(function(value)
+							return self:_decodeValue(value)
+						end)
+					})
+				end
+			else
+				current = Rx.of(self._definition:GetDefaultValue())
+			end
+
+			for _, item in pairs(self._roguePropertyService:GetProviders()) do
+				current = item:ObserveModifiedVersion(baseValue, self, current)
+			end
+
+			return current
+		end);
+		RxBrioUtils.emitOnDeath(self._definition:GetDefaultValue());
+	})
+end
+
+function RogueProperty:CreateMultiplier(amount, source)
+	assert(type(amount) == "number", "Bad amount")
+
+	local provider = self._serviceBag:GetService(RogueMultiplierProvider)
+	local baseValue = self:_getBaseValueObject()
+
+	if not baseValue then
+		warn("Failed to get the baseValue to parent")
+	end
+
+	local multiplier = provider:Create(amount, source)
+	multiplier.Parent = baseValue
+
+	return multiplier
+end
+
+function RogueProperty:CreateAdditive(amount, source)
+	assert(type(amount) == "number", "Bad amount")
+
+	local provider = self._serviceBag:GetService(RogueAdditiveProvider)
+	local baseValue = self:_getBaseValueObject()
+
+	if not baseValue then
+		warn("Failed to get the baseValue to parent")
+	end
+
+	local multiplier = provider:Create(amount, source)
+	multiplier.Parent = baseValue
+
+	return multiplier
+end
+
+function RogueProperty:_observeModifiersBrio()
+	return RxBinderUtils.observeBoundChildClassesBrio(self._roguePropertyBinderGroups.RogueModifiers:GetAll(), self._adornee)
+end
+
+function RogueProperty:__index(index)
+	if index == "Value" then
+		return self:GetValue()
+	elseif RogueProperty[index] then
+		return RogueProperty[index]
+	else
+		error(("Bad index %q"):format(tostring(index)))
+	end
+end
+
+function RogueProperty:_decodeValue(current)
+	return RoguePropertyUtils.decodeProperty(self._definition, current)
+end
+
+function RogueProperty:_encodeValue(current)
+	return RoguePropertyUtils.encodeProperty(self._definition, current)
+end
+
+return RogueProperty

package/src/Shared/Property/RoguePropertyUtils.lua

@@ -0,0 +1,39 @@
+--[=[
+	@class RoguePropertyUtils
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local JSONUtils = require("JSONUtils")
+
+local RoguePropertyUtils = {}
+
+function RoguePropertyUtils.decodeProperty(definition, value)
+	if definition:GetValueType() == "table" then
+		local ok, decoded, err = JSONUtils.jsonDecode(value)
+		if not ok then
+			warn(("Failed to decode current value of %s. %q"):format(definition:GetName(), tostring(err)))
+			return definition:GetDefaultValue()
+		end
+
+		return decoded
+	else
+		return value
+	end
+end
+
+function RoguePropertyUtils.encodeProperty(definition, value)
+	if definition:GetValueType() == "table" then
+		local ok, encoded, err = JSONUtils.jsonEncode(value)
+		if not ok then
+			warn(("Failed to encode current value of %s. %q"):format(definition:GetName(), tostring(err)))
+			return definition:GetEncodedDefaultValue()
+		end
+
+		return encoded
+	else
+		return value
+	end
+end
+
+return RoguePropertyUtils

package/src/Shared/RogueBindersShared.lua

@@ -0,0 +1,13 @@
+--[=[
+	@class RogueBindersShared
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local BinderProvider = require("BinderProvider")
+local Binder = require("Binder")
+
+return BinderProvider.new(function(self, serviceBag)
+	self:Add(Binder.new("RogueMultiplier", require("RogueMultiplier"), serviceBag))
+	self:Add(Binder.new("RogueAdditive", require("RogueAdditive"), serviceBag))
+end)

package/src/Shared/RoguePropertyBinderGroups.lua

@@ -0,0 +1,17 @@
+--[=[
+	@class RoguePropertyBinderGroups
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local BinderGroup = require("BinderGroup")
+local t = require("t")
+
+return require("BinderGroupProvider").new(function(self)
+	self:Add("RogueModifiers", BinderGroup.new(
+		{},
+		t.interface({
+			GetObject = t.callback;
+		})
+	))
+end)

package/src/Shared/RoguePropertyService.lua

@@ -0,0 +1,69 @@
+--[=[
+	@class RoguePropertyService
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local RunService = game:GetService("RunService")
+
+local Signal = require("Signal")
+local Maid = require("Maid")
+local Observable = require("Observable")
+
+local RoguePropertyService = {}
+
+function RoguePropertyService:Init(serviceBag)
+	assert(not self._serviceBag, "Already initialized")
+	self._serviceBag = assert(serviceBag, "No serviceBag")
+
+	self._maid = Maid.new()
+
+	-- Internal
+	self._serviceBag:GetService(require("RogueBindersShared"))
+	self._roguePropertyBinderGroups = self._serviceBag:GetService(require("RoguePropertyBinderGroups"))
+
+	self._providers = {}
+
+	self.ProviderAddedEvent = Signal.new()
+	self._maid:GiveTask(self.ProviderAddedEvent)
+
+	-- Internal providers
+	self._serviceBag:GetService(require("RogueAdditiveProvider"))
+	self._serviceBag:GetService(require("RogueMultiplierProvider"))
+end
+
+function RoguePropertyService:AddProvider(provider)
+	self._roguePropertyBinderGroups.RogueModifiers:Add(provider:GetBinder())
+
+	table.insert(self._providers, provider)
+
+	self.ProviderAddedEvent:Fire(provider)
+end
+
+function RoguePropertyService:GetProviders()
+	return self._providers
+end
+
+function RoguePropertyService:ObserveProviderList()
+	return Observable.new(function(sub)
+		local maid = Maid.new()
+
+		sub:Fire(self._providers)
+
+		maid:GiveTask(self.ProviderAddedEvent:Connect(function()
+			sub:Fire(self._providers)
+		end))
+
+		return maid
+	end)
+end
+
+function RoguePropertyService:CanInitializeProperties()
+	return RunService:IsServer()
+end
+
+function RoguePropertyService:Destroy()
+	self._maid:DoCleaning()
+end
+
+return RoguePropertyService

package/src/Shared/Table/RoguePropertyTable.lua

@@ -0,0 +1,87 @@
+--[=[
+	@class RoguePropertyTable
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local RunService = game:GetService("RunService")
+
+local RoguePropertyTable = {}
+RoguePropertyTable.ClassName = "RoguePropertyTable"
+RoguePropertyTable.__index = RoguePropertyTable
+
+function RoguePropertyTable.new(adornee, serviceBag, roguePropertyTableDefinition)
+	local self = setmetatable({}, RoguePropertyTable)
+
+	self._adornee = assert(adornee, "No roguePropertyTableDefinition")
+	self._serviceBag = assert(serviceBag, "No serviceBag")
+	self._definition = assert(roguePropertyTableDefinition, "No roguePropertyTableDefinition")
+
+	self._properties = {}
+
+	if RunService:IsServer() then
+		self:_setup()
+	end
+
+	return self
+end
+
+function RoguePropertyTable:ObserveContainerBrio()
+	return self._definition:ObserveContainerBrio(self._serviceBag, self._adornee)
+end
+
+function RoguePropertyTable:GetContainer()
+	return self._definition:GetContainer(self._serviceBag, self._adornee)
+end
+
+function RoguePropertyTable:Set(newBaseValues)
+	assert(type(newBaseValues) == "table", "Bad newBaseValues")
+
+	for propertyName, value in pairs(newBaseValues) do
+		local rogueProperty = self:GetRogueProperty(propertyName)
+		if not rogueProperty then
+			error(("Bad property %q"):format(tostring(propertyName)))
+		end
+
+		rogueProperty:SetBaseValue(value)
+	end
+end
+
+function RoguePropertyTable:_setup()
+	for definitionName, _ in pairs(self._definition:GetDefinitionMap()) do
+		self:GetRogueProperty(definitionName)
+	end
+end
+
+function RoguePropertyTable:GetRogueProperty(name)
+	-- Caching these things doesn't do a whole lot, but saves on table allocation.
+	if self._properties[name] then
+		return self._properties[name]
+	end
+
+	local definition = self._definition:GetDefinition(name)
+	if definition then
+		self._properties[name] = definition:Get(self._serviceBag, self._adornee)
+		return self._properties[name]
+	else
+		return nil
+	end
+end
+
+function RoguePropertyTable:__index(index)
+	assert(type(index) == "string", "Bad index")
+
+	if RoguePropertyTable[index] then
+		return RoguePropertyTable[index]
+	elseif type(index) == "string" then
+		local property = self:GetRogueProperty(index)
+		if not property then
+			error(("Bad index %q"):format(tostring(index)))
+		end
+		return property
+	else
+		error(("Bad index %q"):format(tostring(index)))
+	end
+end
+
+return RoguePropertyTable

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": "RoguePropertiesTest",
+  "tree": {
+    "$className": "DataModel",
+    "ServerScriptService": {
+      "rogueproperties": {
+        "$path": ".."
+      },
+      "Script": {
+        "$path": "scripts/Server"
+      }
+    },
+    "StarterPlayer": {
+      "StarterPlayerScripts": {
+        "Main": {
+          "$path": "scripts/Client"
+        }
+      }
+    }
+  }
+}

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

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

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

@@ -0,0 +1,41 @@
+--[[
+	@class ServerMain
+]]
+local ServerScriptService = game:GetService("ServerScriptService")
+
+local loader = ServerScriptService:FindFirstChild("LoaderUtils", true).Parent
+local packages = require(loader).bootstrapGame(ServerScriptService.rogueproperties)
+
+local serviceBag = require(packages.ServiceBag).new()
+serviceBag:GetService(packages.RoguePropertyService)
+
+-- Start game
+serviceBag:Init()
+serviceBag:Start()
+
+local RoguePropertyTableDefinition = require(packages.RoguePropertyTableDefinition)
+local RoguePropertyDefinition = require(packages.RoguePropertyDefinition)
+
+local properties = RoguePropertyTableDefinition.new({
+	RoguePropertyDefinition.new("AttackDamage", 30);
+	RoguePropertyDefinition.new("AbilityPower", 30);
+})
+
+local attackDamage = properties.AttackDamage:Get(serviceBag, workspace)
+local abilityPower = properties.AbilityPower:Get(serviceBag, workspace)
+
+attackDamage:Observe():Subscribe(function(value)
+	print("Attack damage", value)
+end)
+abilityPower:Observe():Subscribe(function(value)
+	print("Ability power", value)
+end)
+
+attackDamage:CreateMultiplier(2, workspace)
+attackDamage:CreateAdditive(100, workspace)
+
+print(attackDamage:GetValue())
+
+attackDamage:ObserveSourcesBrio():Subscribe(function(value)
+	print(value:GetValue())
+end)