Add files via upload

Author: Dukefarming

collections/ListenerList.lua

@@ -0,0 +1,69 @@
+
+
+
+
+
+
+
+
+
+
+---Holds and manages a collection of functions and target objects
+local ListenerList_mt = Class(ListenerList)
+
+
+---Creates a new listener list.
+-- @param boolean? ignoreFirstArgument If this is true, the first argument is not passed along when invoking. Used to ignore the table instance when the listener list is a member of a table.
+-- @return ListenerList instance The created instance.
+function ListenerList.new(ignoreFirstArgument)
+
+    -- Create the instance.
+    local self = setmetatable({}, ListenerList_mt)
+
+    -- The collection of listening functions.
+    self.listeners = {}
+
+    -- If this is true, the first argument is not passed to the invoked functions. This is useful to ignore the table instance when the listener list is a member of a table.
+    self.ignoreFirstArgument = ignoreFirstArgument == true
+
+    -- Return the created instance.
+    return self
+end
+
+
+---Adds the given listener function and target object to the listeners list.
+-- @param (function|TargetedFunction) listenerFunction The function or TargetedFunction to add to the list.
+-- @param table? targetObject The optional target object.
+function ListenerList:registerListener(listenerFunction, targetObject)
+
+    -- Resolve the listener function.
+    local listener = TargetedFunction.resolveListener(listenerFunction, targetObject)
+
+    -- Add the listener function to the list.
+    table.insert(self.listeners, listener)
+end
+
+
+---Calls the listeners with the given arguments.
+-- @param any ... The collection of arguments to pass to the functions.
+function ListenerList:invoke(targetObject, ...)
+
+    -- Invoke each listener.
+    if self.ignoreFirstArgument then
+        for _, listener in ipairs(self.listeners) do
+            listener:invoke(...)
+        end
+    else
+        for _, listener in ipairs(self.listeners) do
+            listener:invoke(targetObject, ...)
+        end
+    end
+end
+
+
+---Metamethod so the table itself can be called as a shortcut for :invoke().
+-- @param ListenerList instance The instance of the listener list.
+-- @param any ... The collection of arguments to pass to the functions.
+function ListenerList_mt.__call(instance, ...)
+    return instance:invoke(...)
+end

collections/MapDataGrid.lua

@@ -0,0 +1,92 @@
+
+
+
+
+
+
+
+
+
+
+
+---A map data grid that splits a map into multiple sections
+local MapDataGrid_mt = Class(MapDataGrid, DataGrid)
+
+
+---Creates a map grid instance with the given map size, cells per row/column, and optional custom metatable.
+-- @param integer mapSize map size
+-- @param integer blocksPerRowColumn blocks per row and column
+-- @param table? customMt custom metatable
+-- @return table instance instance of object
+function MapDataGrid.new(mapSize, blocksPerRowColumn, customMt)
+    local self = DataGrid.new(blocksPerRowColumn, blocksPerRowColumn, customMt or MapDataGrid_mt)
+
+    self.blocksPerRowColumn = blocksPerRowColumn
+    self.mapSize = mapSize
+    self.blockSize = self.mapSize/self.blocksPerRowColumn
+
+    return self
+end
+
+
+---Creates a new data grid from the given map size and block size.
+-- @param integer mapSize The size of the map in metres.
+-- @param integer blockSize The size of one cell in metres.
+-- @param table? customMt The custom metatable to use, if any.
+-- @return MapDataGrid instance The created instance.
+function MapDataGrid.createFromBlockSize(mapSize, blockSize, customMt)
+
+    -- Calculate the blocks per row, then return the result of the constructor with this value.
+    local blocksPerRowColumn = math.ceil(mapSize / blockSize)
+    return MapDataGrid.new(mapSize, blocksPerRowColumn, customMt)
+end
+
+
+---Get value at world position
+-- @param float worldX world position x
+-- @param float worldZ world position z
+-- @return table value value at the given position
+function MapDataGrid:getValueAtWorldPos(worldX, worldZ)
+    local rowIndex, colIndex = self:getRowColumnFromWorldPos(worldX, worldZ)
+    return self:getValue(rowIndex, colIndex), rowIndex, colIndex
+end
+
+
+---Set value at world position
+-- @param float worldX world position x
+-- @param float worldZ world position z
+-- @param table value value at the given position
+function MapDataGrid:setValueAtWorldPos(worldX, worldZ, value)
+    local rowIndex, colIndex = self:getRowColumnFromWorldPos(worldX, worldZ)
+    self:setValue(rowIndex, colIndex, value)
+end
+
+
+---Gets clamped row and column at given world position
+-- @param float worldX world position x
+-- @param float worldZ world position z
+-- @return integer row row
+-- @return integer column column
+function MapDataGrid:getRowColumnFromWorldPos(worldX, worldZ)
+    local mapSize = self.mapSize
+    local blocksPerRowColumn = self.blocksPerRowColumn
+
+    local x = (worldX + mapSize*0.5) / mapSize
+    local z = (worldZ + mapSize*0.5) / mapSize
+
+    local row = math.clamp(math.ceil(blocksPerRowColumn*z), 1, blocksPerRowColumn)
+    local column = math.clamp(math.ceil(blocksPerRowColumn*x), 1, blocksPerRowColumn)
+
+--    log(worldX, worldZ, " -> ", (worldX + self.mapSize*0.5), (worldZ + self.mapSize*0.5), z, x, row, column)
+
+    return row, column
+end
+
+
+---Calculates if the given world position is in range of the data.
+-- @param float worldX The x world position.
+-- @param float worldZ The z world position.
+-- @return boolean isInRange True if the position is in range of the data; otherwise false.
+function MapDataGrid:isWorldPositionInRange(worldX, worldZ)
+    return worldX > self.mapSize * -0.5 and worldX <= self.mapSize * 0.5 and worldZ > self.mapSize * -0.5 and worldZ <= self.mapSize * 0.5
+end

collections/ObjectPool.lua

@@ -0,0 +1,121 @@
+
+
+
+
+
+
+
+
+
+
+
+---Holds a collection of pooled objects and handles creating new ones when the pool is empty.
+local ObjectPool_mt = Class(ObjectPool)
+
+
+
+
+
+
+
+
+
+---Creates a new object pool with the given constructor.
+-- @param function? objectConstructor The constructor function to call in order to create new objects when the pool is empty. If this is nil, ObjectPool.EMPTY_TABLE_CONSTRUCTOR will be used.
+-- @param any ... The arguments to pass through to the constructor.
+-- @return ObjectPool instance The created instance.
+function ObjectPool.new(objectConstructor, ...)
+
+    -- Ensure a constructor was given or is nil.
+    --#debug Assert.isNilOrType(objectConstructor, "function", "Object constructor was not a function or nil!")
+
+    -- Create the instance.
+    local self = setmetatable({}, ObjectPool_mt)
+
+    -- The object constructor and arguments.
+    self.objectConstructor = objectConstructor or ObjectPool.EMPTY_TABLE_CONSTRUCTOR
+    self.objectConstructorArguments = table.pack(...)
+
+    -- The pool of objects.
+    self.pool = {}
+
+    -- The set of pooled objects to avoid duplicates.
+    self.poolSet = {}
+
+    -- Return the created instance.
+    return self
+end
+
+
+---Gets the total count of objects in the pool.
+-- @return integer count The number of items in the pool.
+function ObjectPool:getLength()
+    -- TODO: Replace with __len metafunction in Lua 5.2
+    return #self.pool
+end
+
+
+---Removes all instances from the pool's collections.
+function ObjectPool:clear()
+    table.clear(self.poolSet)
+    table.clear(self.pool)
+end
+
+
+---Gets and returns an instance from the pool, or creates one if the pool is empty.
+-- @return table instance The pooled or created object.
+function ObjectPool:getOrCreateNext()
+
+    -- Get the next object in the pool.
+    local instance = table.remove(self.pool)
+
+    -- If there was no object in the pool, create a new one.
+    if not instance then
+
+        -- If the constructor is the default empty table, skip the unpacking.
+        if self.objectConstructor == ObjectPool.EMPTY_TABLE_CONSTRUCTOR then
+            instance = self.objectConstructor()
+        -- Otherwise; unpack the arguments and call the constructor.
+        else
+            instance = self.objectConstructor(table.unpack(self.objectConstructorArguments, 1, self.objectConstructorArguments.n))
+        end
+    -- Otherwise; also remove the object from the set.
+    else
+        self.poolSet[instance] = nil
+    end
+
+    -- Return the created or gotten object.
+    return instance
+end
+
+
+---Returns the given instance to the pool.
+-- @param table instance The instance to return to the pool.
+function ObjectPool:returnToPool(instance)
+
+    -- Ensure the given instance exists.
+    if instance == nil then
+        return false
+    end
+    --#debug Assert.isType(instance, "table", "Given instance was not a table!")
+
+    -- Ensure the object is not already pooled.
+    if self.poolSet[instance] ~= nil then
+        return false
+    end
+
+    -- If the object constructor is the default empty table, clear the table.
+    if self.objectConstructor == ObjectPool.EMPTY_TABLE_CONSTRUCTOR then
+        table.clear(instance)
+    -- Otherwise; if the instance has a reset function, call it.
+    elseif instance.reset ~= nil then
+        instance:reset()
+    end
+
+    -- Add the object to the collections.
+    table.insert(self.pool, instance)
+    self.poolSet[instance] = instance
+
+    -- Return true, as the addition was a success.
+    return true
+end

collections/Queue.lua

@@ -0,0 +1,71 @@
+
+
+
+
+
+
+
+
+
+
+
+
+---
+local Queue_mt = Class(Queue)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---Returns the element from the front of the queue without popping it.
+-- @return table? value The element at the front of the queue, or nil if the queue is empty.
+function Queue:peek()
+    return self.first
+end