LÖVE

Code: Select all

function render_layers()
  -- Renders all layers of the selected map

  local i = 1
  -- Draw background
  while i <= map_lastshadow[current_map] do
   if i ~= map_collisionlayer[current_map] then
    draw_layer(current_map, i)
    draw_layer(current_map, i, 1)
    if current_season == 0 then draw_layer(current_map, i, 2) end
   end
   i = i + 1
  end

  -- Draw above-shadow-below-entity background layers
  i = map_lastshadow[current_map] + 1
  while i < map_foreground[current_map] do
   if i ~= map_collisionlayer[current_map] then
    draw_layer(current_map, i)
    draw_layer(current_map, i, 1)
    if current_season == 0 then draw_layer(current_map, i, 2) end
   end
   i = i + 1
  end

  -- Draw foreground
  i = map_foreground[current_map]
  while i <= map_layer_count[current_map] do
  if i ~= map_collisionlayer[current_map] then
   draw_layer(current_map, i)
   draw_layer(current_map, i, 1)
   if current_season == 0 then draw_layer(current_map, i, 2) end
  end
   i = i + 1
  end
end

Code: Select all

function draw_layer(index, layer, layertype)
  -- Draws a layer from the specified map
  local hold_r = hold_r
  local hold_g = hold_g
  local hold_b = hold_b
  local tile_xsize = tile_xsize[index]
  local tile_ysize = tile_ysize[index]
  local map_xsize = map_xsize[index]
  local map_ysize = map_ysize[index]

  local i = 1
  local j = 1
  local l = 1
  local rendertile
  local selecttileset = 1
  local pickset = "tileset_tiles"

if setting_map == false then
 if layertype == 1 then g.setCanvas(snow_layer[layer])
 elseif layertype == 2 then g.setCanvas(transition_layer[layer])
 else g.setCanvas(map_layer[layer]) end
 g.clear()
end
  while j <= map_ysize do
    while l <= map_xsize do
      pickset = "tileset_tiles"
      if tile[index][layer] then if tile[index][layer][l] then if tile[index][layer][l][j] then
      if tile[index][layer][l][j] ~= 0 then
        rendertile = tile[index][layer][l][j]

        -- Check to see if the tile's value exceeds the currently-checked tileset offset
        selecttileset = 1
        while map_tileset[index][i] do
          if tile[index][layer][l][j] >= map_tileset_offset[index][i] then
            -- Check if an offset exists higher than this
            if not map_tileset_offset[index][i + 1] then
              -- No higher offset that meet this criteria, so use this one
              rendertile = tile[index][layer][l][j] - map_tileset_offset[index][i] + 1
              selecttileset = i
            elseif i > 1 then -- This one is too big, use the previous one (but only if not first index!)
              rendertile = tile[index][layer][l][j] - map_tileset_offset[index][i] + 1
              selecttileset = i
            end
          end
          i = i + 1
        end
        i = 1
        
        selecttileset = map_tileset[index][selecttileset]
        if tileset_variants[selecttileset] then
         if not layertype then
          if current_season == 2 or (current_season == 0 and current_subseason == 3) then
           pickset = "tileset_summertiles"
          elseif current_season == 3 or (current_season == 0 and current_subseason == 4) then
           pickset = "tileset_autumntiles"
          elseif current_season == 4 or (current_season == 0 and current_subseason == 1) then
           pickset = "tileset_wintertiles"
          else
           pickset = "tileset_tiles"
          end
         else
          if current_subseason == 1 then pickset = "tileset_tiles"
          elseif current_subseason == 2 then pickset = "tileset_summertiles"
          elseif current_subseason == 3 then pickset = "tileset_autumntiles"
          elseif current_subseason == 4 then pickset = "tileset_wintertiles" end
         end
        end

        if layertype == 1 then pickset = "tileset_snowtiles" end

        -- Store diggable and water info; this is the only place it made sense to set this...
        if tileset_diggable[selecttileset][rendertile] == true and not tile_diggable[index][l][j] then
         tile_diggable[index][l][j] = true
         tile_digimage[index][l][j] = ""
         tile_waterimage[index][l][j] = ""
         tile_state[index][l][j] = "normal"
         tile_tilled[index][l][j] = false
         tile_ploughed[index][l][j] = false
         tile_trenched[index][l][j] = false
         tile_trenched_filled[index][l][j] = false
        end
        if tileset_water[selecttileset][rendertile] == true and not tile_water[index][l][j] then
         tile_water[index][l][j] = true
        end

        if tileset_animation[selecttileset][rendertile - 1] then rendertile = tileset_animation_frame[selecttileset][rendertile - 1][tileset_animation[selecttileset][rendertile - 1]] + 1 end

        -- Render the tile; if this is a blockmap render, we do it a little differently!
        if map_layer_opacity[index][layer] then g.setColor(hold_r, hold_g, hold_b, map_layer_opacity[index][layer]) end
        if setting_map then gdraw(tileset_tiles[selecttileset][rendertile], ((l * tile_xsize) - tile_xsize), ((j * tile_ysize) - tile_ysize))
        else if _G[pickset][selecttileset][rendertile] then gdraw(_G[pickset][selecttileset][rendertile], ((l * tile_xsize) - tile_xsize), ((j * tile_ysize) - tile_ysize)) end
        end end end end end
      g.setColor(hold_r, hold_g, hold_b, base_a)
    l = l + 1
    end
  l = 1
  j = j + 1
  end
 if setting_map == false then g.setCanvas() end
end

Code: Select all

  while i <= map_lastshadow[current_map] do
    if i ~= map_collisionlayer[current_map] then
     gdraw(map_layer[i], screen_x, screen_y, base_rot, scale_x, scale_y)
    g.setColor(base_r, base_g, base_b, snow_level / 100)
    gdraw(snow_layer[i], screen_x, screen_y, base_rot, scale_x, scale_y)
    g.setColor(base_r, base_g, base_b, base_a)
    end
    i = i + 1
  end

Code: Select all

for x = x_visible_min, x_visible_max do
	for y = y_visible_min, y_visible_max do
		table.insert ( rendertiles, tiles[layer][x][y] )
	end
end
table.sort ( rendertiles, function ( a, b ) return a.priority < b.priority end )
for i = 1, #rendertiles do
	spritebatch:add ( rendertiles[i].sprite, rendertiles[i].x, rendertiles[i].y )
end
love.graphics.draw ( spritebatch, camera_x, camera_y )