balken && metablobs

.gitignore

@@ -1 +1,2 @@
 *.pyc
+*swp

balken/README.md

@@ -0,0 +1,4 @@
+balken
+=======
+
+3D spalten :)

balken/bot.lua

@@ -0,0 +1,132 @@
+
+
+function Field:getInput()
+
+	local key_down = {}
+	if self.key_state then
+		-- human
+		key_down.right = self.key_state.right
+		key_down.left = self.key_state.left
+		key_down.down = self.key_state.down
+		key_down.rot = self.key_state.a
+
+	else
+		-- bot
+		key_down = self:bot()
+	end
+
+	local events = {}
+	local dx = bool[key_down.right] - bool[key_down.left]
+	if dx ~= self.input.dx then
+		self.input.rep = 0
+	end
+	self.input.dx = dx
+	self.input.rep = self.input.rep - 1
+	if self.input.rep <= 0 then
+		events.dx = dx
+		self.input.rep = 3
+	else
+		events.dx = 0
+	end
+	events.down = key_down.down
+	events.rot = key_down.rot and not self.input.rot
+	self.input.rot = key_down.rot
+
+	return events
+end
+
+
+function Field:bot()
+
+	-- stateless bot - very inefficient, but it kinda works
+	-- go through all moves, choose the 'best'
+
+	local save_x = self.x
+	local save_y = self.y
+
+	local moves = {}
+	-- do nothing if no move can be found
+	moves[0] = {
+		{ x = self.x, rot = 0 }
+	}
+
+	for rot = 0, 2 do
+		for x = 1, 6 do
+			self.x = x
+			self.y = save_y
+			if not self:collision() then
+				repeat
+					self.y = self.y + 1
+				until self:collision()
+				self.y = self.y - 1
+				if self.y >= 3 then
+					self:pushColumn()
+
+					self:findGemsInLine()
+					local magic = self.combo_count * 4
+					for y2 = 1, 13 do
+						if math.max(unpack(self.grid[self.layer][y2])) > 0 then
+							magic = magic + y2
+							break
+						end
+					end
+
+					if not moves[magic] then
+						moves[magic] = {}
+					end
+					table.insert(moves[magic], { x = x, rot = rot })
+
+					self.gems_in_line = {}
+					self.combo_count = 0
+
+
+					-- reverse the push
+					self.grid[self.layer][self.y][self.x] = 0
+					self.grid[self.layer][self.y - 1][self.x] = 0
+					self.grid[self.layer][self.y - 2][self.x] = 0
+				end
+
+			end
+		end
+
+		-- rotate
+		local c = self.column
+		c[1], c[2], c[3] = c[3], c[1], c[2]
+	end
+	self.x = save_x
+	self.y = save_y
+
+	-- select any of the best moves
+	local max_magic = 0
+	for i, l in pairs(moves) do
+		if i > max_magic then
+			max_magic = i
+		end
+	end
+
+	local best_move = moves[max_magic][1]
+	for _, move in ipairs(moves[max_magic]) do
+		if math.abs(move.x - self.x) < math.abs(best_move.x - self.x) then
+			best_move = move
+		end
+	end
+
+	local key_down = {}
+
+	-- easy bot
+	key_down.left = self.x > best_move.x and math.random(10) == 1
+	key_down.right = self.x < best_move.x and math.random(10) == 1
+	key_down.down = self.x == best_move.x and self.y > math.random(10)
+	key_down.rot =  best_move.rot > 0 and math.random(3) == 1
+
+--[[
+	-- fast bot
+	key_down.left = self.x > best_move.x
+	key_down.right = self.x < best_move.x
+	key_down.down = self.x == best_move.x or math.random(3) == 1
+	key_down.rot =  best_move.rot > 0 and math.random(2) == 1
+--]]
+
+	return key_down
+end
+

balken/conf.lua

@@ -0,0 +1,9 @@
+function love.conf(t)
+	t.title = "spalten"
+	t.author = "twobit"
+	t.screen.width = 320
+	t.screen.height = 300
+	t.screen.vsync = false
+	t.modules.physics = false
+	t.modules.mouse = false
+end

balken/draw.lua

@@ -0,0 +1,103 @@
+
+local string = string
+local floor = math.floor
+
+
+local gem_colors = {}
+gem_colors[-2] = {136, 136, 136}   -- border
+gem_colors[-1] = { 85,  85,  85}   -- brick
+gem_colors[0] =  {  0,   0,   0}   -- background
+
+gem_colors[1] = {187,  34,   0}
+gem_colors[2] = {  0, 170, 187}
+gem_colors[3] = {  0, 187,   0}
+gem_colors[4] = {187, 187,   0}
+gem_colors[5] = {136,   0, 187}
+gem_colors[6] = {  0, 187, 187}
+
+local function Color(c)
+    return string.format("%02X%02X%02X", floor(c[1]), floor(c[2]), floor(c[3]))
+end
+
+
+function Field:draw()
+
+    local layer = self.layer
+    if self.state ~= "normal" then
+        layer = (layer - 1) % self.width + 1
+    end
+
+    local g = {}
+    for i = 0, self.height+1 do
+        local row = {}
+        for j = 0, self.width+1 do
+            row[j] = {}
+            for i, col in ipairs(gem_colors[0]) do
+                row[j][i] = col
+            end
+        end
+        g[i] = row
+    end
+
+    for _z = 0, self.width+1 do
+        local z = ((self.width - _z) + layer) % self.width + 1
+        for y = 0, self.height+1 do
+            local row = self.grid[z][y] or {}
+            for x = 0, self.width+1 do
+
+                local gem = row[x]
+                if self.state == "normal" and y > 0 and x == self.x then
+                    -- also draw active column
+                    gem = self.column[self.y - y + 1] or gem
+                end
+                local is_empty =
+                    g[y][x][1] == gem_colors[0][1] and
+                    g[y][x][2] == gem_colors[0][2] and
+                    g[y][x][3] == gem_colors[0][3]
+                gem = gem or -2
+                for i, col in ipairs(gem_colors[gem]) do
+                    if is_empty or gem ~= 0 then
+                        g[y][x][i] = col * _z/(self.width+1)
+                        if gem ~= -2 then
+                            g[y][x][i] = g[y][x][i] * (
+                                (z == layer or
+                                (x==self.x and
+                                y>=self.y-2 and
+                                y<=self.y)) and
+                                1 or 0.3)
+                        end
+                    end
+                end
+            end
+        end
+    end
+    for y = 0, self.height+1 do
+        for x = 0, self.width+1 do
+            wall:pixel(self.pos + x-1, y-1, Color(g[y][x]))
+        end
+    end
+
+	-- draw flashing gems
+	if self.state == "highlight" then
+		for _, coords in pairs(self.gems_in_line) do
+			local color = ({ "ffffff", "000000" })[self.state_delay % 3 + 1]
+			if color then
+				wall:pixel(self.pos + coords.x-1, coords.y-1, color)
+			end
+		end
+	end
+
+	-- draw score
+	local score = self.score
+	local y = self.height
+	local x = self.pos == 0 and self.width or self.pos-1
+	while score > 0 and y >= 0 do
+		if score % 2 > 0 then
+			wall:pixel(x, y, "aaaaaa")
+		end
+		score = math.floor(score / 2)
+		y = y - 1
+	end
+end
+
+