Merge pull request #73 from penolakushari/optifix

Optimization fix

lua/smh/client/controller.lua

@@ -1,4 +1,5 @@
 local INT_BITCOUNT = 32
+local KFRAMES_PER_MSG = 250
 
 local function ReceiveKeyframes()
     local entity = net.ReadEntity()
@@ -61,27 +62,83 @@ function CTRL.Record()
     net.SendToServer()
 end
 
-function CTRL.UpdateKeyframe(keyframeId, updateData)
-    net.Start(SMH.MessageTypes.UpdateKeyframe)
-    net.WriteUInt(keyframeId, INT_BITCOUNT)
-    net.WriteTable(updateData)
-    net.WriteUInt(SMH.State.Timeline, INT_BITCOUNT)
+function CTRL.UpdateKeyframe(keyframeId, updateData, singledata)
+    local keyframeAmount = #keyframeId
+
+    for i = 1, math.ceil(keyframeAmount / KFRAMES_PER_MSG) do
+        local keyframesToSend = keyframeAmount - KFRAMES_PER_MSG * (i - 1) > KFRAMES_PER_MSG and KFRAMES_PER_MSG or keyframeAmount - KFRAMES_PER_MSG * (i - 1)
+
+        net.Start(SMH.MessageTypes.UpdateKeyframe)
+        net.WriteUInt(keyframesToSend, INT_BITCOUNT)
+
+        for ids = 1 + KFRAMES_PER_MSG * (i - 1), keyframesToSend + KFRAMES_PER_MSG * (i - 1) do
+            net.WriteUInt(keyframeId[ids], INT_BITCOUNT)
+
+            if singledata then
+                for data, value in pairs(updateData) do
+                    net.WriteString(data)
+                    if data == "Frame" then
+                        net.WriteUInt(value, INT_BITCOUNT)
+                    else
+                        net.WriteFloat(value)
+                    end
+                end
+            else
+                for data, value in pairs(updateData[ids]) do
+                    net.WriteString(data)
+                    if data == "Frame" then
+                        net.WriteUInt(value, INT_BITCOUNT)
+                    else
+                        net.WriteFloat(value)
+                    end
+                end
+            end
+        end
+        net.WriteUInt(SMH.State.Timeline, INT_BITCOUNT)
+        net.SendToServer()
+    end
+
+    net.Start(SMH.MessageTypes.UpdateKeyframeExecute)
     net.SendToServer()
 end
 
 function CTRL.CopyKeyframe(keyframeId, frame)
-    net.Start(SMH.MessageTypes.CopyKeyframe)
-    net.WriteUInt(keyframeId, INT_BITCOUNT)
-    net.WriteUInt(frame, INT_BITCOUNT)
-    net.WriteUInt(SMH.State.Timeline, INT_BITCOUNT)
+    local keyframeAmount = #keyframeId
+
+    for i = 1, math.ceil(keyframeAmount / KFRAMES_PER_MSG) do
+        local keyframesToSend = keyframeAmount - KFRAMES_PER_MSG * (i - 1) > KFRAMES_PER_MSG and KFRAMES_PER_MSG or keyframeAmount - KFRAMES_PER_MSG * (i - 1)
+
+        net.Start(SMH.MessageTypes.CopyKeyframe)
+        net.WriteUInt(keyframesToSend, INT_BITCOUNT)
+
+        for ids = 1 + KFRAMES_PER_MSG * (i - 1), keyframesToSend + KFRAMES_PER_MSG * (i - 1) do
+            net.WriteUInt(keyframeId[ids], INT_BITCOUNT)
+            net.WriteUInt(frame[ids], INT_BITCOUNT)
+        end
+        net.WriteUInt(SMH.State.Timeline, INT_BITCOUNT)
+        net.SendToServer()
+    end
+
+    net.Start(SMH.MessageTypes.CopyKeyframeExecute)
     net.SendToServer()
 end
 
 function CTRL.DeleteKeyframe(keyframeId)
-    net.Start(SMH.MessageTypes.DeleteKeyframe)
-    net.WriteUInt(keyframeId, INT_BITCOUNT)
-    net.WriteUInt(SMH.State.Timeline, INT_BITCOUNT)
-    net.SendToServer()
+    local keyframeAmount = #keyframeId
+
+    for i = 1, math.ceil(keyframeAmount / KFRAMES_PER_MSG) do
+        local keyframesToSend = keyframeAmount - KFRAMES_PER_MSG * (i - 1) > KFRAMES_PER_MSG and KFRAMES_PER_MSG or keyframeAmount - KFRAMES_PER_MSG * (i - 1)
+
+        net.Start(SMH.MessageTypes.DeleteKeyframe)
+        net.WriteUInt(keyframesToSend, INT_BITCOUNT)
+        net.WriteUInt(SMH.State.Timeline, INT_BITCOUNT)
+
+        for ids = 1 + KFRAMES_PER_MSG * (i - 1), keyframesToSend + KFRAMES_PER_MSG * (i - 1) do
+            net.WriteUInt(keyframeId[ids], INT_BITCOUNT)
+        end
+
+        net.SendToServer()
+    end
 end
 
 function CTRL.StartPlayback()
@@ -436,26 +493,26 @@ end
 
 local function GetServerSavesResponse(msgLength)
     for i=1, net.ReadUInt(INT_BITCOUNT) do
-        SMH.TableSplit.AList(net.ReadString(), net.ReadString())
+        SMH.TableSplit.ATable(net.ReadString(), net.ReadString())
     end
-    local saves = SMH.TableSplit.GetList()
+    local saves = SMH.TableSplit.GetTable()
     SMH.UI.SetServerSaves(saves)
 end
 
 local function GetModelListResponse(msgLength)
     for i=1, net.ReadUInt(INT_BITCOUNT) do
-        SMH.TableSplit.AList(net.ReadString(), net.ReadString())
+        SMH.TableSplit.ATable(net.ReadString(), net.ReadString())
     end
-    local models = SMH.TableSplit.GetList()
+    local models = SMH.TableSplit.GetTable()
     local map = net.ReadString()
     SMH.UI.SetModelList(models, map)
 end
 
 local function GetServerEntitiesResponse(msgLength)
     for i=1, net.ReadUInt(INT_BITCOUNT) do
-        SMH.TableSplit.AList(net.ReadEntity(), {Name = net.ReadString()})
+        SMH.TableSplit.ATable(net.ReadEntity(), {Name = net.ReadString()})
     end
-    local entities = SMH.TableSplit.GetList()
+    local entities = SMH.TableSplit.GetTable()
     SMH.UI.SetEntityList(entities)
 end
 

lua/smh/client/derma/frame_pointer.lua

@@ -139,15 +139,15 @@ function PANEL:OnMousePressed(mousecode)
 end
 
 function PANEL:SetParentPointer(ppointer)
-    self.parent = ppointer
+    self._parent = ppointer
 end
 
 function PANEL:ClearParentPointer()
-    self.parent = nil
+    self._parent = nil
 end
 
 function PANEL:GetParentKeyframe()
-    return self.parent
+    return self._parent
 end
 
 function PANEL:SetOffsets(minimum, maximum)
@@ -155,18 +155,6 @@ function PANEL:SetOffsets(minimum, maximum)
     self._maxoffset = maximum
 end
 
-function PANEL:SetParentPointer(ppointer)
-    self.parent = ppointer
-end
-
-function PANEL:ClearParentPointer()
-    self.parent = nil
-end
-
-function PANEL:GetParentKeyframe()
-    return self.parent
-end
-
 function PANEL:OnMouseReleased(mousecode)
     if not self._dragging then
         return
@@ -176,7 +164,7 @@ function PANEL:OnMouseReleased(mousecode)
 
     self:MouseCapture(false)
     self._dragging = false
-    SMH.UI.ClearFrames(self)
+    --SMH.UI.ClearFrames(self)
     self:OnPointerReleased(self._frame)
 
     if mousecode == MOUSE_LEFT and not self.PointyBottom then

lua/smh/client/ui.lua

@@ -31,58 +31,38 @@ local function DeleteEmptyKeyframe(pointer)
                     break
                 end
             end
+            break
         end
     end
 end
 
 local function CreateCopyPointer(keyframeId)
     OffsetPointers = {}
-    local KeysToDelete = {}
+    local KeysToDelete, KeysToCopy, FramesToSend = {}, {}, {}
     local originFrame = KeyframePointers[keyframeId]:GetFrame()
 
     local counter = 1
 
-    for id, kpointer in pairs(KeyframePointers) do
+    for id, kpointer in pairs(SelectedPointers) do
         if id == keyframeId then continue end
-        if SelectedPointers[id] then
-            local difference = kpointer:GetFrame() - originFrame
+        local difference = kpointer:GetFrame() - originFrame
 
-            kpointer:SetSelected(false)
-            SelectedPointers[id] = nil
+        kpointer:SetSelected(false)
+        SelectedPointers[id] = nil
 
-            local pointer = WorldClicker.MainMenu.FramePanel:CreateFramePointer(
-            KeyColor,
-            WorldClicker.MainMenu.FramePanel:GetTall() / 4 * 2.2,
-            false
-            )
+        local pointer = WorldClicker.MainMenu.FramePanel:CreateFramePointer(
+        KeyColor,
+        WorldClicker.MainMenu.FramePanel:GetTall() / 4 * 2.2,
+        false
+        )
 
-            table.insert(OffsetPointers, pointer)
-            pointer:SetFrame(originFrame + difference)
-            pointer:SetSelected(true)
+        table.insert(OffsetPointers, pointer)
+        pointer:SetFrame(originFrame + difference)
+        pointer:SetSelected(true)
+        pointer.NewID = LocalIDs + counter
+        pointer.keyframeId = id
 
-            pointer.OnPointerReleased = function(_, frame)
-                WorldClicker.MainMenu.FramePanel:DeleteFramePointer(pointer)
-                if frame < 0 then return end
-
-                for id, _ in pairs(kpointer:GetIDs()) do
-                    SMH.Controller.CopyKeyframe(id, frame)
-                end
-
-                for id, pointer in pairs(KeyframePointers) do
-                    if id == LocalIDs + counter then continue end
-                    if pointer:GetFrame() == frame then
-                        for ent, id in pairs(pointer:GetEnts()) do
-                            if not kpointer:GetEnts()[ent] then
-                                SMH.Controller.CopyKeyframe(id, frame)
-                            end
-                        end
-
-                        table.insert(KeysToDelete, pointer)
-                    end
-                end
-            end
-            counter = counter + 1
-        end
+        counter = counter + 1
     end
 
     local pointer = WorldClicker.MainMenu.FramePanel:CreateFramePointer(
@@ -105,31 +85,42 @@ local function CreateCopyPointer(keyframeId)
 
     pointer:OnMousePressed(MOUSE_LEFT)
     pointer:SetOffsets(minimum, maximum)
+    pointer.NewID = LocalIDs + counter
 
-    pointer.OnPointerReleased = function(_, frame)
-        for _, kpointer in ipairs(OffsetPointers) do
-            kpointer:OnPointerReleased(kpointer:GetFrame())
-        end
-        OffsetPointers = {}
+    local function ProcessCopyKey(pointer, NewID, frame, keyframeId)
         WorldClicker.MainMenu.FramePanel:DeleteFramePointer(pointer)
         if frame < 0 then return end
 
-        for id, ent in pairs(KeyframePointers[keyframeId]:GetIDs()) do
-            SMH.Controller.CopyKeyframe(id, frame)
+        for id, _ in pairs(KeyframePointers[keyframeId]:GetIDs()) do
+            table.insert(KeysToCopy, id)
+            table.insert(FramesToSend, frame)
         end
 
         for id, pointer in pairs(KeyframePointers) do
-            if id == LocalIDs + counter then continue end
+            if id == NewID then continue end
             if pointer:GetFrame() == frame then
+
                 for ent, id in pairs(pointer:GetEnts()) do
                     if not KeyframePointers[keyframeId]:GetEnts()[ent] then
-                        SMH.Controller.CopyKeyframe(id, frame)
+                        table.insert(KeysToCopy, id)
+                        table.insert(FramesToSend, frame)
                     end
                 end
 
                 table.insert(KeysToDelete, pointer)
             end
         end
+    end
+
+    pointer.OnPointerReleased = function(_, frame)
+        for _, kpointer in ipairs(OffsetPointers) do
+            ProcessCopyKey(kpointer, kpointer.NewID, kpointer:GetFrame(), kpointer.keyframeId)
+        end
+        OffsetPointers = {}
+        ProcessCopyKey(pointer, pointer.NewID, frame, keyframeId)
+
+        SMH.Controller.CopyKeyframe(KeysToCopy, FramesToSend)
+
         for _, dpointer in ipairs(KeysToDelete) do
             DeleteEmptyKeyframe(dpointer)
         end
@@ -145,35 +136,54 @@ local function NewKeyframePointer(keyframeId)
     )
 
     pointer.OnPointerReleased = function(_, frame)
-        if frame < 0 then
-            for id, _ in pairs(pointer:GetIDs()) do
-                SMH.Controller.DeleteKeyframe(id)
-            end
-            return
-        end
+        local KeysToDelete, KeysToUpdate, UpdateStuff = {}, {}, {}
 
-        for id, _ in pairs(pointer:GetIDs()) do
-            SMH.Controller.UpdateKeyframe(id, { Frame = frame })
-        end
-
-        for id, kpointer in pairs(KeyframePointers) do
-            if id == keyframeId then continue end
-
-            if kpointer:GetFrame() == frame then
-                for ent, id in pairs(kpointer:GetEnts()) do
-                    if not pointer:GetEnts()[ent] then
-                        pointer:AddID(id, ent) -- gonna leave this logic in for the future stuff
-                        KeyframeIDs[id] = KeyframeIDs[keyframeId]
-                        kpointer:RemoveID(id)
-                    end
+        local function ReleaseAction(pointer, keyframeId, frame)
+            if frame < 0 then
+                for id, _ in pairs(pointer:GetIDs()) do
+                    table.insert(KeysToDelete, id)
                 end
-                DeleteEmptyKeyframe(kpointer)
+                return
             end
+
+            for id, _ in pairs(pointer:GetIDs()) do
+                table.insert(KeysToUpdate, id)
+                table.insert(UpdateStuff, { Frame = frame })
+            end
+
+            for id, kpointer in pairs(KeyframePointers) do
+                if id == keyframeId then continue end
+
+                if kpointer:GetFrame() == frame then
+                    for ent, id in pairs(kpointer:GetEnts()) do
+                        if not pointer:GetEnts()[ent] then
+                            pointer:AddID(id, ent) -- gonna leave this logic in for the future stuff
+                            KeyframeIDs[id] = KeyframeIDs[keyframeId]
+                            kpointer:RemoveID(id)
+                        end
+                    end
+                    DeleteEmptyKeyframe(kpointer)
+                end
+            end
+        end
+
+        for id, pointer in pairs(SelectedPointers) do
+            ReleaseAction(pointer, id, pointer:GetFrame())
+        end
+
+        ReleaseAction(pointer, keyframeId, frame)
+
+        if next(KeysToDelete) then
+            SMH.Controller.DeleteKeyframe(KeysToDelete)
+        end
+        if next(KeysToUpdate) then
+            SMH.Controller.UpdateKeyframe(KeysToUpdate, UpdateStuff)
         end
     end
 
     pointer.OnCustomMousePressed = function(_, mousecode)
         local frame = pointer:GetFrame()
+        local KeysToDelete = {}
 
         if SelectedPointers[keyframeId] then
             pointer:SetSelected(false)
@@ -182,20 +192,22 @@ local function NewKeyframePointer(keyframeId)
         end
 
         if mousecode == MOUSE_RIGHT and not input.IsKeyDown(KEY_LCONTROL) then
-            for id, kpointer in pairs(KeyframePointers) do
-                if SelectedPointers[id] then
-                    if kpointer == LastSelectedKeyframe then LastSelectedKeyframe = nil end
-                    for id, _ in pairs(kpointer:GetIDs()) do
-                        SMH.Controller.DeleteKeyframe(id)
-                    end
+            for id, kpointer in pairs(SelectedPointers) do
+                if kpointer == LastSelectedKeyframe then LastSelectedKeyframe = nil end
+                for id, _ in pairs(kpointer:GetIDs()) do
+                    table.insert(KeysToDelete, id)
                 end
             end
             for id, _ in pairs(pointer:GetIDs()) do
-                SMH.Controller.DeleteKeyframe(id)
+                table.insert(KeysToDelete, id)
             end
         elseif mousecode == MOUSE_MIDDLE or (mousecode == MOUSE_RIGHT and input.IsKeyDown(KEY_LCONTROL)) then
             CreateCopyPointer(keyframeId)
         end
+
+        if next(KeysToDelete) then
+            SMH.Controller.DeleteKeyframe(KeysToDelete)
+        end
     end
 
     return pointer
@@ -211,11 +223,13 @@ local function AddCallbacks()
         SMH.Controller.UpdateState(newState)
     end
     WorldClicker.MainMenu.OnRequestKeyframeUpdate = function(_, newKeyframeData)
+        local keyframes = {}
         for id, pointer in pairs(KeyframePointers) do
             if pointer:GetFrame() == SMH.State.Frame then
-                for id, mod in pairs(pointer:GetIDs()) do
-                    SMH.Controller.UpdateKeyframe(id, newKeyframeData)
+                for id, ent in pairs(pointer:GetIDs()) do
+                    table.insert(keyframes, id)
                 end
+                SMH.Controller.UpdateKeyframe(keyframes, newKeyframeData, true)
                 break
             end
         end
@@ -602,7 +616,7 @@ function MGR.MoveChildren(pointer, frame)
         end
     else
         for id, kpointer in pairs(KeyframePointers) do
-            if kpointer:GetParentKeyframe() == pointer then
+            if kpointer:GetParentKeyframe() == pointer then -- obsolete but i'm keeping this in here for future
                 kpointer:SetFrame(frame)
             end
             if kpointer == pointer then continue end
@@ -614,7 +628,7 @@ function MGR.MoveChildren(pointer, frame)
     end
 end
 
-function MGR.ClearFrames(pointer)
+function MGR.ClearFrames(pointer) -- i don't think i need this
     for id, kpointer in pairs(KeyframePointers) do
         if kpointer:GetParentKeyframe() == pointer then
             kpointer:OnPointerReleased(kpointer:GetFrame())
@@ -628,10 +642,8 @@ function MGR.ClearFrames(pointer)
 end
 
 function MGR.ClearAllSelected()
-    for id, pointer in pairs(KeyframePointers) do
-        if SelectedPointers[id] then
-            pointer:SetSelected(false)
-        end
+    for id, pointer in pairs(SelectedPointers) do
+        pointer:SetSelected(false)
     end
     LastSelectedKeyframe = nil
     SelectedPointers = {}
@@ -652,7 +664,7 @@ function MGR.ShiftSelect(pointer)
 
     for id, kpointer in pairs(KeyframePointers) do
         if kpointer:GetFrame() >= minimum and kpointer:GetFrame() <= maximum then
-            SelectedPointers[id] = true
+            SelectedPointers[id] = kpointer
             kpointer:SetSelected(true)
         end
     end
@@ -669,7 +681,7 @@ function MGR.ToggleSelect(pointer)
             LastSelectedKeyframe = kpointer
             for id, kpointer in pairs(KeyframePointers) do
                 if kpointer:GetFrame() == frame then
-                    SelectedPointers[id] = true
+                    SelectedPointers[id] = kpointer
                     kpointer:SetSelected(selected)
                 end
             end

lua/smh/server/controller.lua

@@ -115,47 +115,89 @@ local function CreateKeyframe(msgLength, player)
     net.Send(player)
 end
 
+local bufferData = {}
+
 local function UpdateKeyframe(msgLength, player)
-    local id = net.ReadUInt(INT_BITCOUNT)
-    local updateData = net.ReadTable()
-    local timeline = net.ReadUInt(INT_BITCOUNT)
+    bufferData[player] = {Ids = {}, UpdateData = {}, Timeline = 1}
 
-    local keyframe = SMH.KeyframeManager.Update(player, id, updateData, timeline)
-    local framecount, IDs, ents, Frame, In, Out, KModCount, KModifiers = SMH.TableSplit.DKeyframes({keyframe})
+    local count = net.ReadUInt(INT_BITCOUNT)
 
-    net.Start(SMH.MessageTypes.UpdateKeyframeResponse)
-    SendKeyframes(framecount, IDs, ents, Frame, In, Out, KModCount, KModifiers)
-    net.WriteBool(false)
-    net.Send(player)
+    for i = 1, count do
+        table.insert(bufferData[player].Ids, net.ReadUInt(INT_BITCOUNT))
+        local data = net.ReadString()
+
+        if data == "Frame" then
+            local temptable = {}
+            temptable[data] = net.ReadUInt(INT_BITCOUNT)
+            table.insert(bufferData[player].UpdateData, temptable)
+        else
+            local temptable = {}
+            temptable[data] = net.ReadFloat()
+            table.insert(bufferData[player].UpdateData, temptable)
+        end
+    end
+
+    bufferData[player].Timeline = net.ReadUInt(INT_BITCOUNT)
+end
+
+local function UpdateKeyframeExecute(msgLength, player)
+    local keyframes = SMH.KeyframeManager.Update(player, bufferData[player].Ids, bufferData[player].UpdateData, bufferData[player].Timeline)
+
+    for key, keyframe in ipairs(keyframes) do
+        local framecount, IDs, ents, Frame, In, Out, KModCount, KModifiers = SMH.TableSplit.DKeyframes({keyframe})
+
+        net.Start(SMH.MessageTypes.UpdateKeyframeResponse)
+        SendKeyframes(framecount, IDs, ents, Frame, In, Out, KModCount, KModifiers)
+        net.WriteBool(false)
+        net.Send(player)
+    end
+
+    bufferData[player] = {}
 end
 
 local function CopyKeyframe(msgLength, player)
-    local id = net.ReadUInt(INT_BITCOUNT)
-    local frame = net.ReadUInt(INT_BITCOUNT)
-    local timeline = net.ReadUInt(INT_BITCOUNT)
+    bufferData[player] = {Ids = {}, Frames = {}, Timeline = 1}
 
-    local keyframe = SMH.KeyframeManager.Copy(player, id, frame, timeline)
-    local framecount, IDs, ents, Frame, In, Out, KModCount, KModifiers = SMH.TableSplit.DKeyframes({keyframe})
+    local count = net.ReadUInt(INT_BITCOUNT)
 
-    net.Start(SMH.MessageTypes.UpdateKeyframeResponse)
-    SendKeyframes(framecount, IDs, ents, Frame, In, Out, KModCount, KModifiers)
-    net.WriteBool(false)
-    net.Send(player)
+    for i = 1, count do
+        table.insert(bufferData[player].Ids, net.ReadUInt(INT_BITCOUNT))
+        table.insert(bufferData[player].Frames, net.ReadUInt(INT_BITCOUNT))
+    end
+
+    bufferData[player].Timeline = net.ReadUInt(INT_BITCOUNT)
+end
+
+local function CopyKeyframeExecute(msgLength, player)
+    local keyframes = SMH.KeyframeManager.Copy(player, bufferData[player].Ids, bufferData[player].Frames, bufferData[player].Timeline)
+    
+    for key, keyframe in ipairs(keyframes) do
+        local framecount, IDs, ents, Frame, In, Out, KModCount, KModifiers = SMH.TableSplit.DKeyframes({keyframe})
+
+        net.Start(SMH.MessageTypes.UpdateKeyframeResponse)
+        SendKeyframes(framecount, IDs, ents, Frame, In, Out, KModCount, KModifiers)
+        net.WriteBool(false)
+        net.Send(player)
+    end
+
+    bufferData[player] = {}
 end
 
 local function DeleteKeyframe(msgLength, player)
-    local id = net.ReadUInt(INT_BITCOUNT)
-    local timeline = net.ReadUInt(INT_BITCOUNT)
+    local count, timeline = net.ReadUInt(INT_BITCOUNT), net.ReadUInt(INT_BITCOUNT)
 
-    local entity = SMH.KeyframeManager.Delete(player, id, timeline)
+    for i = 1, count do 
+        local id = net.ReadUInt(INT_BITCOUNT)
+        local entity = SMH.KeyframeManager.Delete(player, id, timeline)
 
-    SMH.PropertiesManager.RemoveEntity(player)
-    local isoldent = SMH.PropertiesManager.CheckEntity(player, entity)
+        SMH.PropertiesManager.RemoveEntity(player)
+        local isoldent = SMH.PropertiesManager.CheckEntity(player, entity)
 
-    net.Start(SMH.MessageTypes.DeleteKeyframeResponse)
-    net.WriteUInt(id, INT_BITCOUNT)
-    net.WriteBool(isoldent)
-    net.Send(player)
+        net.Start(SMH.MessageTypes.DeleteKeyframeResponse)
+        net.WriteUInt(id, INT_BITCOUNT)
+        net.WriteBool(isoldent)
+        net.Send(player)
+    end
 end
 
 local function StartPlayback(msgLength, player)
@@ -189,7 +231,7 @@ local function UpdateGhostState(msgLength, player)
 end
 
 local function GetServerSaves(msgLength, player)
-    local saves, keys, count = SMH.TableSplit.DList(SMH.Saves.ListFiles())
+    local saves, keys, count = SMH.TableSplit.DTable(SMH.Saves.ListFiles())
     net.Start(SMH.MessageTypes.GetServerSavesResponse)
     net.WriteUInt(count, INT_BITCOUNT)
     for i = 1, count do
@@ -203,7 +245,7 @@ local function GetModelList(msgLength, player)
     local path = net.ReadString()
 
     local modelslist, map = SMH.Saves.ListModels(path)
-    local models, keys, count = SMH.TableSplit.DList(modelslist)
+    local models, keys, count = SMH.TableSplit.DTable(modelslist)
     net.Start(SMH.MessageTypes.GetModelListResponse)
     net.WriteUInt(count, INT_BITCOUNT)
     for i = 1, count do
@@ -215,7 +257,7 @@ local function GetModelList(msgLength, player)
 end
 
 local function GetServerEntities(msgLength, player)
-    local entities, keys, count = SMH.TableSplit.DList(SMH.PropertiesManager.GetAllEntitiesNames(player))
+    local entities, keys, count = SMH.TableSplit.DTable(SMH.PropertiesManager.GetAllEntitiesNames(player))
 
     net.Start(SMH.MessageTypes.GetServerEntitiesResponse)
     net.WriteUInt(count, INT_BITCOUNT)
@@ -555,7 +597,9 @@ net.Receive(SMH.MessageTypes.SelectEntity, SelectEntity)
 
 net.Receive(SMH.MessageTypes.CreateKeyframe, CreateKeyframe)
 net.Receive(SMH.MessageTypes.UpdateKeyframe, UpdateKeyframe)
+net.Receive(SMH.MessageTypes.UpdateKeyframeExecute, UpdateKeyframeExecute)
 net.Receive(SMH.MessageTypes.CopyKeyframe, CopyKeyframe)
+net.Receive(SMH.MessageTypes.CopyKeyframeExecute, CopyKeyframeExecute)
 net.Receive(SMH.MessageTypes.DeleteKeyframe, DeleteKeyframe)
 
 net.Receive(SMH.MessageTypes.StartPlayback, StartPlayback)

lua/smh/server/ghosts_manager.lua

@@ -173,7 +173,8 @@ function MGR.UpdateState(player, frame, settings, settimeline)
         end
 
         for _, g in ipairs(ghosts) do
-            if not g.Entity == entity then continue end
+
+            if not (g.Entity == entity) then continue end
 
             for name, mod in pairs(SMH.Modifiers) do
                 if filtermods[name] then continue end -- we used these modifiers already
@@ -201,6 +202,7 @@ function MGR.UpdateState(player, frame, settings, settimeline)
                     end
                 end
             end
+
         end
 
         ClearNoPhysGhosts(ghosts) -- need to delete ragdoll ghosts that don't have physbone modifier, or else they'll just keep falling through ground.

lua/smh/server/keyframe_manager.lua

@@ -3,10 +3,9 @@ local function GetExistingKeyframe(player, entity, frame, modnames)
         return nil
     end
     if not modnames then
-        modnames = {}
+        modnames = { "world" }
         for name, mod in pairs(SMH.Modifiers) do
             table.insert(modnames, name)
-            table.insert(modnames, "world")
         end
     end
 
@@ -120,109 +119,132 @@ function MGR.Create(player, entity, frame, timeline)
     return keyframes
 end
 
-function MGR.Update(player, keyframeId, updateData, timeline)
-    if not SMH.KeyframeData.Players[player] or not SMH.KeyframeData.Players[player].Keyframes[keyframeId] then
-        error("Invalid keyframe ID")
-    end
+function MGR.Update(player, keyframeIds, updateData, timeline)
+    local keyframes, movingkeyframes = {}, {}
 
-    local keyframe = SMH.KeyframeData.Players[player].Keyframes[keyframeId]
-    local modnames = player == keyframe.Entity and {"world"} or SMH.Properties.Players[player].Entities[keyframe.Entity].TimelineMods[timeline]
-    local updateableFields = {
-        "Frame",
-        "EaseIn",
-        "EaseOut",
-    }
-    for _, field in pairs(updateableFields) do
-        if updateData[field] then
-            if field == "Frame" then
-                if updateData[field] == keyframe.Frame then continue end
-                local remainmods, EaseIn, EaseOut, frame = table.Copy(keyframe.Modifiers), table.Copy(keyframe.EaseIn), table.Copy(keyframe.EaseOut), updateData[field]
-                for _, name in ipairs(modnames) do
-                    remainmods[name] = nil
-                    EaseIn[name] = nil
-                    EaseOut[name] = nil
-                end
+    for id, keyframeId in ipairs(keyframeIds) do
+        if not SMH.KeyframeData.Players[player] or not SMH.KeyframeData.Players[player].Keyframes[keyframeId] then
+            error("Invalid keyframe ID")
+        end
 
-                if next(remainmods) then -- if there are any modifiers remaining, then we create another keyframe that will stay there
-                    local remainkeyframe = SMH.KeyframeData:New(player, keyframe.Entity)
-
-                    for name, _ in pairs(remainmods) do
-                        ClearModifier(keyframe, name)
+        local keyframe = SMH.KeyframeData.Players[player].Keyframes[keyframeId]
+        local modnames = player == keyframe.Entity and {"world"} or SMH.Properties.Players[player].Entities[keyframe.Entity].TimelineMods[timeline]
+        local updateableFields = {
+            "Frame",
+            "EaseIn",
+            "EaseOut",
+        }
+        for _, field in pairs(updateableFields) do
+            if updateData[id][field] then
+                if field == "Frame" then
+                    if updateData[id][field] == keyframe.Frame then continue end
+                    local remainmods, EaseIn, EaseOut, frame = table.Copy(keyframe.Modifiers), table.Copy(keyframe.EaseIn), table.Copy(keyframe.EaseOut), updateData[id][field]
+                    for _, name in ipairs(modnames) do
+                        remainmods[name] = nil
+                        EaseIn[name] = nil
+                        EaseOut[name] = nil
                     end
-                    remainkeyframe.Frame = keyframe.Frame
-                    remainkeyframe.Modifiers = remainmods
-                    remainkeyframe.EaseIn = EaseIn
-                    remainkeyframe.EaseOut = EaseOut
-                end
 
-                local replacekey = GetExistingKeyframe(player, keyframe.Entity, frame)
-                if replacekey ~= nil and replacekey ~= keyframe then
-                    for name, data in pairs(replacekey.Modifiers) do
-                        if not keyframe.Modifiers[name] then
-                            keyframe.Modifiers[name] = data
-                            keyframe.EaseIn[name] = replacekey.EaseIn[name]
-                            keyframe.EaseOut[name] = replacekey.EaseOut[name]
+                    if next(remainmods) then -- if there are any modifiers remaining, then we create another keyframe that will stay there
+                        local remainkeyframe = SMH.KeyframeData:New(player, keyframe.Entity)
+
+                        for name, _ in pairs(remainmods) do
+                            ClearModifier(keyframe, name)
                         end
+                        remainkeyframe.Frame = keyframe.Frame
+                        remainkeyframe.Modifiers = remainmods
+                        remainkeyframe.EaseIn = EaseIn
+                        remainkeyframe.EaseOut = EaseOut
                     end
-                    SMH.KeyframeData:Delete(player, replacekey.ID)
-                end
-                keyframe.Frame = frame
-            else
-                for _, name in ipairs(modnames) do
-                    if not keyframe[field][name] then continue end
-                    keyframe[field][name] = updateData[field]
+
+                    movingkeyframes[keyframe] = frame
+                else
+                    for _, name in ipairs(modnames) do
+                        if not keyframe[field][name] then continue end
+                        keyframe[field][name] = updateData[id][field]
+                    end
+                    table.insert(keyframes, keyframe)
                 end
             end
         end
     end
 
-    return keyframe
+    for keyframe, frame in pairs(movingkeyframes) do
+        local replacekey = GetExistingKeyframe(player, keyframe.Entity, frame)
+
+        if replacekey ~= nil and not movingkeyframes[replacekey] then
+            for name, data in pairs(replacekey.Modifiers) do
+
+                if not keyframe.Modifiers[name] then
+                    keyframe.Modifiers[name] = data
+                    keyframe.EaseIn[name] = replacekey.EaseIn[name]
+                    keyframe.EaseOut[name] = replacekey.EaseOut[name]
+                end
+            end
+            SMH.KeyframeData:Delete(player, replacekey.ID)
+        end
+        keyframe.Frame = frame
+        table.insert(keyframes, keyframe)
+    end
+
+    return keyframes
 end
 
-function MGR.Copy(player, keyframeId, frame, timeline)
-    if not SMH.KeyframeData.Players[player] or not SMH.KeyframeData.Players[player].Keyframes[keyframeId] then
-        error("Invalid keyframe ID")
-    end
+function MGR.Copy(player, keyframeIds, frame, timeline)
+    local copiedKeyframes, movingkeyframes = {}, {}
 
-    local keyframe = SMH.KeyframeData.Players[player].Keyframes[keyframeId]
-    local modnames = player == keyframe.Entity and {"world"} or SMH.Properties.Players[player].Entities[keyframe.Entity].TimelineMods[timeline]
-
-    local EaseIn, EaseOut, Mods = {}, {}, {}
-    for _, name in ipairs(modnames) do
-        if not keyframe.Modifiers[name] then continue end
-        EaseIn[name] = keyframe.EaseIn[name]
-        EaseOut[name] = keyframe.EaseOut[name]
-        Mods[name] = keyframe.Modifiers[name]
-    end
-
-    local copiedKeyframe = SMH.KeyframeData:New(player, keyframe.Entity)
-    copiedKeyframe.EaseIn = EaseIn
-    copiedKeyframe.EaseOut = EaseOut
-    copiedKeyframe.Modifiers = Mods
-
-    local replacekey = GetExistingKeyframe(player, copiedKeyframe.Entity, frame)
-    if replacekey ~= nil and replacekey ~= keyframe then
-        for name, data in pairs(replacekey.Modifiers) do
-            if not copiedKeyframe.Modifiers[name] then
-                copiedKeyframe.Modifiers[name] = data
-                copiedKeyframe.EaseIn[name] = replacekey.EaseIn[name]
-                copiedKeyframe.EaseOut[name] = replacekey.EaseOut[name]
-            end
+    for id, keyframeId in ipairs(keyframeIds) do
+        if not SMH.KeyframeData.Players[player] or not SMH.KeyframeData.Players[player].Keyframes[keyframeId] then
+            error("Invalid keyframe ID")
         end
-        SMH.KeyframeData:Delete(player, replacekey.ID)
+
+        local keyframe = SMH.KeyframeData.Players[player].Keyframes[keyframeId]
+        local modnames = player == keyframe.Entity and {"world"} or SMH.Properties.Players[player].Entities[keyframe.Entity].TimelineMods[timeline]
+
+        local EaseIn, EaseOut, Mods = {}, {}, {}
+        for _, name in ipairs(modnames) do
+            if not keyframe.Modifiers[name] then continue end
+            EaseIn[name] = keyframe.EaseIn[name]
+            EaseOut[name] = keyframe.EaseOut[name]
+            Mods[name] = keyframe.Modifiers[name]
+        end
+
+        local copiedKeyframe = SMH.KeyframeData:New(player, keyframe.Entity)
+        copiedKeyframe.EaseIn = EaseIn
+        copiedKeyframe.EaseOut = EaseOut
+        copiedKeyframe.Modifiers = Mods
+
+        movingkeyframes[copiedKeyframe] = frame[id]
     end
 
-    copiedKeyframe.Frame = frame
+    for keyframe, frame in pairs(movingkeyframes) do
+        local replacekey = GetExistingKeyframe(player, keyframe.Entity, frame)
 
-    return copiedKeyframe
+        if replacekey ~= nil and not movingkeyframes[replacekey] then
+            for name, data in pairs(replacekey.Modifiers) do
+                if not keyframe.Modifiers[name] then
+                    keyframe.Modifiers[name] = data
+                    keyframe.EaseIn[name] = replacekey.EaseIn[name]
+                    keyframe.EaseOut[name] = replacekey.EaseOut[name]
+                end
+            end
+            SMH.KeyframeData:Delete(player, replacekey.ID)
+        end
+
+        keyframe.Frame = frame
+        table.insert(copiedKeyframes, keyframe)
+    end
+
+    return copiedKeyframes
 end
 
 function MGR.Delete(player, keyframeId, timeline)
-    local entity = SMH.KeyframeData.Players[player].Keyframes[keyframeId].Entity
     if not SMH.KeyframeData.Players[player] or not SMH.KeyframeData.Players[player].Keyframes[keyframeId] then
         error("Invalid keyframe ID")
     end
 
+    local entity = SMH.KeyframeData.Players[player].Keyframes[keyframeId].Entity
+
     local keyframe = SMH.KeyframeData.Players[player].Keyframes[keyframeId]
     local modnames = player == keyframe.Entity and {"world"} or SMH.Properties.Players[player].Entities[keyframe.Entity].TimelineMods[timeline]
 

lua/smh/shared.lua

@@ -11,7 +11,9 @@ SMH.MessageTypes = {
 
     "CreateKeyframe",
     "UpdateKeyframe",
+    "UpdateKeyframeExecute",
     "CopyKeyframe",
+    "CopyKeyframeExecute",
     "UpdateKeyframeResponse",
     "DeleteKeyframe",
     "DeleteKeyframeResponse",

lua/smh/shared/tablesplit.lua

@@ -90,7 +90,7 @@ function MGR.GetProperties()
     return timeline
 end
 
-function MGR.DList(list)
+function MGR.DTable(list)
     local items, keys, count = {}, {}, 0
     for key, item in pairs(list) do
         table.insert(items, item)
@@ -100,7 +100,7 @@ function MGR.DList(list)
     return items, keys, count
 end
 
-function MGR.AList(key, item)
+function MGR.ATable(key, item)
     if not tonumber(key) then
         listAssembling[key] = item
     else
@@ -108,7 +108,7 @@ function MGR.AList(key, item)
     end
 end
 
-function MGR.GetList()
+function MGR.GetTable()
     local list = table.Copy(listAssembling)
     listAssembling = {}
     return list