Using OOP and CollectionService to make automated plots

I’ll be going over very basic OOP and CollectionService concepts via. the creation of plots/properties. Side note, I won’t go too indepth on what OOP is because there’s many tutorials and videos on the subject [All about Object Oriented Programming] and if you’re interested you can take look.

Now, OOP stands for Object Oriented Programming, you may of heard of it or you may not have but it’s basically just a coding practice that uses tables to create objects and classes. For example, we could make a plot/property which would be considered an object.

In this example, we’ve created a module script called Properties and have made a function that creates a new property.

-- Properties Module Script
local Properties = {}
Properties.__index = Properties

function Properties.new(Property: Instance?, access: BasePart) -- Information we'll give the function
	local self = setmetatable({}, Properties) -- Creation of object's metatable
	self.Access = access -- access is the part that the player will touch to get ownership
	self.Owner = nil -- The properties owner
	self.Property = Property -- The property itself
    self.Upgrades = {}
	return self -- Returns the property object
end

return Properties

The code above is basically making an object just like how you’d add a part to the workspace, if we couldn’t visually see the part or its properties it’d be listed something like this,

PartInstance1 = {
Name = "Part",
Size = Vector3.new(5,5,5),
Orientation = Vector3.new(0,0,0).
...
}

Now just in this case were creating our own object each time the player claims a property

Here’s where some of the fun comes with OOP, did you notice how we have a bunch of stuff called “self”, well self is interesting because it allows us to change the properties of the property/plot from another function, here’s what I mean

You’ll notice the function Properties:GiveOwnership() that we use a colon : instead of a period . basically the colon tells us that this function is connected to our property object, like how we apply a force to a part Basepart:ApplyImpulse() – The basepart is the object and the ApplyImpulse is our connected function which changes the velocity property of the basepart. We’re doing the same but this time with the plots ownership property.

local Players = game:GetService("Players")

local Properties = {}
Properties.__index = Properties

function Properties.new(Property: Instance?, access: BasePart)
	local self = setmetatable({}, Properties)
	self.Access = access
	self.Owner = nil
	self.Property = Property
	self.Upgrades = {}
	return self
end

function Properties:GiveOwnership(player: Player)
	self.Owner = player -- self.Owner is used to get the owner property from our object
	return true
end
return Properties

We can even update tables for our objects, in this case the “self.Upgrade” is a table.

function Properties:AddUpgrade(Upgrade)
	self.Upgrades[Upgrade] = true
	return self.Upgrades
end

If you’re keeping up that’s great, if not that’s okay just take your time and maybe look at some other references especially the link I sent before. Hopefully, you can somewhat see why OOP is so powerful it allows us to manage multiple instances of objects each being unique and allowing us to change their properties.

So now we’ve created the perfect set up to mass produce plots. Let’s see how we actually run these functions now shall we.

Now in most cases we’d use another module for this set up but in this case we’ll just make a script in serverscriptservice. We’re going to be diving into collection service one of my favorite features on roblox by far for mass automation.

--Script
local CollectionService = game:GetService("CollectionService")
-- We'll also want to retrieve our properties module
local PropertyModule = require(game.ServerStorage:WaitForChild("Properties"))

-- A very important part is having a table for all the properties that are made
local PropertiesMade = {} -- This way we'll be able to actually use our plot objects

So before we go ahead let’s explain what specifically with CollectionService we’re gonna be using… and thats… tags. If you’ve ever used attributes on parts, objects, instances, etc. you’ll notice there’s a place for tags. If you haven’t used attributes, in the properties of most instances if you scroll down to the bottom you’ll see a section called “tags” and you’ll be able to add a tag.

image

We’ll be creating a tag named “Access” and putting this on the part we want the player to touch to obtain ownership of a property.


The reason CollectionService is so awesome is because now we can put this tag on any part and then we loop through all the tags to get all the parts with this specific tag.

Think of it like reset bricks, you give them the tag “reset” then you loop through all the reset tags that are connected to the bricks and we can put a touched event on every part with the reset tag and have the touched event reset the player.

-- Here's an example,
for _, brick in (CollectionService:GetTagged("reset")) do -- Loop through all the parts with the tag "reset"
    brick.Touched:Connect(function(hit) -- Connect a touched event to them
        hit.Parent:FindFirstChild("Humanoid"):TakeDamage(100)
    end
end

We’ll now be doing that with our access part,

--Script
local CollectionService = game:GetService("CollectionService")
local PropertyModule = require(game.ServerStorage:WaitForChild("Properties"))
local PropertiesMade = {} 

-- Okay I know this may look scary but its not if we take this one step at a time
for _, accessPart in (CollectionService:GetTagged("Access")) do -- Loops through Access parts
		accessPart.Touched:Connect(function(hit: BasePart) -- Connects a touch event to access parts
			if hit and hit.Parent then -- if the part is touched
				local char: Instance = hit.Parent
				if char:FindFirstChild("Humanoid") then -- Check if part is a character
					local player = Players:GetPlayerFromCharacter(char) -- get character's player
					if not PropertiesMade[player] then -- Make sure player doesn't already have a property
						local prop: Instance? = accessPart.Parent -- the accesspart's parent is the property folder
						PropertiesMade[player] = PropertyModule.new(prop, accessPart) -- Adds the created object to the folder giving it to the specific player
						PropertiesMade[player]:GiveOwnership(player) -- Gives ownership to the players created object		
					end
				end
			end
		end)
	end

This can seem kind of scary especially if this is your first time working with OOP or CS (CollectionService) but all we did was

– Get the AccessParts based off the “access” tag
– Allowed the AccessParts to be touchable
– If they were touched check if it was a player
– Checked if that player had a property by checking the PropertiesMade table for the player
– Added the player to the properties table with the creation of the plot if they didn’t have a property
– Gave the player ownership of the plot

Let’s explain what happened in these lines,

PropertiesMade[player] = PropertyModule.new(prop, accessPart)
PropertiesMade[player]:GiveOwnership(player)

Since I think these are the lines that may confuse you the most. The first line were creating our object from the module we made before, if you go back to the module we return “self” when we create a plot which is the object.

PropertiesMade[player] This adds the Player to the table

PropertiesMade = {
   Player1 = 
}

Now we need to give that player something to equal’s in this case our object

PropertiesMade = {
   Player1 = {
    Access = access
	Owner = nil
	Property = Property
	Upgrades = {}
   }
}

Now we give the Player the ownership

PropertiesMade[player]:GiveOwnership(player)
PropertiesMade = {
   Player1 = {
    Access = access
	Owner = Player1
	Property = Property
	Upgrades = {}
   }
}

The reason why this line works is all because this is a object who now has functions remember that basepart:applyimpulse() example I made well were doing the same thing now with the give ownership we don’t need to reference the function from the module script because the object already has the function attached to itself.

Now you have fully functioning plot objects, which get created when someone touches the accesspart.

I hope that you learned something new today from the post and if not my bad for wasting your time. If you have any critics, questions, or thoughts, I’ll respond to them.

6 Likes