On November 22 2013 10:47 sluggaslamoo wrote:On November 22 2013 08:39 3FFA wrote:On November 22 2013 08:21 sluggaslamoo wrote:On November 21 2013 08:09 3FFA wrote:(I just started learning about them so I feel like playing with it and making a small text adventure game, the array is an array of the rooms)
As I said here, this is for a set of 20 rooms to be navigated in. It gets really complicated to navigate more than one or two players/creatures through a ton of numbers that are listed but don't really make much sense. The reason I have 3 columns is because there are 3 routes to other rooms for each room on the map.
I'll make sure I take 21 out of a loop and make it have its own separate assignment statement, thank you for pointing that out.
From a design standpoint a 3D array is not really the right way to go about it. It would be better to have a single array of rooms, and each room has 4 variables, north/south/east/west which link to other rooms. ("3 routes to other rooms" suggest that there are 4 rooms connected for each room, including the one you came from)
Also look at your program in terms of roles and responsibilities and the kind of components you want in your program, don't think about the implementation first.
For example.
- It has a number of rooms = This tells me that a 1D Array of rooms is sufficient
- A room can connect to multiple rooms = Each room either needs an array of more rooms or N/S/E/W, in your case 4, NSEW should be sufficient and less complicated.
- Each room contains XYZ = A room needs to be a data-structure
Depends what you are trying to do though, if you are trying to learn multi-dimensional arrays there's much better problem domains in which multidimensional arrays are useful for. Such as a 2D array for a graphical tile-game, or matrix manipulation for 3D programming.
There's really no point in learning strange ways of implementing things because you're not really learning how to program. You learn to program by learning how to solve real problems in the best way possible. If you wanna learn how to use certain features of programming, you are better off finding a problem domain where the method you are using is appropriate, that way when you visit the same problem, you know exactly the best way of doing it.
I'm using a 2D Array, not a 3D Array. o.O
And I'm sorry, I meant that each room has 3 routes to rooms other than the current room. So NEW or SEW for each room. The way I'm doing the 2D Array is that the 1st column is E 2nd column is W and 3rd column is N or S depending on the room the player is in. Then the player inputs whether he wants to go N/S E or W...
Man I nearly finished writing my reply and then my computer crashed T_T, time to write it all again.
Anyway I looked at your original post again and I think I get it now. There is an initial array of 21 rooms, and each element has another array of 3 elements, which contain the index of the rooms in the original array.
Anyway I've found that telling people that their method is wrong never gets us anywhere so lets do it your way, then we'll design the program in a way that gives it enough flexibility that you can change it later if you want to.
Because you are using C, we'll use a mixture of object pool and factory patterns which makes life easier when using C. Also just because we are using C doesn't mean we can't take anything from OOP.
So initially we will need a Room Manager which is responsible for managing all your rooms and handling room instantiation. Your Room Manager will need
- object pool [base array]
- number_of_rooms [variable]
- initialize_rooms
- clean_up function [for use at the end of the program]
- create_room [factory function]
- has_room_available [true/false]
- retrieve_room
So first of all create those functions with no implementation, and your base array.
We don't need to use ADTs (classes for C), this can just be a separate file, or hell just separate it with comment lines for now.
####### Room Manager ######
function XYZ ()
etc etc
###########################
In your mind its important that you see these functions as belonging to a separate entity even if in reality they are global and don't belong to anything, it will make life easier in the long run.
Create your base array (object pool) globally (yes global variables are poisonous in a vacuum but lets not go down that path for now). Its not a real object pool (it contains arrays not objects) but we can treat it like one because it can be later.
In your initialize_rooms function this will create the pool. It should take a number_of_rooms argument which determines the size of the pool (base_array). Implement this first and test that it works (on its own), once it works move on.
In your clean_up function create an implementation that deallocates the array. This will eventually go at the end of your program.
In your has_room_available function, it will tell you if there are any empty rooms left in the pool. Basically you need to check if number_of_rooms doesn't exceed the number of rooms in the array, returning true or false. Test to make sure this works (on its own), then move on.
In your create_room function, it will take room1_number, room2_number, room3_number. Use your has_room_available() function to determine if you can create more rooms, if not, throw an error. It will then create an array in the next element in pool with 3 elements (using the arguments provided) using the number_of_rooms variable. When the array is created, the function returns the index of the room in the pool that was just created. Test to make sure this works (on its own), then move on.
In your retrieve_room function, you will just take a room_number argument. This will return the array from the pool, given the appropriate room index. This will also allow you to use a 1 based instead of 0 based numbering system, if you wanted to. Test to make sure this works, then move on.
Ok if you have unit tested your Room Manager (even just manually using traces), then you should be able to put the pieces the puzzle together without much problem knowing that each function on its own won't be causing errors allowing you to home in on any bugs much faster.
*************** Rooms done!
Now for the Player. We do the same thing, without using datastructures we create some variables for the player. Create another "component" for the Player like we did with the Room Manager.
Player
- player_position variable = Room number he is in
- move_to(room_number) = self explanatory
- current_room() = actually retrieves the room he is in using the retrieve_room function
See if you can implement those, remember to test each function separately. This is also where you can output your text adventure logging. "You enter room XYZ which room do you want to go now?"
************** Player done!
The last component for our minimum viable product will be the controller. Much like a gamepad, the controller is the interface responsible for handling all the input.
wait_for_input() will pause the terminal to wait for input using your terminal read function and return the appropriate data for which other components will use.
*************
The last bit comes with actually implementing the program. These components should be able to give you the tools to easily create a working program and in a very clean manner too.
The program should look something like
initialize_rooms(21)
starting_room = create_room(1,2,3)
create_room(starting_room,3,4)
move_to(starting_room)
while running
wait_for_input()
clean_up()
*************
Now you may ask why you can't just throw everything in the main function and try and get it to work? Doing it this way gives you direction and prevents you from getting lost, even if you are writing more code, what takes time is not writing the code, its understanding the implementation.
If you can write 75 words per minute, chances are the time spent figuring out what to do is going to be the biggest bottleneck in your program implementation time. So next time instead of rushing into the implementation take a step back and have a think about what are the tools you need to make it work.
At first it will take a long time to do it this way, but eventually in the long run it will be much more efficient, I didn't stop to think one time during this whole post, I just wrote everything off the top of my head. There could be stuff missing, but it should be enough for you to fill in the gaps.
Because this implementation is flexible, if you ever decide to, you can have your Room Manager return data structures instead of arrays if you ever want a more complex program, without much effort.
EPT
