Discrete field module

"""
Dimension maps
CREATE MAP
  Size, dimensions, standard symbol
  Defines a discrete field
PURGE MAP
  Resets the discrete field to the default
SET
  List of coords, value
  Sets value on the coords
GET
  List of coords
  Returns value from the field
MAP_FUNC
  Function (COORDS, VALUE)
  Calls the function on every coord
BOUND
  List of coords
  Returns whether coords lie inside the field
MAP_OBJECT
  Returns the map itself as a list
SHOW_FUNC
  List of functions for each level called AFTER, list of functions for each level called BEFORE incrementing
  First function is called when X is changed
  Second function is called when Y is changed
  Third function is called when Z is changed
  ...
"""

from copy import deepcopy
class Map:
    the_map = []
    default = 0
    cur_size = 0
    dimension = 0
    def __init__(self, size, dimensions=2, standard=0):
        self.create_map(size, dimensions, standard)

    def __round__(self, n):
        # Performs roundation on the whole map if possible
        def roundation(part, coord, value):
            if hasattr(value, "__round__"):
                part.set(coord, round(value, n))
        self.map_func(roundation)

    def create_map(self, size, dimensions=2, standard=0.0):
        blank = []
        temporary = []
        for x in range(size):
            blank.append(deepcopy(standard))
        for dimension in range(0, dimensions-1):
            for x in range(size):
                temporary.append(deepcopy(blank))
            blank = temporary
            temporary = []
        self.the_map = blank
        self.default = standard
        self.cur_size = size
        self.dimension = dimensions

    def purge_map(self):
        def reset(level):
            if type(level) is list:
                for i in range(len(level)):
                    if type(level[i]) is list:
                        reset(level[i])
                    else:
                        level[i] = default
            else:
                level = default
        reset(self.the_map)

    def bound(self, coords):
        for coord in coords:
            if coord < 0:
                return False
            if coord >= self.cur_size:
                return False
        return True

    def set(self, coords, value):
        if not self.bound(coords): return False
        cur_lev = self.the_map
        for i in range(min(self.dimension-1, len(coords)-1)):
            cur_lev = cur_lev[coords[i]]
        cur_lev[coords[len(coords)-1]] = value
        return True

    def get(self, coords):
        if not self.bound(coords): return False
        cur_lev = self.the_map
        for i in range(min(self.dimension-1, len(coords)-1)):
            cur_lev = cur_lev[coords[i]]
        return cur_lev[coords[len(coords)-1]]

    def map_func(self, gf):
        coord_set = []
        for i in range(self.dimension):
            coord_set.append(0)
        while coord_set[0] < self.cur_size:
            n = self.dimension-1
            gf(self, coord_set, self.get(coord_set))
            while n > 0:
                if coord_set[n]+1 < self.cur_size:
                    coord_set[n] += 1
                    break
                else:
                    coord_set[n] = 0
                    coord_set[n-1] += 1
                    n -= 1
                    continue

    def show_func(self, funka=[], funkb=[]):
        coord_set = []
        lst = self.dimension-1
        lim = self.cur_size
        for m in range(self.dimension):
            coord_set.append(0)
        def anti_coord():
            x = deepcopy(coord_set)
            x.reverse()
            return x
        def funkby(n):
            if n < len(funkb):
                f = funkb[n]
                if callable(f):
                    f(self, anti_coord(), self.get(anti_coord()))
        def funkay(n):
            if n < len(funka):
                f = funka[n]
                if callable(f):
                    f(self, anti_coord(), self.get(anti_coord()))
        def incen(n):
            if n > lst:
                return True
            if coord_set[n] >= lim:
                coord_set[n] = 0
                if n == 0:
                    funkay(0)
                return True
            if coord_set[n] < lim:
                funkby(n)
                if incen(n+1):
                    funkay(n)
                    coord_set[n] += 1
                    incen(n)
            return True
        incen(0)

    def map_object():
        return the_map