Turtle Maze in python. I do not know how to avoid the turtle passing walls and cheat

Concept:

This is possible if you replace the pixels of the drawn lines with small turtle objects aligned, each small turtle object making a pixel of the lines.

So for example, if each small turtle object is stored in a list called lines:

def dx():
    red_line.speed(5)
    red_line.forward(11)
    for line in lines:
        if red_line.distance(line) < 5: # If the player came within 5 units of any pixel in the lines list...
            red_line.undo() # then undo the previous move
            break
    red_line.speed(0)

Implementation:

Okay, so here are the changes I made to your code.

1. I defined a pixels list to store each turtle that makes up the walls:

pixels = list()

2. In your mark_horizontal_line and mark_line_vertical functions, instead of drawing the walls, each line will be made up of 2 turtle objects of shape 'square' and size 1 pixel by 10.5 pixels (half the size of a wall).

So in the mark_horizontal_line function, from

            line_horizontal.down()
            line_horizontal.forward(21)
            line_horizontal.up()

to

            for i in range(2):
                line_horizontal.forward(21 / 4)
                pixel = line_horizontal.clone()
                pixel.showturtle()
                pixel.shape("square")
                pixel.shapesize(1 / 20, 10.5 / 20)
                pixels.append(pixel)
                line_horizontal.forward(21 / 4)

And in the mark_line_vertical function, from:

            line_v.down()
            line_v.forward(21)
            line_v.up()

to

            for i in range(2):
                line_v.forward(21 / 4)
                pixel = line_v.clone()
                pixel.showturtle()
                pixel.shape("square")
                pixel.shapesize(1 / 20, 10.5 / 20)
                pixels.append(pixel)
                line_v.forward(21 / 4)

3. I defined a forward() function that will make the red_line turtle move forward, but automatically undo its moves if it comes within 5 pixels of any of the pixels of the pixels list:

def forward(turt):
    for i in range(11):
        turt.forward(1)
        if any(pixel.distance(turt) < 5 for pixel in pixels):
            for i in range(i):
                turt.undo()
            break

5. Finally, replace the red_line.forward(11) in each of the , , and functions with forward(red_line) to call the function defined:

def dx():
    red_line.speed(5)
    forward(red_line) # Function call
    red_line.speed(0)

def sx():

    red_line.right(180)
    red_line.speed(5)
    forward(red_line) # Function call
    red_line.speed(0)
    red_line.right(-180)

def down():
    red_line.right(90)
    red_line.speed(5)
    forward(red_line) # Function call
    red_line.speed(0)
    red_line.right(-90)

def up():
    red_line.right(-90)
    red_line.speed(5)
    forward(red_line) # Function call
    red_line.speed(0)
    red_line.right(90)

Note: If you don't want to wait minute for the maze to be drawn, you can turn off tracer() for the mark_maze() call:

turtle.tracer(0)
mark_maze(lo, lv, -200, 300)
turtle.update()
turtle.tracer(1)

Altogether:

import turtle

turtle.title("TurtleMaze")





#here i define some funcions that mark the walls of the maze by the usage of some lists.
pixels = list()

def mark_horizontal_line(lo, x, y):
    line_horizontal = turtle.Turtle()
    line_horizontal.speed(0)
    line_horizontal.hideturtle()
    line_horizontal.up()
    line_horizontal.setposition(x, y)
    for n in lo:
        if n == 1:
            for i in range(2):
                line_horizontal.forward(21 / 4)
                pixel = line_horizontal.clone()
                pixel.showturtle()
                pixel.shape("square")
                pixel.shapesize(1 / 20, 10.5 / 20)
                pixels.append(pixel)
                line_horizontal.forward(21 / 4)
                
        if n == 0:
            line_horizontal.forward(21)


def mark_horizontal_lines(lo, x, y):
    step_y = y
    for n in lo:
        mark_horizontal_line(n, x, step_y)
        step_y -= 21



def mark_line_vertical(lv, x, y):
    line_v = turtle.Turtle()
    line_v.hideturtle()
    line_v.speed(0)
    line_v.up()
    line_v.setposition(x, y)
    line_v.right(90)
    for n in lv:
        if n == 1:
            for i in range(2):
                line_v.forward(21 / 4)
                pixel = line_v.clone()
                pixel.showturtle()
                pixel.shape("square")
                pixel.shapesize(1 / 20, 10.5 / 20)
                pixels.append(pixel)
                line_v.forward(21 / 4)
        if n == 0:
            line_v.forward(21)


def create_lines_vertical(lv, x, y):
    step_dx = x
    for n in lv:
        mark_line_vertical(n, step_dx, y)
        step_dx += 21


# this function marcks the entire maze by attaching all the others above

def mark_maze(lo, lv, x, y):
    mark_horizontal_lines(lo, x, y)
    create_lines_vertical(lv, x, y)

# i create a finestra = window

finestra = turtle.Screen()
finestra.screensize(600, 400)
finestra.title("TurtleMaze")

# these are the lists that contain the info to mark the lines

lo = [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
      [0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0],
      [0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1],
      [0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0],
      [0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1],
      [0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0],
      [0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0],
      [1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0],
      [0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0],
      [0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1],
      [1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0],
      [0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0],
      [1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1],
      [0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0],
      [0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0],
      [0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0],
      [0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0],
      [0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1],
      [1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0],
      [0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1],
      [0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0],
      [1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1],
      [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]

lv = [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
      [1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0],
      [0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1],
      [0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0],
      [0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1],
      [1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0],
      [0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0],
      [1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0],
      [0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0],
      [1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1],
      [0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0],
      [1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
      [0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0],
      [1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1],
      [1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0],
      [0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1],
      [1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0],
      [0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1],
      [1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0],
      [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0],
      [1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1],
      [0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0],
      [1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1],
      [0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0],
      [0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0],
      [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]




# i call the function to generate the maze

turtle.tracer(0)
mark_maze(lo, lv, -200, 300)
turtle.update()
turtle.tracer(1)

# now the movement section

starting_pos = (63, -162)

red_line = turtle.Turtle()
red_line.hideturtle()
red_line.speed(0)
red_line.up()
red_line.setposition(starting_pos)
red_line.color("red")
red_line.up()
red_line.down()

def forward(turt):
    for i in range(11):
        turt.forward(1)
        if any(pixel.distance(turt) < 5 for pixel in pixels):
            for i in range(i):
                turt.undo()
            break
def dx():
    red_line.speed(5)
    forward(red_line)
    red_line.speed(0)

def sx():

    red_line.right(180)
    red_line.speed(5)
    forward(red_line)
    red_line.speed(0)
    red_line.right(-180)

def down():
    red_line.right(90)
    red_line.speed(5)
    forward(red_line)
    red_line.speed(0)
    red_line.right(-90)

def up():
    red_line.right(-90)
    red_line.speed(5)
    forward(red_line)
    red_line.speed(0)
    red_line.right(90)

# to make the turtle go back i made some separated commands to keep it as easy as possible

def undo_sx():
    red_line.undo()
    red_line.undo()
    red_line.undo()



def undo_dx():
    red_line.undo()
    red_line.undo()
    red_line.undo()
    red_line.undo()
    red_line.undo()
    


def undo_down():
    red_line.undo()
    red_line.undo()
    red_line.undo()
    red_line.undo()
    red_line.undo()


def undo_up():
    red_line.undo()
    red_line.undo()
    red_line.undo()
    red_line.undo()
    red_line.undo()


def close():
    finestra.bye()


finestra.onkey(dx, "Right")
finestra.onkey(sx, "Left")
finestra.onkey(up, "Up")
finestra.onkey(down, "Down")
finestra.onkey(undo_dx, "d")
finestra.onkey(undo_sx, "a")
finestra.onkey(undo_down, "s")
finestra.onkey(undo_up, "w")
finestra.onkey(close, "q")

finestra.listen()
finestra.mainloop()

Output:

Observe how I keep attempting to "cheat", but the walls won't let me.

I like it. The ASCII art is cool. Yea it's do'able, but you have to divide the turtle position by whatever spacing is used, to achieve position in your level data, then compare for collision.

I've gotten somewhere with it, but one of your wall lists is rotated by 90 degrees, so it's wrecking my brain. I'll post what I have so far, so you can look at it. Tired, and it would take another day for me to get it running. Gonna grab some tea, watch a couple youtubes, then pass out. Might glance at it again tomorrow.

turtle.cfg

Tried to resize window with this. There's a way to do it, but for whatever reason it isn't.

width = 0.5
height = 0.75
leftright = None
topbottom = None
canvwidth = 700
canvheight = 500
mode = standard
colormode = 1.0
delay = 0
undobuffersize = 1000
shape = classic
pencolor = black
fillcolor = black
resizemode = noresize
visible = True
language = english
exampleturtle = turtle
examplescreen = screen
title = TurtleMaze
using_IDLE = False

#! /usr/bin/python3

##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
##  docs.python.org/3/library/t.html

import turtle as t
import math

##  create a finestra = window
finestra = t .Screen()

width = 700
height = 500

half_width = math .floor( width /2 )
half_height = math .floor( height /2 )

finestra .screensize( width, height )
finestra .title('TurtleMaze')

##  t.setheading() or t.seth()
East = 0
North = 90
West = 180
South = 270

red_line = t .Turtle()
red_line .hideturtle()
red_line .up()
red_line .speed('fastest')
red_line .color('red')

line_h = t .Turtle()
line_h .hideturtle()
line_h .seth( East )
line_h .up()
line_h .speed('fastest')

line_v = t .Turtle()
line_v .hideturtle()
line_v .seth( South )
line_v .up()
line_v .speed('fastest')

##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

##  draw walls by referencing lists.

def mark_horizontal_line( row, x, y ):
    line_h .up()
    line_h .setposition( x, y )
    for r in row:
        if r == 0:  line_h .up()
        else:  line_h .down()
        line_h .forward( horiz_spacing )


def create_horiz_lines( lo, x, y ):
    step_y = y
    for n in lo:
        mark_horizontal_line( n, x, step_y )
        step_y -= vert_spacing  ##  go down


def mark_line_vertical( column, x, y ):
    line_v .up()
    line_v .setposition( x, y )
    for c in column:
        if c == 0:  line_v .up()
        else:  line_v .down()
        line_v .forward( vert_spacing )


def create_vert_lines( lv, x, y ):
    step_dx = x
    for n in lv:
        mark_line_vertical( n, step_dx, y )
        step_dx += horiz_spacing  ##  go right

##  generate entire maze by attaching all the others above

def mark_maze( lo, lv, x, y ):
    create_horiz_lines( lo, x, y )
    create_vert_lines( lv, x, y )


##  horizontal segment data:  23 vert x 25 horiz

lo = [  [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0],
        [0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1],
        [0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0],
        [0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1],
        [0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0],
        [0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0],
        [1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0],
        [0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0],
        [0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1],
        [1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0],
        [0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0],
        [1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1],
        [0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0],
        [0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0],
        [0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0],
        [0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0],
        [0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1],
        [1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0],
        [0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1],
        [0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0],
        [1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]  ]

##  vertical segment data:  26 vert x 22 horiz   rotated by 90*

lv = [  [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0],
        [0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1],
        [0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0],
        [0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1],
        [1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0],
        [0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0],
        [1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0],
        [0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0],
        [1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1],
        [0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0],
        [1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
        [0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0],
        [1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1],
        [1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0],
        [0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1],
        [1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0],
        [0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1],
        [1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0],
        [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0],
        [1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1],
        [0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0],
        [1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1],
        [0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0],
        [0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]  ]

##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

horiz_spacing = width /len( lo[0] )
vert_spacing = height /len( lv[0] )

horiz_walk = horiz_spacing /3
vert_walk = vert_spacing /3

##  generate maze
mark_maze( lo, lv, -half_width, half_height )

##  now the movement section
starting_pos = ( 0, -half_height )

red_line .setposition( starting_pos )
red_line .seth( North )
red_line .showturtle()
red_line .down()

def up():
    xx = round( (half_width +red_line .xcor()) /horiz_spacing )
    yy = round( (half_height +red_line .ycor() -vert_walk) /vert_spacing )
    red_line .seth( North )
    print( xx, yy )
    if lo[-yy][xx] == 0:
        red_line .forward( vert_walk )
    else:
        finestra .bgcolor( 'orange' )
        red_line .speed( 'slow' )
        red_line .forward( vert_walk )
        red_line .undo()
        finestra .bgcolor( 'white' )


def down():
    xx = round( (half_width +red_line .xcor()) /horiz_spacing )
    yy = round( (half_height +red_line .ycor() +vert_walk) /vert_spacing )
    red_line .seth( South )
    print( xx, yy )
    if lo[-yy][xx] == 0:
        red_line .forward( vert_walk )
    else:
        finestra .bgcolor( 'orange' )
        red_line .speed( 'slow' )
        red_line .forward( vert_walk )
        red_line .undo()
        finestra .bgcolor( 'white' )


def left():
    xx = round( (half_width +red_line .xcor() -horiz_walk) /horiz_spacing )
    yy = round( (half_height +red_line .ycor()) /vert_spacing )
    red_line .seth( West )
    print( xx, yy )
    if lv[xx][yy] == 0:
        red_line .forward( vert_walk )
    else:
        finestra .bgcolor( 'orange' )
        red_line .speed( 'slow' )
        red_line .forward( vert_walk )
        red_line .undo()
        finestra .bgcolor( 'white' )


def right():
    xx = round( (half_width +red_line .xcor() +vert_walk) /horiz_spacing )
    yy = round( (half_height +red_line .ycor()) /vert_spacing )
    red_line .seth( East )
    print( xx, yy )
    if lv[xx][yy] == 0:
        red_line .forward( vert_walk )
    else:
        finestra .bgcolor( 'orange' )
        red_line .speed( 'slow' )
        red_line .forward( vert_walk )
        red_line .undo()
        finestra .bgcolor( 'white' )

def undo():
    red_line .undo()

def quit():
    finestra .bye()

finestra .onkey( up, 'Up' )
finestra .onkey( down, 'Down' )
finestra .onkey( left, 'Left' )
finestra .onkey( right, 'Right' )

finestra .onkey( undo, 'space' )
finestra .onkey( quit, 'q' )

finestra .listen()
finestra .mainloop()

Actually sorry to disappoint you, but i don't think this is possible using turtle. If you want the turtle to collide with the walls, you need to implement collision detection and for that you need the co-ordinates of the walls, which you don't have. Maybe you can make a snake game using pygame module.