Dodj

--[[

    Dodj
    By Dave-ee Jones

    Dodgeball in CC!

--]]

local t_TERM = {} -- Terminal dimensions and positioning
t_TERM.W, t_TERM.H = term.getSize()

local n_VERSION = "BETA"

--[[ CONFIGURATION ]]--

-- Ball update interval
local n_BALL_UPDATE_INTERVAL = 1 / 30 -- seconds / frames (smaller ratio = faster balls)
-- Player update interval
local n_PLAYER_UPDATE_INTERVAL = 1 / 4 -- seconds / frames (smaller ratio = faster movement)

-- Player settings (keybindings, sprites, etc.)
--- This is where you can add more players. Follow the same pattern as 1.
local t_PLAYER_SETTINGS = {
    [1] = {
        LEFT = keys.a, -- Left key (press to move left)
        UP = keys.w, -- Up key (press to move up)
        RIGHT = keys.d, -- Right key (press to move right)
        DOWN = keys.s, -- Down key (press to move down)
        ACTION = keys.leftShift, -- Action key (press to pickup/throw/drop)
        STOP = keys.z, -- Stop key (press while pressing a move key to not move)
        SPRITE = "\1", -- Sprite (1 character)
        TEAM = colors.cyan, -- Team, colour based. Defaults are blue and red.
        X = 3, -- X position at the start of the game and when players are reset
        Y = 3 -- Y position at the start of the game and when players are reset
    },
    [2] = {
        LEFT = keys.left,
        UP = keys.up,
        RIGHT = keys.right,
        DOWN = keys.down,
        ACTION = keys.o,
        STOP = keys.p,
        SPRITE = "\2",
        TEAM = colors.red,
        X = t_TERM.W - 3,
        Y = t_TERM.H - 3
    }
}

-- Default sprites for directions
local t_SPRITES = {
    LEFT = "\17",
    UP = "\30",
    RIGHT = "\16",
    DOWN = "\31",
    BALL = "\7"
}

local c_MAIN_BG = colors.black -- Background colour
local c_MAIN_FG = colors.white -- Foreground colour
local c_BOARD_BG = colors.gray -- Board's background colour

--[[ END CONFIGURATION ]]--

-- Metatables
local t_PLAYER = {}
local t_BALL = {}
t_PLAYER.__index = t_PLAYER
t_BALL.__index = t_BALL

-- Tables
local t_PLAYERS = {} -- Not to be confused with the metatable
local t_BALLS = {} -- Also not to be confused with the metatable
local t_BOARD = { -- t_BOARD dimensions and positioning, along with scoreboard
    X = 1,
    Y = 1,
    W = t_TERM.W - 1,
    H = t_TERM.H - 1,
    XMID = t_TERM.W / 2 + 1,
    TEAMS = {}
}

-- Help
local function f_HELP()
    printError("----------")
    printError("Dodj "..n_VERSION)
    printError("----------")
    printError("Setting up a player:")
    printError("- Edit Dodj")
    printError("- Scroll down to the 't_PLAYER_SETTINGS' table")
    printError("- Make an entry for each player missing")
    error("",0)
end

-- Draw all the players
local function f_PLAYERS_DRAW()
    for i=1,#t_PLAYERS do
        t_PLAYERS[i]:draw()
    end
end

-- Draw all the balls
local function f_BALLS_DRAW()
    for i=1,#t_BALLS do
        t_BALLS[i]:draw()
    end
end

-- Create the teams
local function f_TEAMS_CREATE()
    -- Create a team based on the players' colours
    local n_TEAMS = 0
    for i=1,#t_PLAYERS do
        if not t_BOARD.TEAMS[t_PLAYERS[i].TEAM] then
            -- Team doesn't exist, so let's create it
            t_BOARD.TEAMS[t_PLAYERS[i].TEAM] = {
                SCORE = 0,
                X = 0
            }
            n_TEAMS = n_TEAMS + 1
        end
    end
    local n_INDEX = 1
    if n_TEAMS == 2 then
        -- If there's only 2 teams, draw the text on either side of the board
        for k,v in pairs(t_BOARD.TEAMS) do
            if n_INDEX == 1 then
                t_BOARD.TEAMS[k].X = 2
            else
                t_BOARD.TEAMS[k].X = t_TERM.W - 2
            end
            n_INDEX = n_INDEX + 1
        end
    else
        -- Calculate distance between written text to calculate where we end up drawing them
        local n_XSTART = 2
        local n_DISTANCE_BETWEEN_TEAMS = (t_TERM.W - (n_XSTART*2))/(n_TEAMS-1)
        for k,v in pairs(t_BOARD.TEAMS) do
            t_BOARD.TEAMS[k].X = n_XSTART+n_DISTANCE_BETWEEN_TEAMS*(n_INDEX-1)
            n_INDEX = n_INDEX + 1
        end
    end
end

-- Add one to a team's score
local function f_TEAMS_SCORE(c_TEAM)
    t_BOARD.TEAMS[c_TEAM].SCORE = t_BOARD.TEAMS[c_TEAM].SCORE + 1
end

-- Draw the teams' score
local function f_TEAMS_DRAW()
    term.setBackgroundColor(c_BOARD_BG)
    for k,v in pairs(t_BOARD.TEAMS) do
        term.setTextColor(k)
        term.setCursorPos(t_BOARD.TEAMS[k].X,1)
        write(t_BOARD.TEAMS[k].SCORE)
    end
end

-- Draw the board
local function f_BOARD_DRAW()
    paintutils.drawBox(t_BOARD.X,t_BOARD.Y,t_BOARD.X+t_BOARD.W,t_BOARD.Y+t_BOARD.H,c_BOARD_BG)
    f_TEAMS_DRAW()
end

-- Reset the board
local function f_BOARD_RESET()
    f_BOARD_DRAW()
    -- Reset the players
    for i=1,#t_PLAYERS do
        t_PLAYERS[i]:clear()
        t_PLAYERS[i]:reset()
    end
    -- Reset the balls
    for i=1,#t_BALLS do
        t_BALLS[i]:clear()
        t_BALLS[i]:reset()
    end
    f_BALLS_DRAW()
    f_PLAYERS_DRAW()
    tm_BALL_UPDATE = os.startTimer(1)
end

-- Create a new player
function t_PLAYER:new(n_NUMBER)
    if not t_PLAYER_SETTINGS[n_NUMBER] then
        -- No settings for the player found
        printError("[ERROR] No settings for player "..n_NUMBER)
        printError("Type '"..shell.getRunningProgram().." help' for help.")
        error("",0)
    end
    local self = {
        NUMBER = n_NUMBER,
        DIRECTION = t_SPRITES.DOWN,
        ITEM = nil,
        ACTION_CD = false,
        CATCHING = false,
        STOPPED = false,
        KEY_STATES = {
            LEFT = false,
            UP = false,
            RIGHT = false,
            DOWN = false,
            ACTION = false,
            STOP = false
        }
    }
    -- This is where the t_PLAYER_SETTINGS table comes in handy!
    self.LEFT = t_PLAYER_SETTINGS[n_NUMBER].LEFT
    self.UP = t_PLAYER_SETTINGS[n_NUMBER].UP
    self.RIGHT = t_PLAYER_SETTINGS[n_NUMBER].RIGHT
    self.DOWN = t_PLAYER_SETTINGS[n_NUMBER].DOWN
    self.ACTION = t_PLAYER_SETTINGS[n_NUMBER].ACTION
    self.STOP = t_PLAYER_SETTINGS[n_NUMBER].STOP
    self.X = t_PLAYER_SETTINGS[n_NUMBER].X
    self.Y = t_PLAYER_SETTINGS[n_NUMBER].Y
    self.TEAM = t_PLAYER_SETTINGS[n_NUMBER].TEAM
    self.SPRITE = t_PLAYER_SETTINGS[n_NUMBER].SPRITE
    self.XSTART = self.X
    self.YSTART = self.Y
    setmetatable(self,t_PLAYER)
    return self
end

-- Move a player left
function t_PLAYER:moveLeft()
    self.DIRECTION = t_SPRITES.LEFT
    if not self.KEY_STATES.STOP and self.X > (t_BOARD.X + 1) then
        self:clear()
        self.X = self.X - 1
        if self.ITEM then
            self.ITEM:clear()
            self.ITEM.X = self.X
            self.ITEM.Y = self.Y + 1
        end
        f_BALLS_DRAW()
        f_PLAYERS_DRAW()
    end
    self:draw()
end

-- Move a player up
function t_PLAYER:moveUp()
    self.DIRECTION = t_SPRITES.UP
    if not self.KEY_STATES.STOP and self.Y > (t_BOARD.Y + 1) then
        self:clear()
        self.Y = self.Y - 1
        if self.ITEM then
            self.ITEM:clear()
            self.ITEM.X = self.X
            self.ITEM.Y = self.Y + 1
        end
        f_BALLS_DRAW()
        f_PLAYERS_DRAW()
    end
    self:draw()
end

-- Move a player right
function t_PLAYER:moveRight()
    self.DIRECTION = t_SPRITES.RIGHT
    if not self.KEY_STATES.STOP and self.X < (t_BOARD.X + t_BOARD.W - 1) then
        self:clear()
        self.X = self.X + 1
        if self.ITEM then
            self.ITEM:clear()
            self.ITEM.X = self.X
            self.ITEM.Y = self.Y + 1
        end
        f_BALLS_DRAW()
        f_PLAYERS_DRAW()
    end
    self:draw()
end

-- Move a player down
function t_PLAYER:moveDown()
    self.DIRECTION = t_SPRITES.DOWN
    if not self.KEY_STATES.STOP and self.Y < (t_BOARD.Y + t_BOARD.H - 2) then
        self:clear()
        self.Y = self.Y + 1
        if self.ITEM then
            self.ITEM:clear()
            self.ITEM.X = self.X
            self.ITEM.Y = self.Y + 1
        end
        f_BALLS_DRAW()
        f_PLAYERS_DRAW()
    end
    self:draw()
end

-- Reset a player
function t_PLAYER:reset()
    self.X = self.XSTART
    self.Y = self.YSTART
    self.STOPPED = false
    self.ACTION_CD = false
    self.ITEM = nil
    self.DIRECTION = t_SPRITES.DOWN
    self.CATCHING = false
end

-- Clear a player's drawn sprite
function t_PLAYER:clear()
    paintutils.drawPixel(self.X,self.Y,c_MAIN_BG)
    paintutils.drawPixel(self.X,self.Y+1,c_MAIN_BG)
end

-- Pickup/Throw/Drop something that a player holds
function t_PLAYER:action()
    if self.ITEM then
        -- Player is holding an item and wants to be rid of it
        if self.ITEM.SPRITE == t_SPRITES.BALL then
            -- It's a ball! THROW IT!
            self.ITEM.DIRECTION = self.DIRECTION
            self.ITEM.IS_THROWN = true
            self.ITEM.IS_CAUGHT = false
            self.ITEM = nil
        elseif self.ITEM.SPRITE == t_SPRITES.BLOCK then
            -- It's a block! (of some kind..) DROP IT!
            self.ITEM.IS_HELD = false
        end
    else
        self.CATCHING = true
    end
end

-- Draw a player
function t_PLAYER:draw()
    -- Draw player's sprite
    term.setTextColor(c_MAIN_FG)
    term.setBackgroundColor(self.TEAM)
    term.setCursorPos(self.X,self.Y)
    write(self.SPRITE)
    -- Draw player's direction/item
    term.setTextColor(c_MAIN_FG)
    term.setBackgroundColor(self.TEAM)
    term.setCursorPos(self.X,self.Y+1)
    if not self.ITEM then
        write(self.DIRECTION)
    else
        write(self.ITEM.SPRITE)
    end
end

-- Create a new ball
function t_BALL:new(n_NUMBER)
    local self = {
        NUMBER = n_NUMBER,
        DIRECTION = t_SPRITES.DOWN,
        IS_THROWN = false,
        IS_CAUGHT = false,
        TEAM = c_MAIN_FG,
        SPRITE = t_SPRITES.BALL
    }
    local _n_X = 0
    local _n_Y = 0
    local b_LOOKING = true
    while b_LOOKING do
        -- Looking for a spot to put the ball..
        _n_X = math.random(2,t_TERM.W-1)
        _n_Y = math.random(2,t_TERM.H-1)
        local _collision = false
        for i=1,#t_PLAYERS do
            if t_PLAYERS[i].XSTART == _n_X and t_PLAYERS[i].YSTART == _n_Y then
                -- Ah, can't use this position because it's the same as this player's starting position
                _collision = true
            end
        end
        for i=1,#t_BALLS do
            if t_BALLS[i].XSTART == _n_X and t_BALLS[i].YSTART == _n_Y then
                -- Ah, already a ball there
                _collision = true
            end
        end
        if not _collision then
            -- Okay, we found our spot
            b_LOOKING = false
        end
    end
    self.X = _n_X
    self.Y = _n_Y
    self.XSTART = _n_X
    self.YSTART = _n_Y
    setmetatable(self,t_BALL)
    return self
end

-- Calculate if the ball is touching a player
function t_BALL:collidedWithPlayer()
    for i=1,#t_PLAYERS do
        -- Okay, Player i, are you touching the ball?
        if self.X == t_PLAYERS[i].X and self.Y >= t_PLAYERS[i].Y and self.Y <= (t_PLAYERS[i].Y + 1) then
            -- Oh boi, you are!
            return t_PLAYERS[i]
        end
    end
    -- No one touching the ball!
    return false
end

-- Move a ball
function t_BALL:move()
    if self.IS_THROWN then
        -- Ahh, the ball is supposed to be moving
        if self.DIRECTION == t_SPRITES.LEFT then
            -- Moving left, eh?
            self:clear()
            if self.X > (t_BOARD.X + 1) then
                -- Okay, no wall, so let's keep going!
                self.X = self.X - 1
            else
                -- Oops, hit a wall, so let's rebound!
                self.DIRECTION = t_SPRITES.RIGHT
            end
        elseif self.DIRECTION == t_SPRITES.UP then
            -- Moving up in the world
            self:clear()
            if self.Y > (t_BOARD.Y + 1) then
                -- Okay, no ceiling, so let's keep moving up
                self.Y = self.Y - 1
            else
                -- Okay, hit the ceiling, let's fall
                self.DIRECTION = t_SPRITES.DOWN
            end
        elseif self.DIRECTION == t_SPRITES.RIGHT then
            -- Moving along the right path
            self:clear()
            if self.X < (t_BOARD.X + t_BOARD.W - 1) then
                -- Okay, it really is the right path
                self.X = self.X + 1
            else
                -- It's all gone left (including this ball)
                self.DIRECTION = t_SPRITES.LEFT
            end
        elseif self.DIRECTION == t_SPRITES.DOWN then
            -- Falling
            self:clear()
            if self.Y < (t_BOARD.Y + t_BOARD.H - 1) then
                -- We haven't hit the ground
                self.Y = self.Y + 1
            else
                -- Balls are bouncy, so they rebound off the ground
                self.DIRECTION = t_SPRITES.UP
            end
        end
        f_BALLS_DRAW()
        f_PLAYERS_DRAW()
    end
    if not self.IS_CAUGHT then
        local _other = self:collidedWithPlayer()
        if _other then
            -- Ball is sitting on a player
            if self.TEAM == c_MAIN_FG and _other.CATCHING then
                -- Player is eligible to catch the ball, so they do
                _other.ITEM = self
                self.TEAM = _other.TEAM
                self.IS_CAUGHT = true
                self.IS_THROWN = false
                _other:draw()
            elseif _other.CATCHING then
                -- Ball isn't white, but the player wants to catch the ball
                if (self.DIRECTION == t_SPRITES.DOWN and _other.DIRECTION == t_SPRITES.UP) or (self.DIRECTION == t_SPRITES.UP and _other.DIRECTION == t_SPRITES.DOWN) then
                    -- Player is eligible to catch the ball, so they do
                    _other.ITEM = self
                    self.TEAM = _other.TEAM
                    self.IS_CAUGHT = true
                    self.IS_THROWN = false
                    _other:draw()
                elseif (self.DIRECTION == t_SPRITES.LEFT and _other.DIRECTION == t_SPRITES.RIGHT) or (self.DIRECTION == t_SPRITES.RIGHT and _other.DIRECTION == t_SPRITES.LEFT) then
                    -- Player is eligible to catch the ball, so they do
                    _other.ITEM = self
                    self.TEAM = _other.TEAM
                    self.IS_CAUGHT = true
                    self.IS_THROWN = false
                    _other:draw()
                else
                    -- Player isn't in any position to catch the ball, even though he tried..
                    if self.TEAM ~= _other.TEAM and self.TEAM ~= c_MAIN_FG then
                        -- Player just got hit!
                        f_TEAMS_SCORE(self.TEAM)
                        f_BOARD_RESET()
                    end
                end
            else
                -- Player isn't trying to catch it and the ball isn't white
                if self.TEAM ~= _other.TEAM and self.TEAM ~= c_MAIN_FG then
                    -- AND the ball isn't on the same team as the player, NOT GOOD!
                    f_TEAMS_SCORE(self.TEAM)
                    f_BOARD_RESET()
                end
            end
        end
    end
end

-- Reset a ball
function t_BALL:reset()
    self.X = self.XSTART
    self.Y = self.YSTART
    self.IS_THROWN = false
    self.IS_CAUGHT = false
    self.DIRECTION = t_SPRITES.DOWN
    self.TEAM = c_MAIN_FG
end

-- Clear a ball's drawn sprite
function t_BALL:clear()
    paintutils.drawPixel(self.X,self.Y,c_MAIN_BG)
end

-- Draw a ball
function t_BALL:draw()
    term.setTextColor(self.TEAM)
    term.setBackgroundColor(c_MAIN_BG)
    term.setCursorPos(self.X,self.Y)
    write(t_SPRITES.BALL)
end

-- Creating players based on arguments
local tArgs = { ... }
if tArgs[1] then
    if not tonumber(tArgs[1]) then
        -- Argument isn't a number, therefore we check for keywords
        if tArgs[1] == "help" then
            -- Argument was "help"
            f_HELP()
        else
            -- Unknown argument, error out
            error("[ERROR] Invalid argument: "..tArgs[1],0)
        end
    end
    -- Arguments found, let's create some players
    for i=1,tArgs[1] do
        t_PLAYERS[i] = t_PLAYER:new(i)
    end
    -- Lets create twice the amount of balls (max 10)
    for i=1,(tArgs[1]*2) do
        if #t_BALLS ~= 10 then
            t_BALLS[i] = t_BALL:new(i)
        else
            break
        end
    end
else
    -- No arguments found, default to 2 players
    for i=1,2 do
        t_PLAYERS[i] = t_PLAYER:new(i)
    end
    -- 2 players = 4 balls
    for i=1,4 do
        t_BALLS[i] = t_BALL:new(i)
    end
end

-- Setup the teams
f_TEAMS_CREATE()

-- Back to the drawing board..
local b_RUNNING = true
term.setBackgroundColor(c_MAIN_BG)
term.clear()
f_BOARD_DRAW()

-- Draw all the things before we start looping
f_BALLS_DRAW()
f_PLAYERS_DRAW()

-- Starts the timers
local tm_BALL_UPDATE = os.startTimer(1)
local tm_PLAYER_UPDATE = os.startTimer(1)

-- The Frightening Loop
while b_RUNNING do
    local e_EVENT, e_BUTTON, e_X, e_Y = os.pullEvent()
    if e_EVENT == "key" then
        -- WHICH PLAYER PRESSED A BUTTON, HUH?!
        for i=1,#t_PLAYERS do
            -- WAS IT YOU, i?!
            if e_BUTTON == t_PLAYERS[i].LEFT then
                -- AHA, NOW YOU CAN MOVE LEFT FOR WHAT YOU DID!
                t_PLAYERS[i]:moveLeft()
                t_PLAYERS[i].KEY_STATES.LEFT = true
            elseif e_BUTTON == t_PLAYERS[i].UP then
                -- AHA, NOW YOU CAN MOVE UP FOR WHAT YOU DID!
                t_PLAYERS[i]:moveUp()
                t_PLAYERS[i].KEY_STATES.UP = true
            elseif e_BUTTON == t_PLAYERS[i].RIGHT then
                -- AHA, NOW YOU CAN MOVE RIGHT FOR WHAT YOU DID!
                t_PLAYERS[i]:moveRight()
                t_PLAYERS[i].KEY_STATES.RIGHT = true
            elseif e_BUTTON == t_PLAYERS[i].DOWN then
                -- AHA, NOW YOU CAN MOVE DOWN FOR WHAT YOU DID!
                t_PLAYERS[i]:moveDown()
                t_PLAYERS[i].KEY_STATES.DOWN = true
            elseif e_BUTTON == t_PLAYERS[i].STOP then
                -- AHH, YOU WANT TO STOP DO YOU? FINE.
                t_PLAYERS[i].KEY_STATES.STOP = true
            elseif e_BUTTON == t_PLAYERS[i].ACTION then
                -- WHAT? YOU WANT TO DO SOMETHING? GO AHEAD.
                t_PLAYERS[i]:action()
                t_PLAYERS[i].KEY_STATES.ACTION = true
            end
        end
    elseif e_EVENT == "key_up" then
        -- WHICH PLAYER PRESSED A BUTTON, HUH?!
        for i=1,#t_PLAYERS do
            -- WAS IT YOU, i?!
            if e_BUTTON == t_PLAYERS[i].LEFT then
                -- AHA, NOW YOU CAN STAY RIGHT THERE!
                t_PLAYERS[i].KEY_STATES.LEFT = false
            elseif e_BUTTON == t_PLAYERS[i].UP then
                -- STOP UPPING THEN!
                t_PLAYERS[i].KEY_STATES.UP = false
            elseif e_BUTTON == t_PLAYERS[i].RIGHT then
                -- AHA, THE RIGHT CHOICE!
                t_PLAYERS[i].KEY_STATES.RIGHT = false
            elseif e_BUTTON == t_PLAYERS[i].DOWN then
                -- AHA, NOW YOU CAN STAY RIGHT THERE!
                t_PLAYERS[i].KEY_STATES.DOWN = false
            elseif e_BUTTON == t_PLAYERS[i].STOP then
                -- AHH, YOU DON'T WANT TO STOP DO YOU? FINE.
                t_PLAYERS[i].KEY_STATES.STOP = false
            elseif e_BUTTON == t_PLAYERS[i].ACTION then
                -- WHAT? YOU DON'T WANT TO DO SOMETHING?
                t_PLAYERS[i].CATCHING = false
                t_PLAYERS[i].KEY_STATES.ACTION = false
            end
        end
    elseif e_EVENT == "timer" then
        if e_BUTTON == tm_BALL_UPDATE then
            -- BALLS ARE BEING MOVED, GET READY..
            for i=1,#t_BALLS do
                -- WANNA MOVE, i? THIS IS YOUR CHANCE.
                t_BALLS[i]:move()
            end
            tm_BALL_UPDATE = os.startTimer(n_BALL_UPDATE_INTERVAL)
        elseif e_BUTTON == tm_PLAYER_UPDATE then
            -- PLAYERS ARE BEING MOVED, GET READY..
            for i=1,#t_PLAYERS do
                if t_PLAYERS[i].KEY_STATES.LEFT then
                    -- WHEN YOU GONNA STOP HEADING LEFT?
                    t_PLAYERS[i]:moveLeft()
                elseif t_PLAYERS[i].KEY_STATES.UP then
                    -- MOVIN' ON UP!
                    t_PLAYERS[i]:moveUp()
                elseif t_PLAYERS[i].KEY_STATES.RIGHT then
                    -- RIGHT, RIGHT!
                    t_PLAYERS[i]:moveRight()
                elseif t_PLAYERS[i].KEY_STATES.DOWN then
                    -- DOWN WE GO!
                    t_PLAYERS[i]:moveDown()
                end
                tm_PLAYER_UPDATE = os.startTimer(n_PLAYER_UPDATE_INTERVAL)
            end
        end
    end
end