# Copyright (c) 2013 Edward Langley

# All rights reserved.

#

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions

# are met:

#

# Redistributions of source code must retain the above copyright notice,

# this list of conditions and the following disclaimer.

#

# Redistributions in binary form must reproduce the above copyright

# notice, this list of conditions and the following disclaimer in the

# documentation and/or other materials provided with the distribution.

#

# Neither the name of the project's author nor the names of its

# contributors may be used to endorse or promote products derived from

# this software without specific prior written permission.

#

# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED

# TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

from __future__ import division

import colorsys

import ctypes

import libtcodpy as libtcod

import random

import time

import yaml

inst = lambda a:a()

@inst

class Settings:

LEVELS = 3

libtcod.console_init_root(Settings.SCREEN_WIDTH, Settings.DISPLAY_HEIGHT, 'Mapping', False)

libtcod.console_set_custom_font("terminal.png",libtcod.FONT_LAYOUT_ASCII_INROW|libtcod.FONT_TYPE_GREYSCALE)

#libtcod.console_set_fullscreen(True)

con = libtcod.console_new(Settings.SCREEN_WIDTH, Settings.SCREEN_HEIGHT)

blank = libtcod.console_new(Settings.SCREEN_WIDTH, Settings.SCREEN_HEIGHT)

#for x in range(Settings.SCREEN_WIDTH):

#for y in range(Settings.SCREEN_HEIGHT):

message_con = libtcod.console_new(Settings.SCREEN_WIDTH, 2)

libtcod.console_set_default_background(message_con,libtcod.red)

#libtcod.console_set_default_background(blank,libtcod.red)

libtcod.sys_set_fps(Settings.LIMIT_FPS)

import map

level = 1

mp = map.Map.rand_new(Settings.LEVELS, Settings.BASE) ## warning: exponential BASE ** LEVELS

mapping = {}

colors = {

}

df = 1/40.0

for x in range(-20,20):

char = random.choice(['.','.','.','*','*',';',':','"',"'",chr(5),'`'])

if char in colors:

h,s,v = colors[char]

print s,v

color = colorsys.hsv_to_rgb(h,s/1.75,v/2)

bgcolor = colorsys.hsv_to_rgb(h,s/4,v/4)

else:

hue = x+21 * df

color = colorsys.hsv_to_rgb(1/hue,0.5,0.5)

bgcolor = colorsys.hsv_to_rgb(1/hue,0.25,0.25)

color = [int(h*255) for h in color]

bgcolor = [int(h*255) for h in bgcolor]

mapping[x] = (libtcod.Color(*color), char, libtcod.Color(*bgcolor))

names = {

}

class LevelMap(object):

lm.adj_map(level, x,y)

lm = LevelMap(mp)

lm.calculate_level(level)

libtcod.console_set_default_foreground(message_con, libtcod.white)

for c in [con,message_con]:

libtcod.console_set_default_foreground(c, libtcod.white)

libtcod.console_clear(c)

offset_x, offset_y = 0,0

levelmap = mp.get_level(level)

MAP_Y,MAP_X = len(levelmap), len(levelmap[0])

player_x, player_y = random.randrange(0,MAP_X),random.randrange(0,MAP_Y)

if not lm.get_walkable(level,player_x,player_y):

player_x,player_y = [(x,y) for x in range(player_x-2,player_x+3) for y in range(player_y-2,player_y+3) if lm.get_walkable(level,x,y)][-1]

import time

ak=0

while not libtcod.console_is_window_closed():

t0 = time.time()

if player_x - offset_x >= Settings.SCREEN_WIDTH-5: offset_x += 5

elif player_x - offset_x < 5: offset_x -= 5

if player_y - offset_y >= Settings.SCREEN_HEIGHT-5: offset_y += 5

elif player_y - offset_y < 5: offset_y -= 5

offset_y = min(offset_y,MAP_Y-Settings.SCREEN_HEIGHT)

offset_y = max(offset_y,0)

offset_x = min(offset_x,MAP_X-Settings.SCREEN_WIDTH)

offset_x = max(offset_x,0)

t1 = time.time()

lm.comp_fov(level, player_x, player_y,10)

player_screen_pos = player_x-offset_x,player_y-offset_y

for y,row in enumerate(levelmap[offset_y:offset_y+Settings.SCREEN_HEIGHT]):

for x,cell in enumerate(row[offset_x:offset_x+Settings.SCREEN_WIDTH]):

color,char,bgcolor = mapping.get(cell, (libtcod.Color(0,0,0),' ',libtcod.Color(0,0,0)))

color = lm.get_color(level, x+offset_x, y+offset_y, color)

bgcolor = lm.get_color(level, x+offset_x, y+offset_y, bgcolor)

if (x,y) == player_screen_pos:

color = libtcod.Color(128,128,100)

char = '\x01'

libtcod.console_set_char_foreground(con, x,y, color)

libtcod.console_set_char_background(con, x,y, bgcolor)

libtcod.console_set_char(con,x,y,char)

print 'draw loop:', time.time()-t1

libtcod.console_print(message_con, 0,1,lm.get_tile_type(level, player_x,player_y)[0])

libtcod.console_blit(message_con, 0,0, Settings.SCREEN_WIDTH,2, 0, 0,Settings.DISPLAY_HEIGHT-2)

blit_x,blit_y = 0,0

blit_w,blit_h = Settings.SCREEN_WIDTH, Settings.SCREEN_HEIGHT

if blit_x + MAP_X < Settings.SCREEN_WIDTH:

blit_x = (Settings.SCREEN_WIDTH - (blit_x + MAP_X))/2

blit_x = int(blit_x)

blit_w = MAP_X

if blit_y + MAP_Y < Settings.SCREEN_HEIGHT:

blit_y = (Settings.SCREEN_HEIGHT - (blit_y + MAP_Y))/2

blit_y = int(blit_y)

blit_h = MAP_Y

libtcod.console_blit(con, 0,0, blit_w,blit_h , 0,blit_x,blit_y)

libtcod.console_flush()

libtcod.console_clear(message_con)

bk = (time.time()-t0)*1000

print 'time to keypress:', bk

print 'loop time:', ak+bk

key = libtcod.Key()

mouse = libtcod.Mouse()

libtcod.sys_wait_for_event(libtcod.EVENT_KEY_PRESS, key, mouse, False)

t0 = time.time()

olevel = level

diff = 1

if key.shift:

diff *= 10

alt = key.lalt | key.ralt

ox,oy = player_x,player_y

dest_x,dest_y = player_x,player_y

if key.vk == libtcod.KEY_DOWN and player_y < MAP_Y:

dest_y += diff

if alt:

dest_x -= diff

elif key.vk == libtcod.KEY_UP and dest_y > 0:

dest_y -= diff

if alt:

dest_x += diff

elif key.vk == libtcod.KEY_RIGHT and dest_x < MAP_X:

dest_x += diff

if alt:

dest_y += diff

elif key.vk == libtcod.KEY_LEFT and dest_x > 0:

dest_x -= diff

if alt:

dest_y -= diff

elif key.vk == libtcod.KEY_ESCAPE and any([key.lctrl,key.rctrl]): break

elif key.c == ord('>') and level < mp.depth: level += 1

elif key.c == ord('<') and level > 1: level -= 1

dest_x = min(dest_x,MAP_X-1)

dest_y = min(dest_y,MAP_Y-1)

dest_x = max(dest_x,0)

dest_y = max(dest_y,0)

if olevel == level:

libtcod.line_init(player_x,player_y, dest_x,dest_y)

nx,ny = libtcod.line_step()

while None not in {nx,ny}:

if not lm.get_walkable(level,nx,ny):

libtcod.console_print(message_con, 0,0,'You cannot walk through a %s' % lm.get_tile_type(level, nx,ny)[0])

break

print nx,ny

player_x,player_y = nx,ny

nx,ny = libtcod.line_step()

else:

player_prop = player_x/MAP_X, player_y/MAP_Y

offset_prop = offset_x/MAP_X, offset_y/MAP_Y

levelmap = mp.get_level(level)

MAP_Y,MAP_X = len(levelmap), len(levelmap[0])

libtcod.console_clear(0)

libtcod.console_clear(con)

print 'before:',offset_x, player_x, offset_x+Settings.SCREEN_WIDTH

player_x = int(MAP_X * player_prop[0])

player_y = int(MAP_Y * player_prop[1])

offset_x = int(player_x - Settings.SCREEN_WIDTH / 2)

if offset_x + Settings.SCREEN_WIDTH > MAP_X:

offset_x -= (offset_x+Settings.SCREEN_WIDTH) - MAP_X

offset_y = int(player_y - Settings.SCREEN_HEIGHT / 2)

if offset_y + Settings.SCREEN_HEIGHT > MAP_Y:

offset_y -= (offset_x+Settings.SCREEN_HEIGHT) - MAP_Y

lm.calculate_level(level)

if not lm.get_walkable(level,player_x,player_y):

player_x,player_y = [(x,y) for x in range(player_x-2,player_x+3) for y in range(player_y-2,player_y+3) if lm.get_walkable(level,x,y)][-1]

print 'time after keypress:', (time.time()-t0)*1000