--[[

RACER

map-independant racing script

originally by mikade, edited heavily by others

-----------------------------------------

Script parameters:

rounds=N

--> The game will be played with N rounds (default: 3)

waypointradius=N

--> The waypoints have a radius of N pixels (default: 450)

maxwaypoints=N

--> The maximum number of waypoints to be placed (default: 8)

teamrope=true

--> The team will be colored in the color of the team.

-----------------------------------------

DEVELOPER WARNING - FOR OFFICIAL DEVELOPMENT --

Be careful when editig this script, do not introduce changes lightly!

This script is used for time records on the official Hedgewars server.

Introducing breaking changes means we have to invalidate past time records!

]]

-----------------------------

-- SCRIPT BEGINS

-----------------------------

HedgewarsScriptLoad("/Scripts/Locale.lua")

HedgewarsScriptLoad("/Scripts/OfficialChallenges.lua")

HedgewarsScriptLoad("/Scripts/Params.lua")

------------------

-- Got Variables?

------------------

local roundLimit = 3

local roundNumber = 0

local firstClan = 10

local fastX = {}

local fastY = {}

local fastCount = 0

local fastIndex = 0

local fastColour = 0xffffffff

local currX = {}

local currY = {}

local currCount = 0

local specialPointsX = {}

local specialPointsY = {}

local specialPointsCount = 0

local landObjectPoints = {}

local landObjects = {}

local TeamRope = false

local waypointCursor = false

local waypointPreview = nil

local officialChallenge

local ammoDelays

--------------------------

-- hog and team tracking variales

--------------------------

local numhhs = 0 -- store number of hedgehogs

local hhs = {} -- store hedgehog gears

local numTeams --  store the number of teams in the game

local teamNameArr = {}  -- store the list of teams

local teamClan = {}

local teamSize = {}     -- store how many hogs per team

local teamIndex = {} -- at what point in the hhs{} does each team begin

local teamComment = {}

local teamScore = {}

-------

-- racer vars

--------

local cGear = nil

local cameraGear = nil -- gear created to center the cameera on

local bestClan = 10

local bestTime = MAX_TURN_TIME

local gameBegun = false

local gameOver = false

local racerActive = false

local trackTime = 0

local wpCirc = {}

local wpX = {}

local wpY = {}

local wpCol = {}

local wpActive = {}

local wpRad = 450

local WAYPOINT_RADIUS_MIN = 40

local wpCount = 0

local wpLimit = 8

local usedWeapons = {}

local roundN

local lastRound

local RoundHasChanged

local turnSkipped = false

local boostX = 0

local boostY = 0

local boostValue = 1

-- themes with bright background

local brightThemes = {

	Bath = true,

	Bamboo = true,

	Beach = true,

	Blox = true,

	Compost = true,

	Desert = true,

	Fruit = true,

	Golf = true,

	Hoggywood = true,

	Jungle = true,

	Olympics = true,

	Sheep = true,

}

-- themes with medium or heavily mixed brightness.

-- only add themes here if both bright and dark waypoint

-- colors fail otherwise.

local mediumThemes = {

	Halloween = true,

}

-- All themes not explicitly listed above are assumed to

-- be "dark" and work with the default bright waypoints.

-- Waypoint colors in 3 color themes!

-- We do this so the waypoints are easy on the eyes,

-- at least in each of the default themes.

-- Bright waypoints (default)

local waypointColourBright = 0xFFFFFFFF -- Primary colour of inactive waypoints

local waypointColourBrightAtPlacement = 0xAAAAAAFF -- Colour of non-highlighted waypoints while placing

-- Medium bright waypoints

local waypointColourMedium = 0x606060FF

local waypointColourMediumAtPlacement = 0x404040FF

-- Dark waypoints

local waypointColourDark = 0x000000FF

local waypointColourDarkAtPlacement = 0x303030FF

-- Waypoints touched by the players assume the clan color, which is unchanged.

-- Touched waypoints are not important to be visible.

-- Default waypoint colors (only use these color variables in the code below)

local waypointColour = waypointColourBright

local waypointColourAtPlacement = waypointColourBrightAtPlacement

-------------------

-- general methods

-------------------

-- Returns brightness level of background from 1-3.

-- 1 = brightest

function GetBackgroundBrightness()

	-- This just looks at the theme names above.

	-- This code will fail for bright unofficial themes.

	-- TODO: Change how this thing works.

	-- Consider adding a function into the Lua API which looks

	-- up the theme's sky color, so we could use thit instead.

	if brightThemes[Theme] then

		return 1

	elseif mediumThemes[Theme] then

		return 2

	else

		return 3

	end

end

function onParameters()

    parseParams()

    if params["teamrope"] ~= nil then

        TeamRope = true

    end

    if params["rounds"] ~= nil then

        roundLimit = tonumber(params["rounds"])

        if type(roundLimit) ~= "number" then

             roundLimit = 3

        end

        roundLimit = math.max(1, math.floor(roundLimit))

    end

    if params["waypointradius"] ~= nil then

        wpRad = tonumber(params["waypointradius"])

        if type(wpRad) ~= "number" then

             wpRad = 450

        end

        wpRad = math.max(WAYPOINT_RADIUS_MIN, math.floor(wpRad))

    end

    if params["maxwaypoints"] ~= nil then

        wpLimit = tonumber(params["maxwaypoints"])

        if type(wpLimit) ~= "number" then

             wpLimit = 8

        end

        wpLimit = math.max(2, math.floor(wpLimit))

    end

end

function RebuildTeamInfo()

        -- make a list of individual team names

        for i = 0, (TeamsCount-1) do

                teamNameArr[i] = " "

                teamSize[i] = 0

                teamIndex[i] = 0

                teamScore[i] = MAX_TURN_TIME

        end

        numTeams = 0

        for i = 0, (numhhs-1) do

                z = 0

                unfinished = true

                while(unfinished == true) do

                        newTeam = true

                        tempHogTeamName = GetHogTeamName(hhs[i]) -- this is the new name

                        if tempHogTeamName == teamNameArr[z] then

                                newTeam = false

                                unfinished = false

                        end

                        z = z + 1

                        if z == TeamsCount then

                                unfinished = false

                                if newTeam == true then

                                        teamNameArr[numTeams] = tempHogTeamName

                                        numTeams = numTeams + 1

                                end

                        end

                end

        end

        -- find out how many hogs per team, and the index of the first hog in hhs

        for i = 0, (numTeams-1) do

                for z = 0, (numhhs-1) do

                        if GetHogTeamName(hhs[z]) == teamNameArr[i] then

                                teamClan[i] = GetHogClan(hhs[z])

                                if teamSize[i] == 0 then

                                        teamIndex[i] = z -- should give starting index

                                end

                                teamSize[i] = teamSize[i] + 1

                                --add a pointer so this hog appears at i in hhs

                        end

                end

        end

end

-----------------

-- RACER METHODS

-----------------

function onLeft()

	boostX = boostX +boostValue

end

function onLeftUp()

	boostX = boostX -boostValue

end

function onRight()

	boostX = boostX -boostValue

end

function onRightUp()

	boostX = boostX +boostValue

end

function onUp()

	boostY = boostY +boostValue

end

function onUpUp()

	boostY = boostY -boostValue

end

function onDown()

	boostY = boostY -boostValue

end

function onDownUp()

	boostY = boostY +boostValue

end

function CheckWaypoints()

        trackFinished = true

        for i = 0, (wpCount-1) do

                g1X, g1Y = GetGearPosition(CurrentHedgehog)

                g2X, g2Y = wpX[i], wpY[i]

                g1X = g1X - g2X

                g1Y = g1Y - g2Y

                dist = (g1X*g1X) + (g1Y*g1Y)

                NR = (48/100*wpRad)/2

                if dist < (NR*NR) then

                        wpCol[i] = GetClanColor(GetHogClan(CurrentHedgehog))

                        SetVisualGearValues(wpCirc[i], wpX[i], wpY[i], 64, 64, 1, 10, 0, wpRad, 5, wpCol[i])

                        wpRem = 0

                        for k = 0, (wpCount-1) do

                                if wpActive[k] == false then

                                        wpRem = wpRem + 1

                                end

                        end

                        if wpActive[i] == false then

                                local wpMessage = ""

                                if wpRem-1 == 0 then

                                         wpMessage = loc("Track completed!")

                                else

                                         wpMessage = string.format(loc("Waypoints remaining: %d"), wpRem-1)

                                end

                                AddCaption(wpMessage, 0xffba00ff, capgrpGameState)

                        end

                        wpActive[i] = true

                end

                if wpActive[i] == false then

                        trackFinished = false

                end

        end

        return(trackFinished)

end

function AdjustScores()

	bestTimeComment = loc("Did not finish")

        newScore = false

        -- update this clan's time if the new track is better

        for i = 0, (numTeams-1) do

                if teamClan[i] == GetHogClan(CurrentHedgehog) then

                        if trackTime < teamScore[i] then

                                teamScore[i] = trackTime

                                newScore = true

                        else

                                newScore = false

                        end

                end

        end

        -- find the best time out of those so far

        for i = 0, (numTeams-1) do

                if teamScore[i] < bestTime then

                        bestTime = teamScore[i]

                        bestClan = teamClan[i]

                end

        end

        if bestTime ~= MAX_TURN_TIME then

                bestTimeComment = string.format(loc("%.1fs"), (bestTime/1000))

        end

        if newScore == true then

                if trackTime == bestTime then -- best time of the race

                        ShowMission(loc("Racer"),

                        loc("Track completed!"),

                        string.format(loc("New race record: %.1fs"), (trackTime/1000)) .. "|" ..

                        string.format(loc("Winning time: %s"), bestTimeComment), 0, 4000)

                        PlaySound(sndHomerun)

                else    -- best time for the clan

                        ShowMission(loc("Racer"),

                        loc("Track completed!"),

                        string.format(loc("New clan record: %.1fs"), (trackTime/1000)) .. "|" ..

                        string.format(loc("Winning time: %s"), bestTimeComment), 4, 4000)

                end

        else -- not any kind of new score

                ShowMission(loc("Racer"),

                loc("Track completed!"),

                string.format(loc("Time: %.1fs"), (trackTime/1000)) .. "|" ..

                string.format(loc("Winning time: %s"), bestTimeComment), -amSkip, 4000)

                PlaySound(sndHellish)

        end

        for i = 0, (TeamsCount-1) do

                if teamNameArr[i] ~= " " and teamScore[i] ~= MAX_TURN_TIME then

                        SetTeamLabel(teamNameArr[i], string.format(loc("%.1fs"), teamScore[i]/1000))

                end

        end

        if bestTime == trackTime then

                fastColour = GetClanColor(GetHogClan(CurrentHedgehog))

                for i = 0, (currCount-1) do

                        fastX[i] = currX[i]

                        fastY[i] = currY[i]

                end

                fastCount = currCount

                fastIndex = 0

        else

                currCount = 0

                fastIndex = 0

        end

end

function onNewRound()

        roundNumber = roundNumber + 1

        totalComment = ""

        for i = 0, (TeamsCount-1) do

                        if teamNameArr[i] ~= " " and teamScore[i] ~= MAX_TURN_TIME then

                                teamComment[i] = string.format(loc("%s: %.1fs"), teamNameArr[i], (teamScore[i]/1000)) .. "|"

                        else

                                teamComment[i] = string.format(loc("%s: Did not finish"), teamNameArr[i]) .. "|"

                        end

                        totalComment = totalComment .. teamComment[i]

        end

        local icon

        if roundNumber >= roundLimit then

                icon = 0

        else

                icon = 2

        end

        ShowMission(    loc("Racer"),

                                        loc("Status update"),

                                        string.format(loc("Rounds complete: %d/%d"), roundNumber, roundLimit) .. "|" .. " " .. "|" ..

                                        loc("Best team times: ") .. "|" .. totalComment, icon, 4000)

        -- end game if its at round limit

        if roundNumber >= roundLimit then

                -- Sort the scores for the ranking list

                local unfinishedArray = {}

                local sortedTeams = {}

                local k = 1

                local c = 1

                local clanScores = {}

                local previousClan

                for i = 0, TeamsCount-1 do

                        local clan = GetTeamClan(teamNameArr[i])

                        if not clanScores[clan+1] then

	                       clanScores[clan+1] = {}

	                       clanScores[clan+1].index = clan

	                       clanScores[clan+1].score = teamScore[i]

                        end

                        if teamScore[i] ~= MAX_TURN_TIME and teamNameArr[i] ~= " " then

                               sortedTeams[k] = {}

                               sortedTeams[k].name = teamNameArr[i]

                               sortedTeams[k].score = teamScore[i]

	                       sortedTeams[k].clan = clan

                               k = k + 1

                        else

                               table.insert(unfinishedArray, string.format(loc("%s did not finish the race."), teamNameArr[i]))

                        end

                end

                table.sort(sortedTeams, function(team1, team2)

                        if team1.score == team2.score then

                                return team1.clan < team2.clan

                        else

                                return team1.score < team2.score

                        end

                end)

                table.sort(clanScores, function(clan1, clan2) return clan1.score < clan2.score end)

                local rank = 0

                local rankPlus = 0

                local prevScore