# coding=utf-8    #必須指定
# df_maze.py
#!/usr/bin/env python

import numpy as np
import sys , traceback , os
import pdb
from collections import deque
import math
from struct import *
import random
if sys.version[0] == "2":
    import Tkinter as tk
else:
    import tkinter as tk
import copy
import math
from collections import deque
from p3drect import Room3d

debug_flag = False

class Maze():
#   def __init__(self,nx, ny, ix, iy):
    def __init__(self):

        print ("Search data file..")
        maze = []

        argvs = sys.argv
        argc  = len(argvs)
        if argc >=2:
            stno = argvs[1]
        else:
            stno = '1'
        sokodat = 'xsokoban/screens/screen.'+stno
        fs = open(sokodat)
        print (fs)
        cc = 0
        nxcount = []
        while True:
            a = (fs.readline())
            if a=="":
                break
            nxcount.append(len(a))
            maze.append([])
            for ch in a:
                maze[cc].append([ch])
            cc += 1
#       for ln in maze:
#           print (ln)

        nx = max(nxcount)-1
        ny = cc
        self.nx = nx
        self.ny = ny


        self.mazemap = []
        cc = 0
        for yl in range(len(maze)):
            self.mazemap.append([])
            for xi in range(nx):
                if xi >= len(maze[cc]) -1:
                    ch = [' ']
                else:
                    ch = maze[yl][xi]
                print (ch[0]),
                self.mazemap[cc].append(ch)
            self.mazemap[cc].reverse()
#           print (self.mazemap[cc])
            cc += 1
            print 
#       reversed(self.mazemap)
        # room data
        for y in range(ny):
            for x in range(nx):
#               print (self.mazemap[y][x][0]),
                # check outside
                if x <= 0:
                    self.mazemap[y][x].append('W')
                if x >= nx-1:
                    self.mazemap[y][x].append('E')
                if y <= 0:
                    self.mazemap[y][x].append('N')
                if y >= ny-1:
                    self.mazemap[y][x].append('S')

                # check wall N
                nb_n_x = x 
                nb_n_y = y - 1
                if 0 <= nb_n_x <= (nx-1) and 0 <= nb_n_y <= (ny-1):
                    if '#' in self.mazemap[nb_n_y][nb_n_x]:
                        self.mazemap[y][x].append('N')

                # check wall S
                nb_s_x = x
                nb_s_y = y + 1
                if 0 <= nb_s_x <= (nx-1) and 0 <= nb_s_y <= (ny-1):
                    if '#' in self.mazemap[nb_s_y][nb_s_x]:
                        self.mazemap[y][x].append('S')

                # check wall W
                nb_w_x = x -1 
                nb_w_y = y
                if 0 <= nb_w_x <= (nx-1) and 0 <= nb_w_y <= (ny-1):
                    if '#' in self.mazemap[nb_w_y][nb_w_x]:
                        self.mazemap[y][x].append('W')

                # check wall E
                nb_e_x = x + 1
                nb_e_y = y
                if 0 <= nb_e_x <= (nx-1) and 0 <= nb_e_y <= (ny-1):
                    if '#' in self.mazemap[nb_e_y][nb_e_x]:
                        self.mazemap[y][x].append('E')


#           print

    def mazewall(self):
        return self.mazemap

class Smallworld():
    def __init__(self):
        # Maze dimensions (ncols, nrows)
#       nx, ny = 15, 7
#       self.nx = float(nx)
#       self.ny = float(ny)
        # Maze entry position
#       ix, iy = 2, 2

        maze = Maze()  # make a sohko instance

        self.nx = maze.nx
        self.ny = maze.ny

        self.cellx = 20.0
        self.celly = 20.0
        self.walldivx = 5
        self.walldivy = 5

        self.height = 20.0

        self.rm3d = Room3d()

        self.rm3d.c0.title('sokoban')
        self.rm3d.c0.bind("<Key-q>",self.quit)
        self.rm3d.c0.bind("<Key-i>",self.initmx)
        self.rm3d.c0.bind("<Key-d>",self.viewval)
        self.rm3d.c0.bind("<Key-e>",self.viewval2)

        self.rm3d.c0.bind("<Up>"   ,self.keyup)
        self.rm3d.c0.bind("<Down>"   ,self.keydown)
        self.rm3d.c0.bind("<Left>"   ,self.keyleft)
        self.rm3d.c0.bind("<Right>"   ,self.keyright)
        self.rm3d.c0.bind("<Key-s>"   ,self.toggle_rotsw)
        self.rm3d.c0.bind("<Key-h>"   ,self.height_sw)
        self.rm3d.c0.bind("<Key-x>"   ,self.packman_debug)
        self.rm3d.c0.bind("<Key-f>"   ,self.follow_sw)
        self.rm3d.c0.bind("<Key-t>"   ,self.step)
        self.rm3d.c0.bind("<Key-p>"   ,self.pushcarge)
        self.rm3d.c0.bind("<Key-l>"   ,self.upandpush)
  
        valtext = "key assign:\n <up>,<down>  view point height\n <left>,<right>  distance\n s     toggle rotate"
#       self.rm3d.c6.create_text(30,30,textvariable=self.rm3d.s.get(),fill="white",justify='left',anchor='nw')
        self.rm3d.s2.set('key assign ------\n  h: toggle view point height.\n  d: view map\n  p: push cargo\n  l:push & walk')

        self.rm3d.s1.set(sys.version)
        self.rm3d.s3.set('[   ]')

        # build wall rectangle

        self.payload_qth = []

        self.mazemap = maze.mazewall()
        self.wall = self.build_a_world(self.mazemap)
#       self.rm3d.dispwall(self.wall)

        self.rm3d.dest = [self.maxx/2.0 , self.maxy/2.0,0]
        self.rm3d.dest = [0.0,0.0,0.0]
        self.rm3d.cposx = - 100.0
        self.rm3d.cposy = - 100.0
        self.rm3d.cposz = 300.0
        self.rm3d.cpos = [self.rm3d.cposx,self.rm3d.cposy,self.rm3d.cposz]

        self.rotsw = False
        xa = 180.0
        self.rotang = 180

        self.za = 10.0

        ix = self.ix
        iy = self.iy
        self.qthx = float(ix)
        self.qthy = float(iy)
        self.xpos = int(self.qthx)
        self.ypos = int(self.qthy)
        self.rl = self.cellx * 3.0
        self.rls = self.cellx * 0.38
        self.qthxinc = 0.0
        self.qthyinc = 0.0
        self.walk = 10

        self.here = 1.2
        self.sidewalk = 0
        self.kickoff = False

        hand = ['N','E','S','W']
#       hand = ['N','W','S','E']
        waydir = 2
        waydirinc = [ [0.0,-0.1],[0.1,0],[0,0.1],[-0.1,0]]
        followang = [180, 90,  0,270]   # use by index variable waydir
#       followang = [  0,270,180, 90]

 #      xque = deque(maxlen = 10)
 #      yque = deque(maxlen = 10)
        xque = deque([0,0,0,0,0,0,0,0,0,0])
        yque = deque([0,0,0,0,0,0,0,0,0,0])

        packinc = [0.0,0.0]
        xp2 = 0
        yp2 = 0

        self.cor_debug = False
        self.follow = False

        rotangtemp = 0

        self.rm3d.mx = 7.0
        self.rm3d.my = 1.0
        self.rm3d.xcenter = 0.0
        self.rm3d.ycenter = 0.0

        self.rm3d.threth = 8.0
#       self.rm3d.threth = 0.2
        self.rm3d.initmx = False   # diseble auto gain in rm3d.shift2center()

        self.rm3d.width= 1
        self.rm3d.focus = 20

        self.qthxp = 3.0
        self.qthyp = 3.0
        self.qthzp = 0.0

        self.packtoggle = False
        self.packsizel = 15.0

        payload = self.generate_packman()

        self.hita = False
        self.hitw = False
        self.hitc = False
 
        self.pushinc = 0
        self.pushkickoff = False
        self.pushwalk = 0
        self.pushandwalk = False
                ##### loop top #######################

        while True:
            if True:
                destoffsetx = np.sin(xa)*self.rl
                destoffsety = np.cos(xa)*self.rl
                destoffsetxs = np.sin(xa)*self.rls
                destoffsetys = np.cos(xa)*self.rls
                self.rm3d.cposx = self.qthx * self.cellx + self.cellx/2.0 - self.maxx/2.0
                self.rm3d.cposy = self.qthy * self.celly + self.celly/2.0 - self.maxy/2.0
                self.rm3d.cposz = self.za
                self.rm3d.cpos = [ self.rm3d.cposx , self.rm3d.cposy , self.rm3d.cposz]
                self.rm3d.dest = [self.rm3d.cposx + destoffsetx ,self.rm3d.cposy + destoffsety,0.1]  

                self.standin = [[ [ self.rm3d.cposx+destoffsetxs-self.here , self.rm3d.cposy+destoffsetys-self.here , 2],
                                  [ self.rm3d.cposx+destoffsetxs-self.here , self.rm3d.cposy+destoffsetys+self.here , 2],
                                  [ self.rm3d.cposx+destoffsetxs+self.here , self.rm3d.cposy+destoffsetys+self.here , 2],
                                  [ self.rm3d.cposx+destoffsetxs+self.here , self.rm3d.cposy+destoffsetys-self.here , 2],
                                  [0.9],['#fafdfe'],[56] ]]



            ##### aux object
            if True:
                st = self.rm3d.solve(self.standin)
                st2 = self.rm3d.reorder(st,[])
                st3 = self.rm3d.shift2center(st)
                self.rm3d.drawaux(st3)

            if True:
                ########## packman ############

                if True:
                    hogepack = []
                    for cell in self.payload_qth:
                            cposxp = cell[0] * self.cellx  - self.maxx/2.0
                            cposyp = cell[1] * self.celly  - self.maxy/2.0
                            cposzp = self.qthzp
                            hogetemp = self.rm3d.solve_pack(payload[0],[cposxp,cposyp,cposzp])
                            hogepack+=hogetemp

            ##### main object
            hoge = []
            self.imax = 0
            self.imin = 32767
            for cell in self.wall: 
                hoge2 = self.rm3d.solve(cell)
                for box in hoge2:
                    if len(box) > 2:
                        hoge.append(box)
                        if box[4][0] > self.imax:
                            self.imax =copy.copy( box[4][0])
                        if self.imin > box[4][0]:
                            self.imin = box[4][0]


            doge = self.rm3d.reorder(hoge,hogepack)
            boge = self.rm3d.shift2center(doge)
            self.rm3d.drawwall(boge)
            self.doge = boge

            ##### walk

            self.xpos = int(self.qthx+0.49)
            self.ypos = int(self.qthy+0.49)

            if self.walk != 0:
                self.qthx += self.qthxinc
                self.qthy += self.qthyinc
                self.walk -= 1

            elif self.kickoff and not self.hitw and not self.hita and (not self.hitc or self.pushandwalk):
#           elif self.kickoff and not self.hitw and not self.hita:
                self.kickoff = False
                if 340 < self.rotang or self.rotang < 20:
                    if not 'S' in self.mazemap[self.ypos][self.xpos] :
                        self.qthxinc = 0.0
                        self.qthyinc = 0.25
                        self.rotang = 0
                        self.walk = 4
                    else:
                        print ("Hit wall S")
                        pass
                elif 60 < self.rotang < 110:
                    if not 'E' in self.mazemap[self.ypos][self.xpos] :
                        self.qthxinc = 0.25
                        self.qthyinc = 0.0
                        self.rotang = 90
                        self.walk = 4
                    else:
                        print ("Hit wall E")
                        pass
                elif 160 <self.rotang < 200:
                    if not 'N' in self.mazemap[self.ypos][self.xpos] :
                        self.qthxinc = 0.0
                        self.qthyinc = -0.25
                        self.rotang = 180
                        self.walk = 4
                    else:
                        print ("Hit wall N")
                        pass
                elif 250 < self.rotang < 290:
                    if not 'W' in self.mazemap[self.ypos][self.xpos] :
                        self.qthxinc = -0.25
                        self.qthyinc = 0.0
                        self.rotang = 270
                        self.walk = 4
                    else:
                        pass
                        print ("Hit wall W")
            else:
                self.kickoff = False
                self.qthx = int(self.qthx + 0.3)
                self.qthy = int(self.qthy + 0.3)

            if self.sidewalk != 0:
                self.rotang += self.rotanginc
                self.sidewalk -= 1
                if self.rotang < 0:
                    self.rotang += 360
            xa = (2*np.pi/360.0) * self.rotang
            self.rotang = self.rotang % 360

            # push carge
            if self.pushkickoff and (self.pushwalk != 0):
                if not (self.hitw or self.hita):
                    self.payload_qth[cargeindex][0] += pushincx
                    self.payload_qth[cargeindex][1] += pushincy
                    self.pushwalk -= 1
                    if self.pushwalk == 0:
                        self.payload_qth[cargeindex][0] = int(self.payload_qth[cargeindex][0]+0.4)
                        self.payload_qth[cargeindex][1] = int(self.payload_qth[cargeindex][1]+0.4)
                        self.pushandwalk = False

                else:
                    self.pushwalk = 0
                    self.pushkickoff = False
                pass

            # check payload
            if self.walk == 0 or self.pushandwalk:
                pushincx = 0
                pushincy = 0
                if 340 < self.rotang or self.rotang < 20:
                    payposx = self.xpos
                    payposy = self.ypos + 1
                    paysurx = self.xpos
                    paysury = self.ypos + 2
                    pushincy = 1 * self.pushinc
                elif 60 < self.rotang < 110:
                    payposx = self.xpos + 1
                    payposy = self.ypos
                    paysurx = self.xpos + 2
                    paysury = self.ypos
                    pushincx = 1 * self.pushinc
                elif 160 <self.rotang < 200:
                    payposx = self.xpos
                    payposy = self.ypos - 1
                    paysurx = self.xpos
                    paysury = self.ypos - 2
                    pushincy = -1 * self.pushinc
                elif 250 < self.rotang < 290:
                    payposx = self.xpos - 1
                    payposy = self.ypos
                    paysurx = self.xpos - 2
                    paysury = self.ypos
                    pushincx = -1 * self.pushinc

                if [payposx,payposy] in self.payload_qth:
                    self.hitc = True
                    cargeindex = self.payload_qth.index([payposx,payposy])
#                   print ("Cargo is There.",[payposx,payposy],self.mazemap[paysury][paysurx])
                    if '#' in self.mazemap[paysury][paysurx]:
#                       print ("The cargo is hitting the wall. ")
                        self.rm3d.s3.set('Cargo can not move.')
                        self.hitw = True
                    else:
                        self.hitw = False
                    if [paysurx,paysury] in self.payload_qth:
#                       print ("The cargo hits another cargo. ")
                        self.rm3d.s3.set('Cargo can not move.')
                        self.hita = True
                    else:
                        self.hita = False
#                       self.rm3d.s3.set(' ')
                else:
                    self.hita = False
                    self.hitw = False
                    self.hitc = False
        pass
        # end of loop

    def generate_packman2(self,psc='#ffff00'):
        self.psc = psc
#       if self.packtoggle:
#           self.ps = self.packsizel
#           self.packtoggle = False
#       else:
#           self.ps = self.packsizes
#           self.packtoggle = True

        self.ps = self.packsizel
        packman = [[   
         [[-self.ps,-self.ps,-self.ps],[+self.ps,-self.ps,-self.ps],
                                    [+self.ps,+self.ps,-self.ps],[-self.ps,+self.ps,-self.ps],[0],[self.psc],[13] ],

         [[-self.ps,-self.ps,+self.ps],[+self.ps,-self.ps,+self.ps],
                                    [+self.ps,+self.ps,+self.ps],[-self.ps,+self.ps,+self.ps],[0],[self.psc],[13] ],


         [[-self.ps,-self.ps,-self.ps],[+self.ps,-self.ps,-self.ps],
                                    [+self.ps,-self.ps,+self.ps],[-self.ps,-self.ps,+self.ps],[0],[self.psc],[13] ],

         [[-self.ps,+self.ps,-self.ps],[+self.ps,+self.ps,-self.ps],
                                    [+self.ps,+self.ps,+self.ps],[-self.ps,+self.ps,+self.ps],[0],[self.psc],[13] ],


         [[-self.ps,-self.ps,-self.ps],[-self.ps,+self.ps,-self.ps],
                                    [-self.ps,+self.ps,+self.ps],[-self.ps,-self.ps,+self.ps],[0],[self.psc],[13] ],

         [[+self.ps,-self.ps,-self.ps],[+self.ps,+self.ps,-self.ps],
                                    [+self.ps,+self.ps,+self.ps],[+self.ps,-self.ps,+self.ps],[0],[self.psc],[13] ],
          ]]
        return packman

    def generate_packman(self):
        if True:

                    self.cellxpm = float((self.cellx-4) / self.walldiv)
                    self.cellypm = float((self.celly-4) / self.walldiv)

                    paycolor2 = '#ff0000'
                    self.payheight = 17
                    cc = 0
                    wallnwx = 2.0
                    wallnwy = 2.0
                    walldiv = self.walldiv
                    cellwall = [[]]

                    self.cellxm = self.cellx-4
                    self.cellym = self.celly-4


                    for i in range(walldiv):
                    # N                        
                        cellwall[cc].append([
                                [wallnwx+self.cellxpm*i    ,wallnwy,          0],
                                [wallnwx+self.cellxpm*(i+1),wallnwy,          0],
                                [wallnwx+self.cellxpm*(i+1),wallnwy,self.payheight],
                                [wallnwx+self.cellxpm*i    ,wallnwy,self.payheight],
                                [0],
                                [paycolor2],
                                [13]
                                             ])
                    # W
                        cellwall[cc].append([
                                [wallnwx+self.cellxm,wallnwy+self.cellypm*i    ,          0],
                                [wallnwx+self.cellxm,wallnwy+self.cellypm*(i+1),          0],
                                [wallnwx+self.cellxm,wallnwy+self.cellypm*(i+1),self.payheight],
                                [wallnwx+self.cellxm,wallnwy+self.cellypm*i    ,self.payheight],
                                [0],
                                [paycolor2],
                                [13]
                                             ])
                    # S
                        cellwall[cc].append([
                                [wallnwx+self.cellxpm*i     ,wallnwy+self.cellym,          0],
                                [wallnwx+self.cellxpm*(i+1) ,wallnwy+self.cellym,          0],
                                [wallnwx+self.cellxpm*(i+1) ,wallnwy+self.cellym,self.payheight],
                                [wallnwx+self.cellxpm*i     ,wallnwy+self.cellym,self.payheight],
                                [0],
                                [paycolor2],
                                [13]
                                             ])
                    # E
                        cellwall[cc].append([
                                [wallnwx           ,wallnwy+self.cellypm*i    ,          0],
                                [wallnwx           ,wallnwy+self.cellypm*(i+1),          0],
                                [wallnwx           ,wallnwy+self.cellypm*(i+1),self.payheight],
                                [wallnwx           ,wallnwy+self.cellypm*i    ,self.payheight],
                                [0],
                                [paycolor2],
                                [13]
                                             ])
        return cellwall

            
    def build_a_world(self,maze_map):

        self.maxx = self.nx * self.cellx
        self.maxy = self.ny * self.celly

        cellwall = []
        x,y=0,0
        cc = 0
        for column in maze_map:
            x = 0
            for cell in column:
                cellwall.append([])
#               print ("%2d %2d cell " % (x,y) ,cell.walls)

                wallcolor =  '#ffc0ff'
                wallcolor3=  '#ef00ef'
                wallcolor4=  '#044440'
                wallcolor5=  '#555500'
                wallcolor6=  '#666666'

                wallcolor9=  '#808080'

                wallcolorx = [wallcolor3,wallcolor,wallcolor,wallcolor3,wallcolor,wallcolor]
                goalcolor =  '#00ff00'
                startcolor = '#00ffff'
                ########
                wallnwx = x * self.cellx - self.maxx/2.0   # ne cornur
                wallnwy = y * self.celly - self.maxy/2.0  
                walldiv = 4
                self.walldiv = walldiv
                self.cellxp = float(self.cellx / walldiv)
                self.cellyp = float(self.celly / walldiv)

                # build wall polygon
                if '#' in maze_map[y][x]:

                    for i in range(walldiv):
                        wallcolor2 = wallcolorx[i]
                    # N                        
                        cellwall[cc].append([
                                [wallnwx+self.cellxp*i    ,wallnwy,          0],
                                [wallnwx+self.cellxp*(i+1),wallnwy,          0],
                                [wallnwx+self.cellxp*(i+1),wallnwy,self.height],
                                [wallnwx+self.cellxp*i    ,wallnwy,self.height],
                                [0],
                                [wallcolor2],
                                [0]
                                             ])
                    # W
                        cellwall[cc].append([
                                [wallnwx+self.cellx,wallnwy+self.cellyp*i    ,          0],
                                [wallnwx+self.cellx,wallnwy+self.cellyp*(i+1),          0],
                                [wallnwx+self.cellx,wallnwy+self.cellyp*(i+1),self.height],
                                [wallnwx+self.cellx,wallnwy+self.cellyp*i    ,self.height],
                                [0],
                                [wallcolor2],
                                [0]
                                             ])
                    # S
                        cellwall[cc].append([
                                [wallnwx+self.cellxp*i     ,wallnwy+self.celly,          0],
                                [wallnwx+self.cellxp*(i+1) ,wallnwy+self.celly,          0],
                                [wallnwx+self.cellxp*(i+1) ,wallnwy+self.celly,self.height],
                                [wallnwx+self.cellxp*i     ,wallnwy+self.celly,self.height],
                                [0],
                                [wallcolor2],
                                [0]
                                             ])
                    # E
                        cellwall[cc].append([
                                [wallnwx           ,wallnwy+self.cellyp*i    ,          0],
                                [wallnwx           ,wallnwy+self.cellyp*(i+1),          0],
                                [wallnwx           ,wallnwy+self.cellyp*(i+1),self.height],
                                [wallnwx           ,wallnwy+self.cellyp*i    ,self.height],
                                [0],
                                [wallcolor2],
                                [0]
                                             ])

                if '.' in maze_map[y][x]:

                        cellwall[cc].append([
                                [wallnwx+4            ,wallnwy+4            , 0],
                                [wallnwx+4            ,wallnwy+self.celly-4 , 0],
                                [wallnwx+self.cellx-4 ,wallnwy+self.celly-4 , 0],
                                [wallnwx+self.cellx-4 ,wallnwy+4            , 0],
                                [0],
                                [wallcolor9],
                                [0]
                                             ])

                # build peyload
                if '$' in maze_map[y][x]:
                    self.payload_qth.append([x,y])

                if '@' in maze_map[y][x]:
                    self.ix = x
                    self.iy = y
                    print ("@ is found ",self.ix,self.iy)
                

                ########
                cc += 1
                x += 1
            y += 1
#       print ("payload position = ",self.payload_qth)
        return cellwall
  
    def packman_debug(self,event=None):
        if self.cor_debug:
            self.cor_debug = False
        else:
            self.cor_debug = True

    def follow_sw(self,event=None):
        if self.follow:
            self.follow = False
        else:
            self.follow = True

    def viewval(self,event=None):
        x=0
        y=0
        for a in self.mazemap:
            x=0
#           a.reverse()
            for b in reversed(a):
                if '#' in b:
                    print ('#'),
#               elif (self.nx-x+3)==round(self.qthx) and y==round(self.qthy):
                elif (x)==round(self.nx - self.qthx - 1) and y==round(self.qthy):
                    print ('@'),
                elif [self.nx - x-1 ,y] in self.payload_qth:
                    print ('$'),
                elif '.' in b:
                    print ('.'),
                elif '$' in b:
                    print (' '),
                    pass
                elif '@' in b:
                    print (' '),
                    pass
                else:
                    print (' '),

#               print (b)
                x+=1
            print
            y+=1
        pass
        print ("x,y=",int(self.qthx),int(self.qthy))
        print ("carge ",self.payload_qth)

    def viewval2(self,event=None):
        print ("self.wall length = ",len(self.wall))
        self.rm3d.objval = 0
        pass

    def keyup(self,event=None):
        if self.walk == 0 and self.sidewalk == 0:
#           print ("up key...")
            self.rm3d.s3.set("up key...")
            self.kickoff = True
            return

    def pushcarge(self,event=None):
        if self.hitc:
            self.pushwalk = 5
            self.pushinc = 0.2
            self.pushkickoff = True
        pass

    def upandpush(self,event=None):
        if self.hitc:
            self.pushwalk = 4
            self.pushinc = 0.25
            self.pushkickoff = True
        if self.walk == 0 and self.sidewalk == 0:
            self.rm3d.s3.set("up key...")
            self.kickoff = True
        self.pushandwalk = True
#       print ("upandpush...",self.kickoff,self.pushkickoff)


    def keydown(self,event=None):
        if False:
            self.za -= 1.0
            print (" self.za = ",self.za)
        pass

    def keyleft(self,event=None):
        if self.walk != 0 or self.sidewalk != 0:
            return
        self.sidewalk = 2
        self.rotanginc = -45
#       self.rotang -= 90
        self.rotang = self.rotang % 360
        self.rm3d.s3.set("ang={:d}".format(self.rotang-90))

    def keyright(self,event=None):
        if self.walk != 0 or self.sidewalk != 0:
            return
        self.sidewalk = 2
        self.rotanginc = +45
#       self.rotang += 90
        self.rotang = self.rotang % 360
        self.rm3d.s3.set("ang={:d}".format(self.rotang+90))

    def initmx(self,event=None):
        self.rm3d.initmx = True

    def toggle_rotsw(self,event=None):
        if self.rotsw:
            self.rotsw = False
        else:
            self.rotsw = True

    def height_sw(self,event=None):
        self.rm3d.mx = 5.0
        self.rm3d.my = 1.0
        self.rm3d.xcenter = 0.0
        self.rm3d.ycenter = 0.0
        if self.za <= 20.0:
            self.za = 80.0
            self.rm3d.threth = 5.0
            self.rm3d.mx = 10.0
        elif self.za == 80.0:
            # close up view
            self.za = 10.0
            self.rm3d.threth = 120.0
        print (" self.za = ",self.za)

    def step(self,event=None):
        if self.rm3d.stepflag:
            self.rm3d.stepflag = False
        else:
            self.rm3d.stepflag = True

    def quit(self,event=None):
        print ("quit")
        self.rm3d.c0.destroy()
        sys.exit()

def HelloWorld():
    global mazemap
    print ("Hello World!")

    from df_maze import Maze

    print ("Sokoban 3D...... version 1.02 21-03-02")
    print ("(c) Kodera Ippei")

    sm = Smallworld()

    tk.mainloop()


if __name__=="__main__":
    HelloWorld()