dcearth/main.lua

local love = assert( love, "This tool requires LOVE: love2d.org" )
--assert( require('mobdebug') ).start() --remote debugger
local map = require 'map'
local button = require 'button'
local SAVEDIRECTORY = "out/"
local Camera = require 'camera'
local wasKeyPressed

function love.load()

  local lfs = assert( love.filesystem )
  lfs.setIdentity( "dcearth", false )
  assert( lfs.createDirectory( SAVEDIRECTORY.."data/earth" ))
  assert( lfs.createDirectory( SAVEDIRECTORY.."data/graphics" ))


  love.graphics.setNewFont( 14 )--, "mono" )
end

function love.directorydropped( path )
  if map.path then 
    assert( love.filesystem.unmount( map.path ) )
    map.loaded = false
  end
  love.filesystem.mount( path, "" )
  return map.load( path )
end

function love.update( dt )
  local tx, ty = 0, 0
  local moveCamera = false
  if love.keyboard.isScancodeDown( "w" ) then moveCamera = true; ty = ty + 30 * dt end
  if love.keyboard.isScancodeDown( "a" ) then moveCamera = true; tx = tx - 30 * dt end
  if love.keyboard.isScancodeDown( "s" ) then moveCamera = true; ty = ty - 30 * dt end
  if love.keyboard.isScancodeDown( "d" ) then moveCamera = true; tx = tx + 30 * dt end
  if love.keyboard.isScancodeDown( "q" ) then Camera.Zoom( dt ) end
  if love.keyboard.isScancodeDown( "e" ) then Camera.Zoom( -dt ) end
  if moveCamera then Camera.Translate( tx, ty ) end


end

function love.draw()
  if not map.loaded then
    local w, h = love.graphics.getDimensions()
    return love.graphics.printf( "Drag and drop folder to begin.", w / 2 - 200, h / 2 - 128, 200, "center")
  end

  love.graphics.push( "all" )
  map.draw()
  love.graphics.pop()

  --Status bar.
  local x, y = love.mouse.getPosition()
  local wx, wy = Camera.GetWorldCoordinate( x, y )
  local bx, by = Camera.GetBitmapCoordinate( x, y )
  local h = love.graphics.getHeight() - 60
  love.graphics.setColor( 0.1, 0.1, 0.5, 0.8 )
  love.graphics.rectangle( "fill", 0, 0, 250, love.graphics.getHeight() )
  love.graphics.setColor( 1, 1, 1, 1 )
  love.graphics.print(([[
    SCREEN%8d%8d
    WORLD %8.2f%8.2f
    BITMAP%8.2f%8.2f]]):format(x, y, wx, wy, bx, by), 0, 0)

  if map.selected then love.graphics.print( map.selected:formatDisplayInfo(), 0, 80 ) end
  if map.selectionLocked then end

  love.graphics.setColor( 1, 1, 1, 0.8 )
  button:draw()
end

function love.resize(w, h)
  Camera.Resize( w, h )
end

function love.wheelmoved(x, y)
  Camera.Zoom( (y > 0) and 0.5 or -0.5 )
end

function love.mousepressed( x, y, mouseButton, istouch, presses )
  local wx, wy = Camera.GetWorldCoordinate( x, y )
  print( ("MOUSE\tx %f\ty %f\twx %f\twy %f"):format(x, y, wx, wy) )
  if button.selected and button.selected:contains( x, y ) then button.selected:callback() end
end

function love.mousemoved( x, y, dx, dy, istouch )
  if not map.loaded then return end
  --mouse over menu
  button.selectIn( x, y )

  --mouse on map
  if map.selectionLocked then return end
  if map.editLayer and map.editLayer.selectNearest then 
    map.selected = map.editLayer:selectNearest( Camera.GetWorldCoordinate( x, y ) )
  end
end

function love.keypressed(key, code, isRepeat)
  wasKeyPressed = true

  if code == "down"   then return button.selectNext() end
  if code == "up"     then return button.selectPrev() end
  if code == "return" then return button.selected:callback() end

  if key == "l" then
    return map.save()
  end
  if key == "c" then
    map.selectionLocked = not( map.selectionLocked )
  end
end



do

  button.new{ name = "UNDO", y = 250, callback = map.undo }

  local function toolCallback( self )
    local f = (map.layers[self.layer])[self.name]
    if f then return f(self) end
  end

  local tools = {
    button.new{ name = "SELECT"},
    button.new{ name = "ERASE",},
    button.new{ name = "MOVE", },
    button.new{ name = "ADD",  },
    button.new{ name = "EDIT", },
    button.new{ name = "DRAW", },
  }
  for i, v in ipairs( tools ) do 
    v.callback = toolCallback 
    v.y = 250 + (v.h + 4) * ( i + 1 )
    v.visible = false
  end


  local layerButtons = {}

  local function back( self )
    for k, button in pairs( tools ) do button.visible = false end
    for k, button in pairs( layerButtons ) do button.visible = true end
    self.visible = false
    map.editLayer = false
  end

  local backButton = button.new{
    name = "BACK", 
    visible = false,
    y = 250 + button.h + 4,
    callback = back,
  }

  local layers = {
    { name = "AF",    layer = "africa"       },
    { name = "EU",    layer = "europe"       },
    { name = "NA",    layer = "northamerica" },
    { name = "SA",    layer = "southamerica" },
    { name = "AS",    layer = "southasia"    },
    { name = "RU",    layer = "russia"       },
    { name = "PATH",  layer = "travelnodes"  },
    { name = "AI",    layer = "ainodes"      },
    { name = "CITY",  layer = "cities"       },
    { name = "COAST", layer = "coastlines"   },
    { name = "LOW",   layer = "coastlinesLow"},
    { name = "SAIL",  layer = "sailable"     },
  }

  local visibilityIcon = love.graphics.newImage( "icons/eye.bmp" )
  local function toggleVisibleLayer( self )
    if not (self and self.layer) then return end
    local ml = map.layers[ self.layer ]
    ml.visible = not( ml.visible )
    self.icon = ml.visible and visibilityIcon
  end

  local soloIcon = love.graphics.newImage( "icons/eye.bmp" )
  local function soloVisibleLayer( self )
    --hide icons for disabled invisible layers
    print( "===SOLO LAYER===", self.layer )
    for i, button in ipairs( layerButtons ) do
      if button.layer ~= self.layer then
        button.icon = false
      end
    end
    for k, layer in pairs( map.layers ) do
      print( "invisible layer, map:", k, layer)
      layer.visible = false
    end
    map.layers[ self.layer ].visible = true
  end

  local function editLayer( self )
    map.editLayer = map.layers[ self.layer ]
    for k, button in pairs( layerButtons ) do button.visible = false end
    for k, button in pairs( tools ) do 
      button.visible = true
      button.layer = self.layer
    end
    backButton.visible = true
    return soloVisibleLayer( self )
  end

  local function copy( i, target )
    for k, v in pairs( layers[i] ) do 
      target[k] = target[k] or v
    end
    return target
  end


  local y = 250
  for i = 1, #layers do

    layerButtons[ 3 * i - 2 ] = button.new( copy( i, { 
          x = 8,
          y = y + (button.h + 4) * i,
          w = 112,
          callback = editLayer
        }))

    layerButtons[ 3 * i - 1 ] = button.new( copy( i, {
          x = 128,
          y = y + (button.h + 4) * i,
          w = 24,
          name = "V",
          callback = toggleVisibleLayer,
          icon = visibilityIcon,
        }))

    layerButtons[ 3 * i    ] = button.new( copy( i, {
          x = 160,
          y = y + (button.h + 4) * i,
          w = 24,
          name = "S",
          callback = soloVisibleLayer,
          icon = soloIcon
        }))
  end
end