View difference between Paste ID: hPHgy2iN and weMqyL0N

-local print = epoe.Print
+
-local me = me
+local sounddict = {
--- config / gmod specific
+    ["hi"] = "",
     ["hi there"] = "",
-local SOUNDS = {
+    ["eat me"] = "",
-	hi = "ambient/levels/prison/radio_random11.wav",
+    ["eat"] = "",
-	oh = "ambient/energy/spark3.wav",
+    ["an eye for an eye"] = "",
-	boop = "buttons/button16.wav",
+    ["an eye for an apple or banana"] = "",
-	kick = "weapons/crossbow/hitbod1.wav",
+    ["orange"] = "",
-	beep = "npc/attack_helicopter/aheli_crash_alert2.wav",
+    ["cactus"] = "",
-	snare = "physics/flesh/flesh_strider_impact_bullet3.wav",
+    ["cactus please"] = "",
-	wood = "physics/wood/wood_box_impact_bullet4.wav"
+    ["no sir"] = "",
 }
 
-local MODIFIERS = {
+local testphraselist = {
-	["&"] = {
+    "hello",
-		args = {
+    "say hi",
-			function(dsp) return math.Clamp(tonumber(dsp) or 0, 0, 128) end
+    "hi there",
-		},
+    "oh hi there",
-
+    "an eye for an eye for an eye for an apple or banana",
-		start = function(self, dsp)
+    "an eye for an apple or banana",
-			LocalPlayer():SetDSP(dsp)
+    "cactus orange no sir",
-		end,
+    "eat me hi",
-
+
-		stop = function(self, dsp)
+
-			LocalPlayer():SetDSP(0)
+local soundtree = {}
-		end,
+local soundtree_filekey = newproxy and newproxy() or {}
-	},
+for sound_patt, sound_file in pairs(sounddict) do
-	["=="] = {
+    local currnode = soundtree
-		args = {
+    for part in string.gmatch(sound_patt, "([a-z_]+)") do
-			function(time) return tonumber(time) or 1 end
+        -- TODO: preprocess part to ignore case and such
-		},
+        currnode[part] = currnode[part] or {}
-
+        currnode = currnode[part]
-		init = function(self, time)
+    end
-			self.duration = time
+    currnode[soundtree_filekey] = string.gsub(sound_patt, " ", "_")..".wav"
-		end,
+
-	},
+
-	["--"] = {
+function stuff(soundtree, phrase)
-		args = {
+    -- TODO: preprocess phrase to ignore case and such
-			function(stop_percent) return tonumber(stop_percent) or 100 end
+
-		},
+    local foundlist = {}
-
+
-		init = function(self, stop_percent)
+    local stack_i = 0
-			self.duration = self.duration * (stop_percent / 100)
+    local stack_eposlist = { [0] = 1 }
-		end,
+    local stack_nodelist = { [0] = soundtree }
-	},
+    local complete, atend = false, false
-	["="] = {
+    local backtrack = false
-		args = {
+    repeat
-			function(time) return tonumber(time) or 0 end
+        local spos = stack_eposlist[stack_i]
-		},
+        local node = stack_nodelist[stack_i]
-
+        stack_i = stack_i+1
-		init = function(self, time)
+        -- get next word
-			self.duration = time
+        local word_s, word_e, mods = string.find(phrase, "([a-z_]+)(%p%d)+", spos, true)
-		end,
+        if word_s then
-	},
+            -- we have a next word
-	["%"] = {
+            local word = string.sub(phrase, word_s, word_e)
-		args = {
+            local subnode = node[word] -- (you could do pattern matching here)
-			function(pitch) return math.Clamp(tonumber(pitch) or 100, 0, 255) end,
+            if subnode then
-			function(time) return tonumber(time) or 0 end,
+                -- we have a pattern that matches this next word
-		},
+                -- (could be first, middle or last word in pattern!)
-
+                stack_eposlist[stack_i] = word_e+1
-		init = function(self, pitch, time)
+                stack_nodelist[stack_i] = subnode
-			self.duration = self.duration / (pitch / 100)
+                -- continue
-			self.duration = self.duration + time
+            else
-		end,
+                -- there is no continuing pattern that matches this word
-
+                if stack_i == 1 then
-		think = function(self, pitch, time)
+                    -- this is the first word or next unmatched word and no pattern starts with it
-			if self.csp then
+                    -- so jump to next word
-				self.csp:ChangePitch(pitch, time)
+                    stack_i = 0
-			end
+                    stack_eposlist[0] = word_e+1
-		end,
+                else
-	},
+                    -- we were matching a pattern, see what comes of it
-	["^"] = {
+                    -- (this word did not continue any pattern, so it's not considered)
-		args = {
+                    backtrack = true
-			function(volume) return math.Clamp(tonumber(volume) or 100, 0, 100) end,
+                end
-			function(time) return tonumber(time) or 0 end,
+            end
-		},
+        else
-
+            -- there is no next word, check for patterns
-		think = function(self, volume, time)
+            -- (last few words may be rechecked if there is no sound for their nodes)
-			if self.csp then
+            atend = true
-				if self.source_entity == LocalPlayer() then
+            backtrack = true
-					volume = volume / 2
+        end
-				end
+        if backtrack then
-
+            -- find the longest pattern on the stack that has a sound associated
-				self.csp:ChangeVolume(volume / 100, time)
+            for stack_j = stack_i-1, 1, -1 do
-			end
+                -- work backwards through each word to see if it has a sound
-		end,
+                local node = stack_nodelist[stack_j]
-	}
+                local soundfile = node[soundtree_filekey]
                 if soundfile then
                     -- this word has a sound
-local function PLAY_SOUND(self)
+                    table.insert(foundlist, soundfile)
-	local csp = CreateSound(me, self.path)
+                    -- TODO: handle mods here
-	csp:PlayEx(1, 0)
+
-	self.source_entity = me
+                    if stack_j == stack_i and atend then
-	self.csp = csp
+                        -- we consumed the last word
                         complete = true
                     else
-local function STOP_SOUND(self)
+                        -- start searching for new patterns
-	if self.csp then
+                        stack_i = 0
-		self.csp:Stop()
+                        -- resume from word after longest pattern with a sound
-	end
+                        stack_eposlist[0] = stack_eposlist[stack_j+1]
                     end
                     -- stop backtracking
-local function GET_DURATION(self)
+                    break
-	return SoundDuration(self.path)	or 0
+                end
             end
             backtrack, atend = false, false
---
+        end
-local cache = {}
+    until complete
 
-local function parse(str)
+    return foundlist
-	if cache[str] then return cache[str] end
+
-
+
-	local out = {}
+for testphrase_i = 1, #testphraselist do
-
+    local testphrase = testphraselist[testphrase_i]
-	-- lowercase it so we don't have to deal with case sensitivity
+    local out = stuff(soundtree, testphrase)
-	str = str:lower()
+    for sound_i = 1, #out do
-
+        print(out[sound_i])
-	-- add a last space so it matches the end as well
+    end
-	str = str .. " "
+end