--[[

This program was set as an exersize by Graham Ellis on
a Lua training course in Mexico (I run them worldwide -
contact graham@wellho.net for details)

Principles shown include the reading in of simulation /
game elements from a data file (and cleaning that data)
into several different types of 'object' (table in lua)
so that the simulation can be run with different towns
acting in a different manner, and yet with no horrid
series of if ... elseif ... elseif ... else blocks - i.e.
we're using polymorphism well.

Error checking, version control, better comments, variable
naming conventions all need further consideration, but
this is just a demonstration!

Sample data line from data file:
Chippenham 28000 growth 4 150000
]]

-- town.lua contains the definition of all types of town
-- (not like Java where it must be one class per file)

require ("towns")

fh,err = io.open("town_sim.txt")
towns = {}

-- Read the starting data into a table of towns

while true do
        line = fh:read()
        if not line then break end

        -- Strip comments off the end of each line
        line = string.gsub(line,"#.*","")

        -- If there's anything left in the line ...
        if string.match(line,"%S") then

                -- this could usefully be a separate function.
                -- that function should probably be in a separate
                -- file for re-use later
                line = string.gsub(line,"^%s*","")
                place, pop, rss_type, tph, houseprice =
                        string.match(line ,"(.-)\t+(.-)\t+(.-)\t+(.-)\t+(.*)")
                if rss_type == "growth" then
                        current = growth.new(place,pop,tph, houseprice)
                elseif rss_type == "stable" then
                        current = stable.new(place,pop,tph, houseprice)
                else
                        -- DON'T throw away error lines - flag them!
                        io.write ("Data error")
                        current = nil
                end
                if current then
                        towns[#towns+1] = current
                end
        end
end

--------- Data has been read in

--------- Initialise tables for simulation results and
--------- display initial data

changes = {}
prices = {}
for _,v in pairs(towns) do
        print (" ",v)
        -- Save initial values as start or result sets
        changes[v.place] = {v.pop}
        prices[v.place] = {v.houseprice}
        end

---------- Run simulation

-- 20 steps of 1 year

for k = 1, 20 do
        -- print ("Running forward ".. k .. " years")
        totfact = 0

        -- get factor total (for distribution of newcomers)

        for _,v in pairs(towns) do
                fftt = v:getfact()
                totfact = totfact + fftt
                end

        for _,v in pairs(towns) do
                fftt = v:getfact()
                incoming = v.pop

                -- Add newcomers in proportion to factor
                v:addpeeps(6000 * fftt / totfact)

                -- A certain percentage will move away
                v:wastage()
                outgoing = v.pop

                -- House prices change based on supply and demand
                v:change_house_prices(incoming, outgoing)

                -- Save the new values every fourth year
                if k % 4 == 0 then
                        changes[v.place][#changes[v.place]+1] = v.pop
                        prices[v.place][#prices[v.place]+1] = v.houseprice
                end
        end

        --[[ Commented out - dump the data annually
        for _,v in pairs(towns) do
                print (" ",v)
                end
        ]]
end

----------- Display result tables

io.write("\nProgression of population every 4 years\n")
for k,v in pairs(changes) do
        io.write(string.format("%-15s",k))
        for k9,v9 in pairs(v) do
                io.write(string.format("%6d",v9))
        end
        io.write("\n")
end

io.write("\nProgression of house prices every 4 years\n")

for k,v in pairs(prices) do
        io.write(string.format("%-15s",k))
        for k9,v9 in pairs(v) do
                io.write(string.format("%7d",v9))
        end
        io.write("\n")
end