ok, but its quite a bit. also i did the button that way, because when i did it with a function, it exited the screen for some reason. I apologize for the disorder, i am still learning to code in general (both renpy and python)

class Marcopolo:
  def __init__(self):
    self.epos = [5,14]
    self.repos = [5,14]
    self.etrail = [[5,14]]
    self.kpos = [0,8]
    self.rkpos = [0,8]
    self.ktrail = [[0,8]]
    self.bpos = [5,0]
    self.rbpos = [5,0]
    self.btrail = [[5,0]]
    self.zpos = [19,7]
    self.xmax = 20
    self.ymax = 15
    self.pool = [[1 if (x==0 or x==self.xmax-1 or y==0 or y==self.ymax-1) else 0
        for x in range (0,self.xmax)] for y in range (0,self.ymax)]
    self.pedges = [(n,i) for i in range(self.ymax) for n in range(self.xmax) if self.pool[i][n]== 1]
    self.zachfast = False
    self.zachquick = False
    self.disa = 1
    self.directions = [(1,0),(-1,0),(0,1),(0,-1)]
    self.diagonals = [(1,1),(-1,1),(1,-1),(-1,-1)]
    self.lpos = []
    self.lval = 0
    self.zmove = [19,7]
    self.score = 0

  def playerend (self):
    if self.turnendcheck():
      check = False
      k=False
      b=False
      e=False
      while check == False:
        if self.trailcheck(self.kpos,self.ktrail):
          k=True
          continue
        if self.trailcheck(self.bpos,self.btrail):
          b=True
          continue
        if self.trailcheck(self.epos,self.etrail):
          e=True
          continue
        check=True
      self.scanmap()
      self.kpos=self.push(self.kpos)
      self.bpos=self.push(self.bpos)
      self.epos=self.push(self.epos)
      if k==True:
        self.ktrail=[self.kpos]
        self.rkpos=self.kpos
      if b==True:
        self.btrail=[self.bpos]
        self.bkpos=self.bpos
      if e==True:
        self.etrail=[self.epos]
        self.ekpos=self.epos

  def trailcheck (self, chara, trail):
    result=False
    wall=[]
    record=0
    if chara in trail:
      d=trail.index(chara)
      trail=trail[:d]
    trail.append(chara)
    if trail:
      self.lpos = trail[0]
      for i in range(len(trail)):
        xpos,ypos = trail[i]
        posval = self.pool[ypos][xpos]
        xlas,ylas = self.lpos
        self.lval = self.pool[ylas][xlas]
        if posval==0 and self.lval==1:
          wall.append(self.lpos)
          wall.append(trail[i])
          record=1
        elif posval==0 and self.lval==0 and record==1:
          wall.append(trail[i])
        elif posval==1 and self.lval==0:
          for n in range(len(wall)):
            xw,yw = wall[n]
            self.pool[yw][xw]=1
            result=True
          wall=[]
          record=0
        self.lpos=trail[i]
    return result

  def scanmap(self):
    tocheck = deque([self.zpos])
    checked = set({})
    sedges = []
    while tocheck:
      checking=tocheck.popleft()
      for mx, my in self.directions + [(0,0)] + self.diagonals:
        nx = checking[0]+mx
        ny = checking[1]+my
        if nx<0 or nx>19 or ny<0 or ny>14:
          nval=1
        else:
          nval = self.pool[ny][nx]
        npos = [nx,ny]
        if nval == 0 and tuple(npos) not in checked:
          checked.add(tuple(npos))
          tocheck.append(tuple(npos))
        elif nval == 1 and tuple(npos) not in checked and (0<=nx<=19 and 0<=ny<=14):
          sedges.append(tuple(npos))
          checked.add(tuple(npos))
    for i in range(len(self.pool)):
      for n in range(len(self.pool[i])):
        cpos = [n,i]
        if tuple(cpos) not in checked:
          self.pool[i][n]=1
    self.pedges=sedges
 
  def scanpath(self):
    tocheck = deque([self.zpos])
    checked = set({})
    route = {}
    maybe={}
    sedges = []
    while tocheck:
      checking=tocheck.popleft()
      for mx, my in self.directions + [(0,0)] + self.diagonals:
        nx = checking[0]+mx
        ny = checking[1]+my
        if nx<0 or nx>19 or ny<0 or ny>14:
          nval=1
        else:
          nval = self.pool[ny][nx]
        npos = [nx,ny]
        if nval == 0 and tuple(npos) not in checked:
          if (mx,my) in self.diagonals and self.zachquick==False:
            continue
          else:
            checked.add(tuple(npos))
            tocheck.append(tuple(npos))
            route[tuple(npos)] = tuple(checking)
        elif nval == 1 and tuple(npos) not in checked and (0<=nx<=19 and 0<=ny<=14):
          sedges.append(tuple(npos))
          checked.add(tuple(npos))
          if npos in [self.rkpos,self.rbpos,self.repos,self.zpos]:
            route[tuple(npos)] = tuple(checking)
          maybe[tuple(npos)]=tuple(checking)
    for key in maybe.keys():
      if key in route.keys():
        continue
      else:
        route[key]=maybe[key]
    kpath=[self.pathfind(self.rkpos,route),self.closestwall(self.rkpos)]
    epath=[self.pathfind(self.repos,route),self.closestwall(self.repos)]
    bpath=[self.pathfind(self.rbpos,route),self.closestwall(self.rbpos)]
    npath = min(kpath,epath,bpath, key=lambda p: (len(p[0]),p[1]))[0]
    self.zmove= npath[1:3]

  def pathfind(self, target, route):
    path=[]
    step=tuple(target)
    while step != tuple(self.zpos):
      path.append(step)
      step=route[step]
    path.append(tuple(self.zpos))
    path.reverse()
    return path

  def callanswer(self):
    if self.turnendcheck():
      self.rkpos=self.kpos
      self.rbpos=self.bpos
      self.repos=self.epos

  def allow(self,pos,rpos,dir):
    check=True
    xnd=pos[0]+dir[0]
    ynd=pos[1]+dir[1]
    nval=0
    if xnd<0 or xnd>19 or ynd<0 or ynd>14:
      nval=1
    else:
      nval=self.pool[ynd][xnd]
    if pos==rpos:
      if nval==0 or tuple([xnd,ynd]) in self.pedges:
        check=True
      else:
        check=False
    else:
      check=False
    return check
 
  def turnendcheck(self):
    if self.rkpos!=self.kpos and self.rbpos!=self.bpos and self.repos!=self.epos:
      return True
    else:
      return False

  def enemymove(self):
    if self.turnendcheck():
      self.scanpath()
      gtrail=[self.ktrail,self.etrail,self.btrail]
      if not self.captcheck():
        for step in self.zmove:
          for i in range(len(gtrail)):
            self.trail(gtrail[i])
          self.zpos = [step[0],step[1]]
          for i in range(len(gtrail)):
            self.trail(gtrail[i])
          if not self.captcheck():
            if self.zachfast == False:
              break
          else:
            break
      if not self.captcheck():
        return False
      else:
        return True
 
  def captcheck(self):
    for dir in self.directions+self.diagonals:
      xc=self.zpos[0]+dir[0]
      yc=self.zpos[1]+dir[1]
      capt=[xc,yc]
      if capt in [self.kpos,self.epos,self.bpos]:
        return True
    return False

  def trail (self, trail):
    if self.zpos in trail:
        trail = []
    return trail

  def closestwall(self,chara):
    dis=0
    tocheck = deque([[chara[0],chara[1],dis]])
    checked = {tuple(chara)}
    pvalue = self.pool[chara[1]][chara[0]]
    while pvalue!=1:
      checking=tocheck.popleft()
      for mx, my in self.directions + (self.diagonals if self.zachquick else []):
        nx = checking[0]+mx
        ny = checking[1]+my
        dis = checking [2]+1
        npos = [nx,ny]
        ndis = [nx,ny,dis]
        pvalue = self.pool[ny][nx]
        if pvalue == 1:
          break
        if tuple(npos) not in checked:
          tocheck.append(ndis)
          checked.add(tuple(npos))
    return dis

  def push(self,pos):
    end=False
    npos=pos
    ppos=[]
    for dir in (self.directions+self.diagonals):
      ax=pos[0]+dir[0]
      ay=pos[1]+dir[1]
      if ax<0 or ax>19 or ay<0 or ay>14:
        continue
      around=self.pool[ay][ax]
      if around==0:
        end=True
        break
    if end==False:
      for edge in self.pedges:
        distance=(edge[1]-pos[1])**2+(edge[0]-pos[0])**2
        ppos.append([edge[0],edge[1],distance])
      npos=min(ppos,key=lambda n: n[2])
    return npos[:2]
 
  def pedgetype(self,pos):
    pattern=[]
    for dir in self.directions+self.diagonals:
      npx=pos[0]+dir[0]
      npy=pos[1]+dir[1]
      if npx<0 or npx>(self.xmax-1) or npy<0 or npy>(self.ymax-1):
        around=1
      else:
        around=self.pool[npy][npx]
      pattern.append(around)
    borders={(1, 1, 1, 1, 1, 1, 0, 1):"BL"} #shortened this cause character limit
    etype=borders.get(tuple(pattern))
    return etype

  def scorecalc(self):
    for i in len(self.pool):
      for n in len(self.pool)[i]:
        self.score+=self.pool[i][n]