improved modularization and freshness detection

ready to be main event loop but loop not programmed yet

chunkymap-regen.py

@@ -3,51 +3,94 @@ import os
 import subprocess
 
 # REQUIRES: see README.md
-# The way to do a full render is deleting all files from the folder chunkymap_data_path such as /var/www/html/minetest/chunkymapdata (or chunkymap in current directory on Windows)
+# The way to do a full render is deleting all files from the folder self.chunkymap_data_path such as /var/www/html/minetest/chunkymapdata (or chunkymap in current directory on Windows)
 
 #minetestmapper-numpy.py calculates the region as follows:
 #(XMIN','XMAX','ZMIN','ZMAX'), default = (-2000,2000,-2000,2000)
 #sector_xmin,sector_xmax,sector_zmin,sector_zmax = numpy.array(args.region)/16
-#sector_ymin = args.minheight/16
-#sector_ymax = args.maxheight/16
+#sector_ymin = args.self.minheight/16
+#sector_ymax = args.self.maxheight/16
 #region server-specific options
 
+class MTChunk:
+    x = None
+    z = None
+    is_player_here = None
+    is_fresh = None
 
-input_string = ""
-username = "owner"
+    def __init__(self):
+        self.is_player_here = False
+        self.is_fresh = False
+
+class MTChunks:
+    
+    website_root = None
+    username = None
+    os_name = None
+    chunkymap_data_path = None
+    profiles_path = None
+    profile_path = None
+    worlds_path = None
+    is_save_output_ok = None
+    mtmn_path = None
+    colors_path = None
+    python_exe_path = None
+    chunks = None
+    
+    #region values to save to YAML
+    world_name = None
+    world_path = None
+    chunkx_min = 0
+    chunkz_min = 0
+    chunkx_max = 0
+    chunkz_max = 0
+    chunk_size = 80
+    #values for command arguments:
+    maxheight = 50
+    minheight = -25
+    pixelspernode = 1
+    #ALSO save to YAML:
+    #total_generated_count = 0
+    #endregion values to save to YAML
+    
+    def __init__(self):  #formerly checkpaths() in global scope
+        self.chunks = {}
+        self.username = "owner"
+        self.website_root="/var/www/html/minetest"
+        self.world_name = "FCAGameAWorld"
         os_name="linux"
+
+        input_string = ""
         if (os.path.sep!="/"):
             os_name="windows"
-#input_string = input("Which username contains minetest/util/minetestmapper-numpy.py (minetest not .minetest) ["+username+"]?")
+        #input_string = input("Which self.username contains minetest/util/minetestmapper-numpy.py (minetest not .minetest) ["+self.username+"]?")
         if (len(input_string)>0):
-    username = input_string
+            self.username = input_string
         
-website_root="/var/www/html/minetest"
-chunkymap_data_path=os.path.join(website_root,"chunkymapdata")
-#input_string = input("What is the root folder of your minetest website ["+website_root+"]?")
+        #input_string = input("What is the root folder of your minetest website ["+self.website_root+"]?")
         if (len(input_string)>0):
-    website_root = input_string
+            self.website_root = input_string
+        self.chunkymap_data_path=os.path.join(self.website_root,"chunkymapdata")
 
-world_name = "FCAGameAWorld"
-#input_string = input("What is the game name ["+world_name+"]")
+        #input_string = input("What is the game name ["+self.world_name+"]")
         if (len(input_string)>0):
-    world_name = input_string
+            self.world_name = input_string
         #region server-specific options
-profiles_path = "/home"
+        self.profiles_path = "/home"
         if os_name=="windows":
-    profiles_path = "C:\\Users"
-profile_path = os.path.join(profiles_path, username)
-#if (not os.path.isdir(profile_path)):
-#    profile_path = os.path.join(profiles_path, "jgustafson")
-dotminetest_path = os.path.join(profile_path,".minetest")
-if (os_name=="windows"): dotminetest_path = "C:\\games\\Minetest"
-worlds_path = os.path.join(dotminetest_path,"worlds")
-world_path = os.path.join(worlds_path, world_name)
+            self.profiles_path = "C:\\Users"
+        self.profile_path = os.path.join(self.profiles_path, self.username)
+        #if (not os.path.isdir(self.profile_path)):
+        #    self.profile_path = os.path.join(self.profiles_path, "jgustafson")
+        self.dotminetest_path = os.path.join(self.profile_path,".minetest")
+        if (os_name=="windows"): self.dotminetest_path = "C:\\games\\Minetest"
+        self.worlds_path = os.path.join(self.dotminetest_path,"worlds")
+        self.world_path = os.path.join(self.worlds_path, self.world_name)
         auto_chosen_world = False
-if not os.path.isdir(world_path):
-    #for item in os.walk(worlds_path):
-    print ("LOOKING FOR WORLDS IN " + worlds_path)
-    for dirname, dirnames, filenames in os.walk(worlds_path):
+        if not os.path.isdir(self.world_path):
+            #for item in os.walk(self.worlds_path):
+            print ("LOOKING FOR WORLDS IN " + self.worlds_path)
+            for dirname, dirnames, filenames in os.walk(self.worlds_path):
                 index = 0
                 for j in range(0,len(dirnames)):
                     i = len(dirnames) - 0 - 1
@@ -57,42 +100,44 @@ if not os.path.isdir(world_path):
                 for subdirname in dirnames:
                     print ("  EXAMINING "+subdirname)
                     if (index == len(dirnames)-1):  # skip first one because the one on my computer is big
-                world_name = subdirname
-                world_path = os.path.join(dirname, subdirname) #  os.path.join(worlds_path, "try7amber")
-                print ("  CHOSE "+world_path)
+                        self.world_name = subdirname
+                        self.world_path = os.path.join(dirname, subdirname) #  os.path.join(self.worlds_path, "try7amber")
+                        print ("  CHOSE "+self.world_path)
                         auto_chosen_world = True
                         break
                     index += 1
                 if auto_chosen_world:
                     break
-python_exe_path = "python"
+        self.python_exe_path = "python"
+                
+        self.is_save_output_ok = True   # this is probably required to avoid minutely writes
+
 
         try:
             alt_path = "C:\\python27\python.exe"
             if os.path.isfile(alt_path):
-        python_exe_path = alt_path
+                self.python_exe_path = alt_path
         except:
             pass  # do nothing, probably linux
 
-mtmn_path = os.path.join( profile_path, "minetest/util/minetestmapper-numpy.py" )
-colors_path = os.path.join( profile_path, "minetest/util/colors.txt" )
+        self.mtmn_path = os.path.join( self.profile_path, "minetest/util/minetestmapper-numpy.py" )
+        self.colors_path = os.path.join( self.profile_path, "minetest/util/colors.txt" )
         if os_name=="windows":
-    mtmn_path = os.path.join(os.path.dirname(__file__), "minetestmapper-numpy.py")
-    colors_path = os.path.join(os.path.dirname(__file__), "colors.txt")
-    website_root = os.path.dirname(__file__)
-
-class MTChunk:
-    x = None
-    z = None
-    is_player_here = None
-
-    def __init__(self):
-        self.is_player_here = False
+            self.mtmn_path = os.path.join(os.path.dirname(__file__), "minetestmapper-numpy.py")
+            self.colors_path = os.path.join(os.path.dirname(__file__), "colors.txt")
+            self.website_root = os.path.dirname(__file__)
 
+        self.chunkx_min = 0
+        self.chunkz_min = 0
+        self.chunkx_max = 0
+        self.chunkz_max = 0
 
-is_save_output_ok = True
+        self.chunk_size = 80
+        self.maxheight = 50
+        self.minheight = -25
+        self.pixelspernode = 1
 
-def get_dict_from_conf_file(path,assignment_operator="="):
+    def get_dict_from_conf_file(self, path,assignment_operator="="):
         results = None
         print ("Checking "+str(path)+" for settings...")
         if os.path.isfile(path):
@@ -116,7 +161,7 @@ def get_dict_from_conf_file(path,assignment_operator="="):
         return results
 
 
-def deny_http_access(dir_path):
+    def deny_http_access(self, dir_path):
         htaccess_name = ".htaccess"
         htaccess_path = os.path.join(dir_path, htaccess_name)
         outs = open(htaccess_path, 'w')
@@ -133,52 +178,40 @@ def deny_http_access(dir_path):
 
 
     #locally unique identifier (unique to world only)
-def get_chunk_luid(x,z):
+    def get_chunk_luid(self, x,z):
         return "x"+str(x)+"z"+str(z)
         
-def get_chunk_image_name(chunk_luid):
+    def get_chunk_image_name(self, chunk_luid):
         return "chunk_"+chunk_luid+".png"
 
-def get_chunk_image_tmp_path(chunk_luid):
-    return os.path.join(os.path.dirname(__file__), get_chunk_image_name(chunk_luid))
+    def get_chunk_image_tmp_path(self, chunk_luid):
+        return os.path.join(os.path.dirname(__file__), self.get_chunk_image_name(chunk_luid))
 
-def get_chunk_image_path(chunk_luid):
-    return os.path.join(chunkymap_data_path, get_chunk_image_name(chunk_luid))
+    def get_chunk_image_path(self, chunk_luid):
+        return os.path.join(self.chunkymap_data_path, self.get_chunk_image_name(chunk_luid))
 
-def get_chunk_mapper_out_name(chunk_luid):
+    def get_chunk_genresult_name(self, chunk_luid):
         return "chunk_"+chunk_luid+"_mapper_result.txt"
 
-def get_chunk_mapper_out_tmp_path(chunk_luid):
-    return os.path.join(os.path.dirname(__file__), get_chunk_mapper_out_name(chunk_luid))
+    def get_chunk_genresult_tmp_path(self, chunk_luid):
+        return os.path.join(os.path.dirname(__file__), self.get_chunk_genresult_name(chunk_luid))
 
-def get_chunk_mapper_out_path(chunk_luid):
-    return os.path.join(chunkymap_data_path, get_chunk_mapper_out_name(chunk_luid))
+    def get_chunk_genresult_path(self, chunk_luid):
+        return os.path.join(self.chunkymap_data_path, self.get_chunk_genresult_name(chunk_luid))
 
-def remove_chunk(chunk_luid):
+    def is_genresult_marked(self, chunk_luid):
         result = False
-    out_path = get_chunk_mapper_out_path(chunk_luid)
-    png_path = get_chunk_image_path(chunk_luid)
-    if os.path.isfile(out_path):
-        os.remove(out_path)
-        result = True
-    if os.path.isfile(png_path):
-        os.remove(png_path)
-        result = True
-    return result
-
-def is_mapper_out_marked(chunk_luid):
-    result = False
-    dest_mapper_out_path = get_chunk_mapper_out_path(chunk_luid)
+        dest_genresult_path = self.get_chunk_genresult_path(chunk_luid)
         #is_empty_chunk = False
-    if os.path.isfile(dest_mapper_out_path):
+        if os.path.isfile(dest_genresult_path):
             result = True
         return result
 
-def is_mapper_out_marked_empty(chunk_luid):
-    dest_mapper_out_path = get_chunk_mapper_out_path(chunk_luid)
+    def is_genresult_marked_empty(self, chunk_luid):
+        dest_genresult_path = self.get_chunk_genresult_path(chunk_luid)
         result = False
-    if os.path.isfile(dest_mapper_out_path):
-        ins = open(dest_mapper_out_path)
+        if os.path.isfile(dest_genresult_path):
+            ins = open(dest_genresult_path)
             line = True
             while line:
                 line = ins.readline()
@@ -190,49 +223,109 @@ def is_mapper_out_marked_empty(chunk_luid):
             ins.close()
         return result
 
-def remove_mapper_out(chunk_luid):
-    dest_mapper_out_path = get_chunk_mapper_out_path(chunk_luid)
-    if os.path.isfile(dest_mapper_out_path):
-        os.remove(dest_mapper_out_path)
+    def remove_genresult(self, chunk_luid):
+        result = False
+        dest_genresult_path = self.get_chunk_genresult_path(chunk_luid)
+        if os.path.isfile(dest_genresult_path):
+            result = True
+            os.remove(dest_genresult_path)
+        return result
+
+    def remove_chunk_image(self, chunk_luid):
+        result = False
+        png_path = self.get_chunk_image_path(chunk_luid)
+        if os.path.isfile(png_path):
+            result = True
+            os.remove(png_path)
+        return result
             
-def remove_chunk_image(chunk_luid):
-    png_path = get_chunk_image_path(chunk_luid)
+    def remove_chunk(self, chunk_luid):
+        result = False
+        out_path = self.get_chunk_genresult_path(chunk_luid)
+        png_path = self.get_chunk_image_path(chunk_luid)
+        if os.path.isfile(out_path):
+            os.remove(out_path)
+            result = True
         if os.path.isfile(png_path):
             os.remove(png_path)
+            result = True
+        return result
 
-def is_chunk_rendered_on_dest(chunk_luid):  #formerly is_chunk_empty_on_dest (reversed)
+    def is_chunk_rendered_on_dest(self, chunk_luid):  #formerly is_chunk_empty_on_dest (reversed)
         is_rendered = False
-    #is_chunk_out_empty = is_mapper_out_marked_empty(chunk_luid)
-    #dest_mapper_out_path = get_chunk_mapper_out_path(chunk_luid)
-    dest_png_path = get_chunk_image_name(chunk_luid)
+        #is_chunk_out_empty = self.is_genresult_marked_empty(chunk_luid)
+        #dest_genresult_path = self.get_chunk_genresult_path(chunk_luid)
+        dest_png_path = self.get_chunk_image_name(chunk_luid)
         if os.path.isfile(dest_png_path):
-        #os.remove(dest_mapper_out_path)
+            #os.remove(dest_genresult_path)
             is_rendered = True
         return is_rendered
     
-if os.path.isfile(mtmn_path) and os.path.isfile(colors_path):
+    def prepare_chunk_meta(self, chunk_luid):
+        if chunk_luid not in self.chunks.keys():
+            self.chunks[chunk_luid] = MTChunk()
         
+    def render_chunk(self, x, z):
+        result = False
+        chunk_luid = self.get_chunk_luid(x,z)
+        png_name = self.get_chunk_image_name(chunk_luid)
+        png_path = self.get_chunk_image_tmp_path(chunk_luid)
+        cmd_suffix = ""
+        genresult_name = self.get_chunk_genresult_name(chunk_luid)
+        genresult_path = self.get_chunk_genresult_tmp_path(chunk_luid)
+        if self.is_save_output_ok:
+            cmd_suffix = " > \""+genresult_path+"\""
+        x_min = x * self.chunk_size
+        x_max = x * self.chunk_size + self.chunk_size - 1
+        z_min = z * self.chunk_size
+        z_max = z * self.chunk_size + self.chunk_size - 1
             
-    chunkymap_data_path=os.path.join(website_root,"chunkymapdata")
-    yaml_name = "generated.yml"
-    yaml_path = os.path.join(chunkymap_data_path, yaml_name)
-    if not os.path.isdir(chunkymap_data_path):
-        os.mkdir(chunkymap_data_path)
-    chunkymap_players_name = "players"
-    chunkymap_players_path = os.path.join(chunkymap_data_path, chunkymap_players_name)
+        #print ("generating x = " + str(x_min) + " to " + str(x_max) + " ,  z = " + str(z_min) + " to " + str(z_max))
+        cmd_string = self.python_exe_path + " \""+self.mtmn_path + "\" --region " + str(x_min) + " " + str(x_max) + " " + str(z_min) + " " + str(z_max) + " --maxheight "+str(self.maxheight)+" --minheight "+str(self.minheight)+" --pixelspernode "+str(self.pixelspernode)+" \""+self.world_path+"\" \""+png_path+"\"" + cmd_suffix
+        dest_png_path = self.get_chunk_image_path(chunk_luid)
+        dest_genresult_path = self.get_chunk_genresult_path(chunk_luid)
+        #is_empty_chunk = is_genresult_marked(chunk_luid) and is_genresult_marked_empty(chunk_luid)
+        print (cmd_string)
+        subprocess.call(cmd_string, shell=True)  # TODO: remember not to allow arbitrary command execution, which could happen if input contains ';' when using shell=True
+        if os.path.isfile(png_path):
+            result = True
+            try:
+                if (os.path.isfile(dest_png_path)):
+                    os.remove(dest_png_path)
+            except:
+                print ("Could not finish deleting '"+dest_png_path+"'")
+            try:
+                os.rename(png_path, dest_png_path)
+                print("(moved to '"+dest_png_path+"')")
+                self.prepare_chunk_meta(chunk_luid)
+                self.chunks[chunk_luid].is_fresh = True
+            except:
+                print ("Could not finish moving '"+png_path+"' to '"+dest_png_path+"'")
+        try:
+            if (os.path.isfile(dest_genresult_path)):
+                os.remove(dest_genresult_path)
+            if self.is_save_output_ok:
+                os.rename(genresult_path, dest_genresult_path)
+                print("(moved to '"+dest_genresult_path+"')")
+            else:
+                if os.path.isfile(genresult_path):
+                    os.remove(genresult_path)
+        except:
+            print ("Could not finish deleting/moving output")
         
-    htaccess_path = os.path.join(chunkymap_data_path,".htaccess")
+        return result
+        
+    def check_players(self):
+        self.chunkymap_data_path=os.path.join(self.website_root,"chunkymapdata")
+        chunkymap_players_name = "players"
+        chunkymap_players_path = os.path.join(self.chunkymap_data_path, chunkymap_players_name)
+        htaccess_path = os.path.join(chunkymap_players_path,".htaccess")
         if not os.path.isdir(chunkymap_players_path):
             os.makedirs(chunkymap_players_path)
         if not os.path.isfile(htaccess_path):
-        deny_http_access(chunkymap_data_path)
-    htaccess_path = os.path.join(chunkymap_players_path,".htaccess")
-    if not os.path.isfile(htaccess_path):
-        deny_http_access(chunkymap_players_path)
+            self.deny_http_access(chunkymap_players_path)
 
-    if not os.path.isdir(chunkymap_players_path):
-        os.makedirs(chunkymap_players_path)
-    players_path = os.path.join(world_path, "players")
+            players_path = os.path.join(self.world_path, "players")
             for dirname, dirnames, filenames in os.walk(players_path):
                 for filename in filenames:
                     file_fullname = os.path.join(players_path,filename)
@@ -255,28 +348,72 @@ if os.path.isfile(mtmn_path) and os.path.isfile(colors_path):
                                         player_name = found_value
                                     elif found_name=="position":
                                         player_position = found_value
+                                        
                                     if (player_name is not None) and (player_position is not None):
                                         has_enough_data = True
                                         break
                         ins.close()
                         player_dest_path = os.path.join(chunkymap_players_path,filename+".yml")
+                        if player_position is not None:
+                            # mark chunk
+                            tuple_noparen_pos_string = player_position.strip("() \n\r")
+                            pos_strings = tuple_noparen_pos_string.split(",")
+                            if len(pos_strings) == 3:
+                                player_x = int(pos_strings[player_x])
+                                player_y = int(pos_strings[player_y])
+                                player_z = int(pos_strings[player_z])
+                                chunk_x = int((float(player_x)/self.chunk_size))
+                                chunk_y = int((float(player_y)/self.chunk_size))
+                                chunk_z = int((float(player_z)/self.chunk_size))
+                                chunk_luid = self.get_chunk_luid(chunk_x, chunk_z)
+                                self.prepare_chunk_meta()
+                                self.chunks[chunk_luid].is_player_here = True
+                            else:
+                                print("Player '"+filename+"' has bad position data--should be 3-length (x,y,z) in position value: "+str(pos_strings))
+                                
                         if has_enough_data:
                             #if player_name!="singleplayer":
-                    map_player_dict = get_dict_from_conf_file(player_dest_path,":")
+                            map_player_dict = self.get_dict_from_conf_file(player_dest_path,":")
                             if (map_player_dict is None) or (map_player_dict["position"]!=player_position):
                                 outs = open(player_dest_path, 'w')
                                 outs.write("name:"+player_name+"\n")  # python automatically uses correct newline for your os when you put "\n"
                                 outs.write("position:"+player_position+"\n")
                                 outs.close()        
+    def is_player_at_luid(self, chunk_luid):
+        result = False
+        if chunk_luid in self.chunks.keys():
+            result = self.chunks[chunk_luid].is_player_here
+        return result
         
-    mapvars = get_dict_from_conf_file(yaml_path,":")
+    def is_chunk_fresh(self, chunk_luid):
+        result = False
+        if chunk_luid in self.chunks.keys():
+            result = self.chunks[chunk_luid].is_fresh
+        return result
+
+    def run(self):
+        if os.path.isfile(self.mtmn_path) and os.path.isfile(self.colors_path):
+            self.check_players()
+            self.chunkymap_data_path=os.path.join(self.website_root,"chunkymapdata")
+            yaml_name = "generated.yml"
+            yaml_path = os.path.join(self.chunkymap_data_path, yaml_name)
+            if not os.path.isdir(self.chunkymap_data_path):
+                os.mkdir(self.chunkymap_data_path)
+
+            htaccess_path = os.path.join(self.chunkymap_data_path,".htaccess")
+            if not os.path.isdir(self.chunkymap_data_path):
+                os.makedirs(self.chunkymap_data_path)
+            if not os.path.isfile(htaccess_path):
+                self.deny_http_access(self.chunkymap_data_path)
+            
+            mapvars = self.get_dict_from_conf_file(yaml_path,":")
             #is_testonly == (os_name=="windows")
 
-    if mapvars is not None and set(['world_name']).issubset(mapvars):
-        #print ("  (FOUND world_name)")
-        if mapvars["world_name"] != world_name:
-            print ("REMOVING data since from different world (map '"+str(mapvars["world_name"])+"' is not '"+str(world_name)+"')...")
-            for dirname, dirnames, filenames in os.walk(chunkymap_data_path):
+            if mapvars is not None and set(['self.world_name']).issubset(mapvars):
+                #print ("  (FOUND self.world_name)")
+                if mapvars["self.world_name"] != self.world_name:
+                    print ("REMOVING data since from different world (map '"+str(mapvars["self.world_name"])+"' is not '"+str(self.world_name)+"')...")
+                    for dirname, dirnames, filenames in os.walk(self.chunkymap_data_path):
                         index = 0
                         for j in range(0,len(filenames)):
                             i = len(filenames) - 0 - 1
@@ -284,7 +421,7 @@ if os.path.isfile(mtmn_path) and os.path.isfile(colors_path):
                                 print ("  SKIPPING "+filenames[i])
                                 filenames.remove_at(i)
                         for filename in filenames:
-                    file_fullname = os.path.join(chunkymap_data_path,filename)
+                            file_fullname = os.path.join(self.chunkymap_data_path,filename)
                             print ("  EXAMINING "+filename)
                             badstart_string = "chunk"
                             if (len(filename) >= len(badstart_string)) and (filename[:len(badstart_string)]==badstart_string):
@@ -292,108 +429,82 @@ if os.path.isfile(mtmn_path) and os.path.isfile(colors_path):
                             elif filename==yaml_name:
                                 os.remove(file_fullname)
 
-
-
-    chunks = {}
-
-    #region values to save to YAML
-    chunk_size = 80
-    chunkx_min = 0
-    chunkz_min = 0
-    chunkx_max = 0
-    chunkz_max = 0
+            self.chunkx_min = 0
+            self.chunkz_min = 0
+            self.chunkx_max = 0
+            self.chunkz_max = 0
             total_generated_count = 0
 
-    #values for command arguments:
-    maxheight = 50
-    minheight = -25
-    pixelspernode = 1
-    #ALSO save to YAML:
-    #world_name
-    #world_path
-    #endregion values to save to YAML
             newchunk_luid_list = list()
-    square_generates_count = 1
-    while square_generates_count > 0:
-        square_generates_count = 0
-        for z in range (chunkz_min,chunkz_max+1):
-            for x in range(chunkx_min,chunkx_max+1):
+            outline_generates_count = 1
+            while outline_generates_count > 0:
+                outline_generates_count = 0
+                for z in range (self.chunkz_min,self.chunkz_max+1):
+                    for x in range(self.chunkx_min,self.chunkx_max+1):
                         #python ~/minetest/util/minetestmapper-numpy.py --region -1200 800 -1200 800 --drawscale --maxheight 100 --minheight -50 --pixelspernode 1 ~/.minetest/worlds/FCAGameAWorld ~/map.png
                         #sudo mv ~/map.png /var/www/html/minetest/images/map.png
                         
                         #only generate the edges (since started with region 0 0 0 0) and expanding from there until no png is created:
-                is_outline = (x==chunkx_min) or (x==chunkx_max) or (z==chunkz_min) or (z==chunkz_max)
+                        is_outline = (x==self.chunkx_min) or (x==self.chunkx_max) or (z==self.chunkz_min) or (z==self.chunkz_max)
                         if is_outline:
-                    chunk_luid = get_chunk_luid(x,z)
-                    png_name = get_chunk_image_name(chunk_luid)
-                    png_path = get_chunk_image_path(chunk_luid)
-                    x_min = x * chunk_size
-                    x_max = x * chunk_size + chunk_size - 1
-                    z_min = z * chunk_size
-                    z_max = z * chunk_size + chunk_size - 1
+                            chunk_luid = self.get_chunk_luid(x,z)
                             
-                    cmd_suffix = ""
-                    mapper_out_name = get_chunk_mapper_out_name(chunk_luid)
-                    mapper_out_path = get_chunk_mapper_out_tmp_path(chunk_luid)
-                    if is_save_output_ok:
-                        cmd_suffix = " > \""+mapper_out_path+"\""
-                    #print ("generating x = " + str(x_min) + " to " + str(x_max) + " ,  z = " + str(z_min) + " to " + str(z_max))
-                    cmd_string = python_exe_path + " \""+mtmn_path + "\" --region " + str(x_min) + " " + str(x_max) + " " + str(z_min) + " " + str(z_max) + " --maxheight "+str(maxheight)+" --minheight "+str(minheight)+" --pixelspernode "+str(pixelspernode)+" \""+world_path+"\" \""+png_path+"\"" + cmd_suffix
-                    dest_png_path = get_chunk_image_tmp_path(chunk_luid)
-                    dest_mapper_out_path = get_chunk_mapper_out_path(chunk_luid)
-                    is_empty_chunk = is_chunk_empty_on_dest(chunk_luid)
-                    if full_render or ((not os.path.isfile(dest_png_path)) and (not is_empty_chunk)):
-                        print (cmd_string)
-                        subprocess.call(cmd_string, shell=True)  # TODO: remember not to allow arbitrary command execution, which could happen if input contains ';' when using shell=True
-                        if os.path.isfile(png_path):
-                            total_generated_count += 1
-                            square_generates_count += 1
-                            try:
-                                if (os.path.isfile(dest_png_path)):
-                                    os.remove(dest_png_path)
-                            except:
-                                print ("Could not finish deleting '"+dest_png_path+"'")
-                            try:
-                                os.rename(png_path, dest_png_path)
-                                print("(moved to '"+dest_png_path+"')")
-                            except:
-                                print ("Could not finish moving '"+png_path+"' to '"+dest_png_path+"'")
-                        try:
-                            if (os.path.isfile(dest_mapper_out_path)):
-                                os.remove(dest_mapper_out_path)
-                            if is_save_output_ok:
-                                os.rename(mapper_out_path, dest_mapper_out_path)
-                                print("(moved to '"+dest_mapper_out_path+"')")
+                            is_player_here = self.is_player_at_luid(chunk_luid)
+                            
+                            is_render_needed = False
+                            
+                            if not self.is_chunk_fresh(chunk_luid):
+                                if is_player_here:
+                                    if self.is_genresult_marked(chunk_luid):
+                                        if self.is_genresult_marked_empty(chunk_luid):
+                                            is_render_needed = True
+                                            print (chunk_luid+": RENDERING non-fresh marked empty chunk (player present in it)")
                                         else:
-                                if os.path.isfile(mapper_out_path):
-                                    os.remove(mapper_out_path)
-                        except:
-                            print ("Could not finish deleting/moving output")
+                                            print (chunk_luid+": SKIPPING non-fresh marked chunk (player present in it)")
                                     else:
-                        if os.path.isfile(dest_png_path):
+                                        is_render_needed = True
+                                        print (chunk_luid+": RENDERING non-fresh unmarked chunk (player present in it)")
+                                else:
+                                    if (not self.is_genresult_marked(chunk_luid)):
+                                        is_render_needed = True
+                                        print (chunk_luid+": RENDERING non-fresh unmarked chunk (skipped other checks since player not present in it)")
+                                    else:
+                                        print (chunk_luid+": SKIPPING non-fresh marked chunk (skipped other checks since player not present in it)")
+                            else:
+                                print (chunk_luid+": SKIPPING fresh chunk")
+                                #if (not self.is_genresult_marked(chunk_luid)):
+                                    #is_render_needed = True
+                            
+                            if is_render_needed:
+                                if (self.render_chunk(x,z)):
                                     total_generated_count += 1
-                            square_generates_count += 1
-                            print("Skipping existing map tile file " + png_name + " (delete it to re-render)")
-                        elif is_empty_chunk:
-                            print("Skipping empty chunk " + chunk_luid + " since not full_render")
-            print ("")  # blank line before next z so output is human readable
-        chunkx_min -= 1
-        chunkz_min -= 1
-        chunkx_max += 1
-        chunkz_max += 1
+                                    outline_generates_count += 1
+                            else:
+                                if self.is_chunk_rendered_on_dest(chunk_luid):
+                                    total_generated_count += 1
+                                    outline_generates_count += 1
+                                    png_path = self.get_chunk_image_path(chunk_luid)
+                                    print(chunk_luid+": Skipping existing map tile file " + png_path + " (delete it to re-render)")
+                                #elif is_empty_chunk:
+                                    #print("Skipping empty chunk " + chunk_luid)
+                    print ("")  # blank line before next z so output is more readable
+                self.chunkx_min -= 1
+                self.chunkz_min -= 1
+                self.chunkx_max += 1
+                self.chunkz_max += 1
             #end while square outline (1-chunk-thick outline) generated any png files
             new_map_dict = {}
-    new_map_dict["world_name"]=str(world_name)
-    new_map_dict["chunk_size"]=str(chunk_size)
-    new_map_dict["pixelspernode"]=str(pixelspernode)
-    new_map_dict["chunkx_min"]=str(chunkx_min)
-    new_map_dict["chunkx_max"]=str(chunkx_max)
-    new_map_dict["chunkz_min"]=str(chunkz_min)
-    new_map_dict["chunkz_max"]=str(chunkz_max)
-    new_map_dict["maxheight"]=str(maxheight)
-    new_map_dict["minheight"]=str(minheight)
-    new_map_dict["world_path"]=str(world_path)
-    new_map_dict["chunkymap_data_path"]=str(chunkymap_data_path)
+            new_map_dict["world_name"]=str(self.world_name)
+            new_map_dict["chunk_size"]=str(self.chunk_size)
+            new_map_dict["pixelspernode"]=str(self.pixelspernode)
+            new_map_dict["chunkx_min"]=str(self.chunkx_min)
+            new_map_dict["chunkx_max"]=str(self.chunkx_max)
+            new_map_dict["chunkz_min"]=str(self.chunkz_min)
+            new_map_dict["chunkz_max"]=str(self.chunkz_max)
+            new_map_dict["maxheight"]=str(self.maxheight)
+            new_map_dict["minheight"]=str(self.minheight)
+            new_map_dict["world_path"]=str(self.world_path)
+            new_map_dict["chunkymap_data_path"]=str(self.chunkymap_data_path)
             new_map_dict["total_generated_count"]=str(total_generated_count)
             is_changed = False
             if mapvars is None:
@@ -411,23 +522,30 @@ if os.path.isfile(mtmn_path) and os.path.isfile(colors_path):
                         break
             if is_changed:
                 outs = open(yaml_path, 'w')
-        outs.write("world_name:"+str(world_name) + "\n")
-        outs.write("chunk_size:"+str(chunk_size) + "\n")
-        outs.write("pixelspernode:"+str(pixelspernode) + "\n")
-        outs.write("chunkx_min:"+str(chunkx_min) + "\n")
-        outs.write("chunkx_max:"+str(chunkx_max) + "\n")
-        outs.write("chunkz_min:"+str(chunkz_min) + "\n")
-        outs.write("chunkz_max:"+str(chunkz_max) + "\n")
+                outs.write("world_name:"+str(self.world_name) + "\n")
+                outs.write("chunk_size:"+str(self.chunk_size) + "\n")
+                outs.write("pixelspernode:"+str(self.pixelspernode) + "\n")
+                outs.write("chunkx_min:"+str(self.chunkx_min) + "\n")
+                outs.write("chunkx_max:"+str(self.chunkx_max) + "\n")
+                outs.write("chunkz_min:"+str(self.chunkz_min) + "\n")
+                outs.write("chunkz_max:"+str(self.chunkz_max) + "\n")
                 #values for command arguments:
-        outs.write("maxheight:"+str(maxheight) + "\n")
-        outs.write("minheight:"+str(minheight) + "\n")
+                outs.write("maxheight:"+str(self.maxheight) + "\n")
+                outs.write("minheight:"+str(self.minheight) + "\n")
                 #ALSO save to YAML:
-        outs.write("world_path:"+str(world_path) + "\n")
-        outs.write("chunkymap_data_path:"+str(chunkymap_data_path) + "\n")
+                outs.write("world_path:"+str(self.world_path) + "\n")
+                outs.write("chunkymap_data_path:"+str(self.chunkymap_data_path) + "\n")
                 outs.write("total_generated_count:"+str(total_generated_count) + "\n")
-
                 outs.close()
             else:
                 print ("(Not saving '"+yaml_path+"' since same value of each current variable is already in file as loaded)")
         else:
             print ("failed since this folder must contain colors.txt and minetestmapper-numpy.py")
+
+def main():
+    #args = parse_args()
+    mtchunks = MTChunks()
+    mtchunks.run()
+
+if __name__ == '__main__':
+    main()