objective c large random method, am i doing this right? - iphone

Question

I've been building a simpler game with core graphics with random scripted encounters if that makes any sense and its started to become a huge method in the view controller.
-(void)spawnStuff{
CGPoint position;
CGPoint position1;
int chance = random()%10;
switch (chance) {
case 0:
[self spawnWall];
Position.y = 580;
Position.x = 160;
wall.center = Position;
[self spawnWall];
Position1.y = 480;
Position1.x = 80;
wall.center = Position1;
}
-(void)spawnWall{
UIImage* myImage = [UIImage imageNamed:#"Wall.png"];
Wall = [[Sprite alloc] initWithImage:myImage];
CGRect rect = CGRectMake(0, 0, 90, 50);
more initilization stuff }
and I might repeat this line of code 20 - 30 different with positions of these walls and with only 10 different scenario its about a 3rd of the code in the class, its starting to get a lil redonkulous I'm still very new to programming and giant methods kinda scare me. Is this the right way to approach this?

Answer 1

If you do this kind of stuff often, I would suggest keeping an array of possible actions, and then just randomly pick one when necessary. Something like the following should show you how to do that.
Note, that you can add/subtract from the array at will, which changes the available blocks... This just shows, at the bottom, randomly picking and executing a block 100 times.
You can add/remove block from the appropriate places in your code to keep it local. This should at least get you started...
// If we want to perform some action randomly, then we build an array
// of possibly actions (blocks), and then randomly pick one and execute it.
// Figure out what type of block you want...
typedef void(^ActionBlock)(void);
NSMutableArray *possibleActions = [NSMutableArray array];
[possibleActions addObject:^{
NSLog(#"Doing Action Foo");
}];
[possibleActions addObject:^{
NSLog(#"Doing Action Bar");
}];
[possibleActions addObject:^{
NSLog(#"Doing Action Baz");
}];
[possibleActions addObject:^{
NSLog(#"Doing Action FooBar");
}];
[possibleActions addObject:^{
NSLog(#"Doing Action Blarg");
}];
[possibleActions addObject:^{
NSLog(#"Doing Action Zip");
}];
// Now, when I want to pick an action to perform...
for (int i = 0; i < 100; ++i) {
ActionBlock block = [possibleActions objectAtIndex:arc4random_uniform(possibleActions.count)];
block();
}
EDIT
The line
typedef void(^ActionBlock)(void);
is a typedef, and defines a type for a specific kind of block. Granted, the syntax for functions and blocks is a bit hard to read. Maybe I should take a step back. I hope it does not offend you, and apologize in advance if it is patronizing in any way. It is similar to
typedef int IntType;
typedef void const * OpaqueType;
which are a bit easier to read. The first defines a type, IntType of type integer, and the second defines a type, OpaqueType, of type "pointer-to-const-void." You can then declare variables like...
IntType someInteger;
OpaqueType someOpaqueValue;
Now, in basic C, we can also declare function pointers. Lets say we have some functions...
int functionOne(int arg1, double arg2) {
// do whatever...
}
int functionTwo(int arg1, double arg2) {
// do whatever...
}
You can call that function easily enough...
int result = functionOne(42, 3.14159);
Well, you can also create a variable that points to the function, and you can call it like any other function.
int(*function)(int,double) = functionOne;
int result = function(42, 3.14159); // Calls functionOne
function = functionTwo;
result = function(42, 3.14159); // calls functionTwo
However, that syntax is a bit wearisome to type. So, especially for functions and blocks, we create typedefs. To create a typedef for a function, it's identical to creating a function pointer variable, but you just put the type in the place of the variable name. So...
typedef int(*MyFunction)(int, double);
declares a type that represents a pointer to a function that returns an int, and takes two parameters, and int and a double.
Now, the syntax for blocks is just like for function pointers, except trading a ^ for a *. So, out type...
typedef void(^ActionBlock)(void);
means that ActionBlock is a type that represents a block that returns void and takes no parameters.
So, you can declare variables of type ActionBlock, and assign them to blocks that have void return and no arguments. Which, in the example, is exactly what I did.
Note, that in the code, we create a bunch of blocks like this...
[possibleActions addObject:^{
NSLog(#"Doing Action Foo");
}];
The compiler allows you to leave out stuff that is obvious, so that code really says... Create a block, that takes no arguments, and has return type void, and then put it into the add it to the collection.
We do this multiple times, and then, when ready to invoke the functions, we just iterate over the collection. however, the compiler wants to know how to call the function/block, and all it gets from the collection is an . So, we want to cast the object we get to a type that tells the compiler it is a block that returns void, and takes no arguments.
When we do that, we can then call the function/block. So, let's look at that last piece again (with some comments), and a little bit less compact
for (int i = 0; i < 100; ++i) {
// We have a bunch of blocks stored in the array.
// We want to pick one at random, so we will get a random number
// between [0, size of our array).
uint32_t index = arc4random_uniform(possibleActions.count);
// Now, we have a random index into our array. Get the object in that position.
id randomObject = [possibleActions objectAtIndex:index];
// We have an opaque id type, but we know it's a block. Cast it to a block type.
ActionBlock block = randomObject;
// Now, we have our block, in a type that the compiler will let us invoke.
// Call it like any other function.
block();
}
EDIT
OK, here you go. Create an iVar, NSTimer *_timer. Schedule it in didLoad, and invalidate it in didUnload and dealloc
- (void)dealloc {
[_timer invalidate];
}
typedef void(^ActionBlock)(void);
- (void)callRandomFunction:(NSTimer*)timer {
// Our userInfo is actually our array of blocks
NSArray *actions = timer.userInfo;
ActionBlock block = [actions objectAtIndex:arc4random_uniform(actions.count)];
block();
}
- (void)viewDidLoad
{
[super viewDidLoad];
NSMutableArray *possibleActions = [NSMutableArray array];
// Create the list of possible functions that can be called...
// Now setup a timer that performs callRandomFunction: every second
// Pass the array of blocks as the userInfo of the timer.
_timer = [NSTimer scheduledTimerWithTimeInterval:1.0 target:self selector:#selector(callRandomFunction:) userInfo:possibleActions repeats:YES];
// Whatever else you need in here...
}
- (void)viewDidUnload
{
[_timer invalidate];
// Any other unload stuff...
[super viewDidUnload];
}