Grimrock

Code: Select all

function randomTele(teleporter_id)
  local rand_x = {15,17,15,17}
  local rand_y = {28,28,30,30}
  local rand_l = {1,1,1,1}
  local rand = math.random(1,math.min(#rand_x,#rand_y,#rand_l))
  teleporter_id:setTeleportTarget(rand_x[rand],rand_y[rand],party.facing,rand_l[rand])
end

function teleActivate(plate)
  tele_id = plate.id:sub(1,8) .. "_tele"
  local tele_port = findEntity(tele_id)
  randomTele(tele_port)
end

Code: Select all

-- This variable keeps track of how many steps in the pattern have been taken.
current = 0

function step(source)
	-- This table defines the pattern we are looking for.
	local pattern = {3, 1, 3, 2}
	
	-- Identify the source that triggered the step. Each potential source needs to have an id ending in a number that identifies its part (if any) in the pattern.
	local _, _, latestId = source.id:find("(%d+)$")
	local latestId = tonumber(latestId)
	
	-- Check whether the source is the next step in the pattern.
	current = current + 1
	if latestId == pattern[current] then
		
		-- Pattern advanced, check whether it is complete.
		if pattern[current + 1] == nil then
			-- To reset at completion, remove the call to backtrack and assign 0 to current instead.
			backtrack(pattern, latestId)
			patternDetected()
		end
		
	else
		backtrack(pattern, latestId)
	end
end

function backtrack(pattern, latestId)
	-- See if the latest steps match a shorter subsequence at the beginning of the pattern.
	local next
	for i = current-1, 1, -1 do
		next = i
		
		if latestId == pattern[i] then
			for j = 1, i-1 do
				if pattern[j] ~= pattern[current - i + j] then
					next = nil
					break
				end
			end
		else
			next = nil
		end
		
		if next ~= nil then
			break
		end
	end
	
	-- If a valid subsequence was found, set the current position to match it.
	if next ~= nil then
		current = next
	else
		current = 0
	end
end

function patternDetected()
	-- A complete pattern has been detected.
end

Code: Select all

onAttack = function(self, attack)
local dx, dy = getForward(self.facing)
if attack == "attack" then
   spawn("fireburst", self.level, self.x+dx, self.y+dy, 0)
elseif attack == "turnAttackLeft" then
   spawn("fireburst", self.level, self.x+dy, self.y-dx, 0)
elseif attack == "turnAttackRight" then
   spawn("fireburst", self.level, self.x-dy, self.y+dx, 0)
end
   end,

Code: Select all

tic = true
function ticking()
  if tic then
    playSound("click_down")
  else
    playSound("click_up")
  end
  tic = not tic
end

Code: Select all

-- Script for a "lights out" style lever puzzle, where toggling one lever also
-- toggles all "adjacent" levers.  Each lever can be connected to any number of
-- other levers.  The puzzle is "solved" when all levers are "activated" (in
-- LoG a lever is activated when it is down).  

-- USING THIS SCRIPT: 
-- Define adjacent levers using the "levers" variable.  Change the "Solved"
-- function to perform the action to take when the puzzle is solved.  Change
-- the "Unsolved" function to be the action to take when the puzzle is moved
-- out of the solved state.  Then, add connectors to each lever like such:

--  Event        Target             Aciton
--   any    ->    this script  ->    PullLever


-- levers is the list of lever adjacencies. Each item in the table should
-- corispond to a single lever used in the puzzle. The key should be the
-- id of each lever, and the value is a list of ids of the levers to toggle
-- when the key lever is pulled.  For example:
--     leverX={"LeverY", "LeverZ", "LeverW"}
-- will cause leverY, LeverZ, and LeverW to be toggled whenever leverX is
-- toggled. Notice that the keys are not surronded by quotes, while the
-- adjancet levers are.  There is no limit to the number of levers in the
-- puzzle or the number of levers adjancet to each lever.
levers = {
	lever1={"lever2"},
	lever2={"lever1", "lever3"},
	lever3={"lever2", "lever4"},
	lever4={"lever3", "lever5"},
	lever5={"lever4"}
}

-- The following function will be called when the puzzle is "solved",
-- meaning that all levers are "activated" (down).  For example, this
-- function could a door.
function Solved()
	puzzleDoor:open()
end

-- The following function will be called when the puzzle is in any state that
-- is not "solved".  For example, closing a door.  If the puzzle should stay
-- "solved" after the player solves the puzzle once, you can leave this function
-- blank.
function Unsolved()
	puzzleDoor:close()
end

-- Set the following variable to true in order to make the puzzle solved when
-- all levers are deactivated too.  This is useful if you only want to make
-- the player get all levers to the same state, rather than forcing all levers
-- to be down.  Note that if you do this, you should be sure to start some 
-- levers up and some down, so the puzzle doesn't start solved
solvedWhenDeactive = false


----------- You shouldn't need to change anything below this point ----------

-- locked is a semaphore to prevent an infinite loop. You can ignore it.
locked = false 

-- Pull lever is the action that should be taken when a lever in the puzzle is
-- toggled. Connect each lever in the puzzle to this function.
function PullLever(trigger)
	-- Only run if the semaphore is not set, in order to prevent infinite recursion
	if not locked then
		-- Set the semaphore
		locked = true

		-- If the triggering lever is in the adjaceny list, loop over all its
		-- adjacent levers and toggle them in turn.
		if levers[trigger.id] then
			for _, id in ipairs(levers[trigger.id]) do
				-- search for the lever by id, and toggle it.
				findEntity(id):toggle()
			end
		end
		-- There's no more chance for recursion, so clear the semaphore.
		locked = false

		-- Loop over each lever in the puzzle, as defined by the keys in the
		-- levers table, and check to see if every one is activated or every
		-- one is deactivated.
		local allActive = true
		local allDeactive = true
		for id, _ in pairs(levers) do
			-- find each lever by id, and check its state.
			local lever = findEntity(id)
			allActive = allActive and lever:getLeverState() == "activated"
			allDeactive = allDeactive and lever:getLeverState() == "deactivated"
		end

		-- If all levers are active, or if solvedWhenDeactive is set and all
		-- levers are deactive, call the Solved function.  Otherwise, call
		-- the Unsolved function.
		if allActive or (solvedWhenDeactive and allDeactive) then
			Solved()
		else
			Unsolved()
		end
	end
end

Code: Select all

cloneObject{
  name = "party",
  baseObject = "party",
  onAttack = function(champ,weapon)
    dexAttackScript.dexAttack(champ,weapon)
  end,
}

Code: Select all

str = 0
ch = 0

dexAttack(champ,weapon)
  ch = champ:getOrdinal()
  str = champ:getStatMax("strength")
  local dex = champ:getStatMax("dexterity")
  if weapon.name == "sling" or weapon.name == "short_bow" or weapon.name "crossbow" or weapon.name == "longbow" then
     champ:setStatMax("strength", str+(dex*0.5)) -- change 0.5 to whatever you want
     champ:setStat("strength", str+(dex*0.5))
  end
  spawn("timer",party.level,party.x,party.y,0,"dexAttackTimer")
   :setTimerInterval(0.03)
   :addConnector("activate", "dexAttackScript", "strReset")
   :activate()
end

strReset()
  party:getChampion(ch):setStatMax("strength", str)
  dexAttackTimer:destroy()
end