Dungeon Game

Ah right, thanks for the feedback. That creates a couple more questions for me though, if you have a chance to answer.

Does that mean it's better to just pass parameters/arguments in to functions that need them? Like my rooms list in the create_map() function, is it better to pass in width, height, rooms instead, then return rooms, and run that as:

rooms = create_map(width, height, rooms)

Like I have done with the repeat variable and the play_again() function?

I have only recently learned about how global and local work in python because I taught a new course this year that involves students needing to use well-chosen scopes for the variables in their program, and when they plan the program they have to list the variables they'll use, the datatype, the scope, and describe what it does.

I read somewhere that passing an argument into a function technically creates a local copy of that variable, and for top marks the students variable lists have to be really accurate (I could never make a full list of the variables I'd use before I've even written the code, but they have to try) so I thought if they just accessed the global ones then they at least don't have to list all of them twice.

In my code above, is it accurate to say that width and height are global variables because they're created outside of the functions, just in my loop, but that they are also local inside create_map()? Or would I just say they're global and not worry about the copies inside create_map()?

This is why I'm spending my holidays upskilling in Python, because it's so much easier to teach if you understand way more than you need to teach your students, rather than just being a few steps ahead :)

Sorry for the long post, and thanks in advance to anyone who can clear up any of this for me!

Hannah

Oops, now I have another question. I refactored my code to take out the globals by just passing in all the variables that I was originally accessing the globals of, and that worked, but then I found that I could actually just take out all of the arguments altogether, and my code still works, and I don't really understand why!

For example, this is the setup of my game still:

# Game Loop
repeat = True
while repeat == True:
    #Welcome the user
    print("Welcome to the dungeon!")
    print("Choose your challenge by setting the room size: \n\n")

    #Set room size
    width, height = "", ""
    while not width.isnumeric() or int(width) < 2:
        width = input("Enter room width: ")

    while not height.isnumeric() or int(height) < 2:
        height = input("Enter room height: ")

    width, height = int(width), int(height)

    #Initialise variables
    rooms = []
    breadcrumbs = []

    #Set up game
    create_map()
    player, door, monster = create_room()

So I'm creating width and height variables, but I can run my create_map() function without passing in width and height, or accessing them as global, and the game still runs fine. I thought I would have to pass them in?

I thought it might be something to do with just reading the values vs. modifying them, but appending to the rooms and breadcrumbs lists is working fine without passing them in as arguments, and I can even change an existing value without passing in the rooms list, e.g. rooms[0] = (1, 1) and that works.

Here are the create_map() and create_room() functions again:

def create_map():

    for y in range(height):
        for x in range(width):
            rooms.append((x, y))

def create_room():

    #Put the player in a spot
    player = random.choice(rooms)
    breadcrumbs.append(player)

    #Put the door in a different spot to player
    valid = False
    while valid == False:
        door = random.choice(rooms)
        if door != player:
            valid = True

    #Put the monster in a different spot to player and door
    valid = False
    while valid == False:
        monster = random.choice(rooms)
        if monster != player and monster != door:
            valid = True

    return player, door, monster

Hannah Taylor played the game, it works great!

So does that mean I should write the width, height = "", "" line up the top before I start defining the functions, and then keep the part where the user enters the width and height inside the game loop?

Thanks so much for your replies, they're really helpful for getting my head around best practice!

If your default width and height are 3, why not just set them to that by default? Then you have workable defaults. But, yes, I'd define them up to and then give the user the ability to overwrite them if wanted.

Wow, thanks, that's awesome. So is that mutability difference the reason why I can do this:

score  = 0
points = 10

def change_score(score):
    score += points
    return score

print(score) # prints 0

score = change_score(score)
print(score) # prints 10

And the function runs fine, and adds 10 to the score, but I only have to pass in score, and not points, because I'm not changing points but I am changing score? Is it better/more pythonic to do that or this with points passed in too:

score  = 0
points = 10

def change_score(score, points):
    score += points
    return score

print(score) # prints 0

score = change_score(score, points)
print(score) # prints 10

Thanks so much again for your time, and glad you enjoyed the game. I am particularly happy with the unicode icons and the WASD keys for navigating - would be better if you didn't have to hit enter, but I guess that's easier with a GUI.

Correct. points is effectively a constant there, since you're always adjusting the score by the same amount. In your second example, it would make more sense to have the points argument have a default.

I would say both are equally Pythonic. The difference would be in the needs of your project. If the score always increases by the same amount, the first makes more sense. If different actions award different increases, the second, with a default, makes more sense.

Awesome, thanks, that makes sense.

One last question (I promise), which is kinda related - the use of break in Python. There's that old argument that break and goto are bad programming, but I notice you use break a lot, and in my experience there are situations where using break in a while True: loop is several lines of code less than using a variable to keep the loop going (like in my game I'm using while repeat == True: and changing the value of repeat as Boolean).

Is break pretty acceptable in Python or considered Pythonic? Other teachers (at schools here) have said at beginner level we should be encouraging the students to use variables and structure their code well rather than using break etc. but not many have actually worked in industry, and especially not recently, so I'd be interested to know how it's seen in the Python community.

Thanks

Hannah Taylor: break isn't unPythonic at all. It's how you end a loop early. Even if my loop was going over a list or waiting for a variable to change to False, it's still valid to end the loop prematurely with break. In fact, Python has an else clause for for and while loops that's always fired so long as the loop completed without breaking (thankfully we don't have goto in Python).

Ideally you know if/when something will happen in your program. You'll know when a loop will end. But if you're not sure when, or you just don't want to have that extra bit of memory overhead, or whatever, you can use break to get out of the loop.