Some work on implementing underpill.

[poca-love.git] / main.lua

--[[
POCA - a game of logic
Copyright 2019 Pajo <xpio at tut dot by>

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <https://www.gnu.org/licenses/>.
]]

-- love 11.1

require('images')
require('levels')
require('anim')
require('menu')
require('trinkets')

function love.load()
        
        directions = { 
                {1, 0}, {1, -1}, {0, -1}, {-1, -1},
                {-1, 0}, {-1, 1}, {0, 1}, {1, 1}
        }

        game = {
                screen = 'playfield', -- 'playfield', 'menu_objects', 'story_beginning' ...
                shown_screens = {},
                change_screen = function(self, newscreen, only_once)
                        if only_once and self.shown_screens[newscreen] then return end
                        self.shown_screens[newscreen] = true
                        menu_elements.drawn = nil
                        self.screen = newscreen
                        if newscreen == 'playfield' then
                                screen.bgcanvas = nil
                        elseif not screen.bgcanvas then
                                screen.bgcanvas = love.graphics.newCanvas(screen.width, screen.height)
                                screen.bgcanvas:renderTo(draw_playfield)
                        end
                end,
                phase = 'play', -- see next_phase()
                timer = 0,
                temppurple = false,
                purple = false,
                died = false,
                showkill = false,
                devil = false,
                underpill = false,
        }

        screen = {}
        love.resize()
        
        playfield = {{}, {}, {}, {}}
        setuplevel(96)
        
end


function explode_clicked()
        local p = playfield[playfield.clickedx][playfield.clickedy]
        if p.kind == 'memory' then
                playfield[playfield.clickedx][playfield.clickedy] = p.memory --recognizeink(p.of)
                return
        end
        -- clicked arrows should explode, even if player dies
        -- to explain turning of yellow arrows, and just for fun
        -- first, copy them to new table
        local newtile = recognizeink('0')
        if p.shape == 'x' or p.shape == '+' then -- perhaps needs more conditions later
                newtile.arrows = {}
                newtile.color = images[p.name].color
                newtile.shape = p.shape
                newtile.gift = p.gift
                newtile.arrowgift = p.arrowgift
                if p.sleep then
                        newtile.sleep = 4
                        newtile.sleeping_name = p.sleeping_name or p.name
                end
                
                for dir, arr in ipairs(p.arrows) do
                        -- arrows are false or integer: distance from tile center
                        newtile.arrows[dir] = arr
                        if arr then
                                local discard, distance, pf = check_direction(playfield.clickedx, playfield.clickedy, directions[dir][1], directions[dir][2])
                                local target
                                if pf and pf.kind == 'yellow' then
                                        pf.hit = true
                                        target = pf
                                end -- mark yellow arrows for rotation
                                explode_arrow(playfield.clickedx, playfield.clickedy, dir, distance, false, target)
                        end
                end
        end
        -- mark all purple arrow tiles if a purple arrow is clicked
        -- even if only a memory --!!
        if p.kind == 'purple' then
                game.temppurple = not game.temppurple
                inplayfield(function (x, y, p) if p.kind == 'purple' or (p.memory and p.memory.kind == 'purple') then
                        playfield[x][y].hit = true
                        local pf = playfield[x][y].memory or playfield[x][y]
                        pf.center = 'dot'
                end end)
        end
        playfield[playfield.clickedx][playfield.clickedy] = newtile
end


function check_player_death()
        inplayfield(function(x, y, p)
                if not p.arrows then return end
                for direction, arrow in ipairs(p.arrows) do
                        if not p.backgrounded and arrow then
                                local death, distance = check_direction(x, y, 
                                        directions[direction][1], directions[direction][2])
                                if death then
                                        explode_arrow(x, y, direction, distance, true) -- kill=true
                                        game.died = true
                                end
                        end
                end
        end)
end


function influence_and_rotate()
        -- devil influence on yellow arrows
        if game.devil then
                local dx, dy
                local yellow_arrows = {}
                inplayfield(function(x, y, p)
                        if p.kind == 'yellow' then
                                if p.devil then -- don't insert last influenced yellow arrow                            
                                        playfield[x][y].devil = nil -- unset but remember in case there are no more arrows
                                        dx, dy = x, y
                                else 
                                        table.insert(yellow_arrows, {x, y})
                                end
                        end
                end)
                if #yellow_arrows > 0 then
                        -- choose among available yellow arrows
                        dx, dy = unpack(yellow_arrows[math.random(#yellow_arrows)])
                        playfield[dx][dy].center = 'dot'
                        if playfield[dx][dy].hit then
                                rotate_arrows(dx, dy, 0) -- will just remove dot
                        else
                                rotate_arrows(dx, dy, -1)
                        end
                        playfield[dx][dy].hit = false -- so won't be rotated later
                end
                if dx then playfield[dx][dy].devil = true end -- new or last dx, dy in case there was only 1
        end
        -- turn yellow and purple arrows
        inplayfield(function(x, y, p)
                if (p.kind == 'yellow' or p.kind == 'purple' or (p.kind == 'memory' and p.memory.kind == 'purple')) and p.hit then
                        rotate_arrows(x, y)
                        p.hit = false
                end
        end)
        -- wake regenerating arrows up
        inplayfield(function(x, y, p)
                if p.sleep and p.sleep > 0 then
                        p.sleep = p.sleep - 1
                        if p.sleep == 0 then
                                playfield[x][y] = recognizeink(p.sleeping_name)
                                grow_arrows(x, y)
                        end
                end
        end)
        -- rotate red arrows
        inplayfield(function(x, y, p)
                if p.kind == 'red' or p.kind == 'loadred' then rotate_arrows(x, y) end
        end)
end


function next_phase()
        local nextphases = {'rotate', 'die', 'level', 'play', 'explode'}
        setmetatable(nextphases, {__index = function (table, key) 
                for a = 1, #table do
                        if rawget(table, a) == key then return table[a + 1] or table[1] end
                end
        end})

        game.phase = nextphases[game.phase] or 'play' -- nextphases['opengifts'] == nil , etc. 
        if game.phase == 'explode' then -- 1. explode clicked arrow
                explode_clicked()
        elseif game.phase == 'rotate' then
                influence_and_rotate()
        elseif game.phase == 'die' then -- 2. check for player death
                check_player_death()
        elseif game.phase == 'level' then -- 3. check for level end
                check_level()
        elseif game.phase == 'play' then -- 4. await next click
        end
end


function remember_arrows()
        playfield.clickedx, playfield.clickedy = nil, nil
        inplayfield(function (x, y, p)
                if p.memory then playfield[x][y] = p.memory end
        end)
end


function love.resize()
        screen.w = love.graphics.getWidth()
        screen.h = love.graphics.getHeight()
        screen.playfieldsize = math.min(screen.w, screen.h) * .9
        screen.tilesize = screen.playfieldsize / 4
        screen.playfieldx = (screen.w / screen.playfieldsize - 1) * 2
        screen.playfieldy = (screen.h / screen.playfieldsize - 1) * 2
        if screen.bgcanvas then
                screen.bgcanvas:renderTo(love.graphics.clear)
                screen.bgcanvas:renderTo(draw_playfield)
        end
        screen.defaultfont = love.graphics.newFont(screen.tilesize / 5)
end


function love.update(dt)
        if game.screen ~= 'playfield' then return end
        if dt < 1/50 then
                love.timer.sleep(1/30 - dt)
        end
        game.timer = game.timer + dt
        update_anim(dt)
end


function osd()
        love.graphics.setColor(1, 1, 1)
        love.graphics.print(game.currentlevel, 1, 2) --debug
        if anim[1] then love.graphics.print(anim[1].step, 1, 12) end
end


function inplayfield(f)
        for y = 1, 4 do for x = 1, 4 do
                f(x, y, playfield[x][y])
        end end
end


function love.draw()
        if game.screen == 'playfield' then
                osd()
                draw_playfield()
        else
                draw_menu()
        end
end


function check_direction(x, y, dx, dy)
        local p, xx, yy
        for a = 1, 4 do
                xx, yy = x + dx * a, y + dy * a
                if not playfield[xx] then return false, a end -- arrow hits playfield edge
                p = playfield[xx][yy]
                if not p then return false, a end --||--
                if xx == playfield.clickedx and yy == playfield.clickedy then return true, a end -- arrow hits player
                if not p.passive then return false, a, p end -- arrow hits another object. return that object
        end
        return false, 3
end


function check_level()
        -- checks for the level end (when all arrows are eliminated)
        -- game should generally check for arrows not shapes!
        local anymemories, anyactivearrows = false, false
        inplayfield(function(x, y, p)
                anymemories = anymemories or p.memory
                if p.arrows then for direction, arrow in ipairs(p.arrows) do
                        anyactivearrows = anyactivearrows or arrow
                end end
        end)
        if not anyactivearrows and not open_gifts() then
                if anymemories then
                        remember_arrows()
                else
                        game.purple = game.temppurple
                        setuplevel(game.currentlevel + 1)
                end
        end
end


function open_gifts()
        local opened = false
        inplayfield(function(x, y, p)
                if p.name == 'J' or p.name == 'K' then
                        if p.name == 'K' then game.devil = true end
                        playfield[x][y] = recognizeink(p.gift)
                        playfield[x][y].gift = p.gift
                        playfield[x][y].ingift = true
                        opened = true
                end
        end)
        if opened then
                animate_gifts()
                --playfield.clickedx, playfield.clickedy = nil, nil
                --necessary to preserve clicked for opening arrowgifts
        end
        return opened
end


function clicked(mx, my)
        if game.screen ~= 'playfield' then
                return
        end
        if game.phase ~= 'play' then
                return
        end
        
        -- click after death
        if game.died then
                setuplevel()
                return
        end
        -- clickedx, clickedy from previous turn
        if playfield.clickedx and
        playfield[playfield.clickedx][playfield.clickedy].arrowgift and
        not (mx == playfield.clickedx and my == playfield.clickedy) then
                local gift = playfield[playfield.clickedx][playfield.clickedy].gift
                -- open arrowgift
                animate_arrow_gift(playfield.clickedx, playfield.clickedy)
                -- preserve gift
                playfield[playfield.clickedx][playfield.clickedy].gift = gift
        end
        -- new clickedx, clickedy
        playfield.clickedx, playfield.clickedy = mx, my
        if playfield[mx][my].onclick then playfield[mx][my].onclick() end

        next_phase()
end


function isin(mx, my, x, y, w, h)
        return mx >= x and mx <= x + w and my >= y and my <= y + h
end
        

function love.mousepressed(mx, my, button)
        if game.screen == 'playfield' then
                inplayfield(function (x, y, p)
                        if isin(mx, my, (screen.playfieldx + x - 1) * screen.tilesize, (screen.playfieldy + y - 1) * screen.tilesize, screen.tilesize, screen.tilesize) then
                                clicked(x, y)
                        end
                end)
        else --menu
                menu_click(mx, my)
        end
end


function love.keypressed(k)
        if k == 'escape' then
                if game.screen ~= 'playfield' then
                        game:change_screen('playfield')
                else
                        love.event.push('quit')
                end
        elseif k == 'q' then
                love.event.push('quit')
        elseif k == 'n' then
                setuplevel(game.currentlevel + 1)
        elseif k == 'p' then
                setuplevel(game.currentlevel - 1)
        elseif k == 'r' then
                game.temppurple = not game.temppurple
                print('purple', game.temppurple)
        elseif k == 'u' then
                game.underpill = not game.underpill
                print('underpill', game.underpill)
        elseif k == 'd' then
                game.devil = not game.devil
                print('devil', game.devil)
        elseif k == 'm' then
                if game.screen ~= 'playfield' then
                        game:change_screen('playfield')
                else
                        game:change_screen('menu_levels')
                end
        end
end