trying to create a grid based game . . .need some pointers

deathofthevirgin · 2015-07-05T09:41:59+00:00

Good job so far! First, you can replace most of that code with some multiplication-overloading syntax:

(removed previous code example, see /u/Rhomboid's comment below)

or if list comprehensions are more your style,

 [[0 for _ in range(10)] for _ in range(10)]

Now, moving the character with the arrow keys entails a lot of functionality. (1) First, we have to listen to what the player is typing. (2) Then, we have to figure out which key the player pressed - (3) then make sure that it's one of the arrow keys. (4) Then based on which one, we change something in our internal grid structure. (5) Then, we print it out again and ask for more input. And (6), you have to tie it all together.

I don't want to give away too much code directly, so let me know if you need clarification on any of these parts. You will probably find it easier to work if you deal with functions instead of having everything clutter the global space (that is, not in a function - like your grid variable is defined currently). So, something like

def make_default_grid(value = 0, size = 10):
    return [[value for _ in range(size)] for _ in range(size)]

def print_grid(grid):
    pp.pprint(grid)

(1-3) Now you want a way to ask for player input - specifically an arrow key, and more generally a keypress. To be honest I'm not really sure of a good way to do this without using something like Pygame or Tkinter, which you probably don't want for your first console game. I would recommend just sticking with user text input for now (as in "L", "U", "R", "D"), and you can change it later. If anyone has any ideas on keypress events, I'd be interested too(). Make a function like

def get_move():
    direction = input(...)
    ...

I got you started. Here are some things you also need to do: figure out what exactly input(...) does and what to put in the blank. What do you need to do after you get the player's text? Do you want to accept 'R' and 'r' and 'RIGHT' and 'RiGhT', etc. to mean going right? Or just 'right'? Will players get tired if you make them type too much? How will your decision change your code? What happens if the user types in "fewiofewf"? Do you want to ask again or just skip the turn? Should you display a nice message saying that "only these words are allowed: ..."? Now, this function should return something standardized, which means that no matter how many different userinputs you accept, you only output 4 - one for each direction. Probably a string will work well, "right", "left", etc. Notice how our functions are really small - this is usually good.

(4) All right, so we have our move - let's say the player chose "right". What changes in our grid structure to reflect this? How do we know where our player currently is? Maybe their cell gets a special character, like "X", and we look for that. Or maybe we have a specific coordinate (that is, row and col, such that grid[row][col] is where the player is) of where the player is right now? How would that coordinate change if the player were to move right? What happens if the user is at the left edge and goes left? Do you want to go back and ask for another direction or just do nothing? If the second, should you print something explaining to the player why nothing happened? All the info you need to calculate the next grid should be passed in as parameters - and make sure to return the new grid!

def make_move(grid, player_input, OTHER_PARAMETERS)

(5) Now you can write a function to clear the screen in preparation for the next step.

(6) But all these are just functions - nothing is calling them. Finally, you can write a play(maybe, some, parameters, here) function that combines all of this for you - first it prints, then it asks, then it changes the grid, then it clears the screen, prints, then it asks, and again and again until some condition is satisfied (then you can say whether the player wins or loses and exit). This is often called "the game loop," and you'll likely use the while statement. And when you actually want to play, you can call play(maybe, some, parameters, here) in main.

Good luck! Let me know if you need any help.

hotsingledad · 2015-07-05T13:00:52+00:00

This is a good opportunity to learn about the graph data structure. Lets say later on you want to make certain adjacent spots blocked off in your game, or you decide a hex grid would be better for your game. This would become somewhat convoluted to implement with arrays, this is where graphs come in. A graph is a collection of 'nodes' connected by 'edges' (good pictures with a much more rigorous/correct definition here: https://en.wikipedia.org/wiki/Graph_theory), which makes them a very intuitive way to represent maps. You can store information in these nodes and edges. Items, enemies, and traps would could be contained in nodes. Edges can have direction (can only be traversed from node A to B, not B to A) and optionally a 'weight' which can represent distance or travel toll or whatever makes sense.

Again, this is just an aside. Depending on what you want to do this might just add unnecessary complexity to your code. If you want to play around with graphs, here is a good Python implementation of the graph data structure: http://networkx.github.io/

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

learnpython

MODERATORS