Adventure:    APAMultiplayerLayeredCharacterScene.m    -handleKeyEvent:keyDown:
- (void)handleKeyEvent:(NSEvent *)event keyDown:(BOOL)downOrUp {
    ... (Check whether the key is on the numeric pad)
        switch (keyChar) {
            case NSUpArrowFunctionKey:
                self.defaultPlayer.moveForward = downOrUp;
                break;
            ... (Handle the Down, Left, and Right arrow keys)
        }
    ... (Check non-numeric keys for W, A, S, D, or Space)
}

Adventure:    APAMultiplayerLayeredCharacterScene.m    -update:
- (void)update:(NSTimeInterval)currentTime {
    ...
    for (APAPlayer *player in self.players) {
        ... (Continue if the player is NSNull)
        APAHeroCharacter *hero = player.hero;
        ... (Continue if there's no hero yet, or if the hero is dying)
        if (player.moveForward) {
            [hero move:APAMoveDirectionForward withTimeInterval:timeSinceLast];
        } else if (player.moveBack) {
            [hero move:APAMoveDirectionBack withTimeInterval:timeSinceLast];
        }
        ... (Handle other keys)
    }
}

Adventure:    APAMultiplayerLayeredCharacterScene.m    -touchesBegan:withEvent:
- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
    ... (Return early if we don't have any heroes in play, or if we're already tracking a touch)
    UITouch *touch = [touches anyObject];
    APAPlayer *defaultPlayer = self.defaultPlayer;
 
    defaultPlayer.targetLocation = [touch locationInNode:defaultPlayer.hero.parent];
    BOOL wantsAttack = NO;
    NSArray *nodes = [self nodesAtPoint:[touch locationInNode:self]];
    for (SKNode *node in nodes) {
        if (node.physicsBody.categoryBitMask & (APAColliderTypeCave | APAColliderTypeGoblinOrBoss) {
            wantsAttack = YES;
        }
    }
    defaultPlayer.fireAction = wantsAttack;
    defaultPlayer.moveRequested = !wantsAttack;
    defaultPlayer.movementTouch = touch;

Adventure:    APAMultiplayerLayeredCharacterScene.m    -update:
- (void)update:(NSTimeInterval)currentTime {
    ...
#if TARGET_OS_IPHONE
    APAPlayer *defaultPlayer = self.defaultPlayer;
    if ([self.heroes count] > 0) {
        APAHeroCharacter *hero = defaultPlayer.hero;
        if (defaultPlayer.fireAction) {
            [hero faceTo:defaultPlayer.targetLocation];
        }
        if (defaultPlayer.moveRequested) {
             if (!CGPointEqualToPoint(defaultPlayer.targetLocation, hero.position)) {
                 [hero moveTowards:defaultPlayer.targetLocation withTimeInterval:timeSinceLast];
             } else {
                 defaultPlayer.moveRequested = NO;
             }
        }
    }
#endif
    ...

    for (APAPlayer *player in self.players) {
        ...
        APAHeroCharacter *hero = player.hero;
        ...
        if (player.fireAction) {
            [hero performAttackAction];
        }
        ...
    }
}

Adventure:    APAMultiplayerLayeredCharacterScene.m    -assignPresetController:toIndex:
- (void)assignPresetController:(CGController *)controller toIndex:(NSInteger)playerIndex {
    APAPlayer *player = self.players[playerIndex];
    ... (Check if the player is NSNull and create a new APAPlayer if so)
    if (player.controller && player.controller != controller) {
        [self assignUnknownController:controller];
        return;
    }
    [self configureController:controller forPlayer:player];
}

- (void)configureController:(GCController *)controller forPlayer:(APAPlayer *)player {
    player.controller = controller;
    GCControllerDirectionPadValueChangedHandler dpadMoveHandler = ^(GCControllerDirectionPad *dpad, float xValue, float yValue) {
        float length = hypotf(xValue, yValue);
        if (length > 0.0f) {
            float invLength = 1.0f / length;
            player.heroMoveDirection = CGPointMake(xValue * invLength, yValue * invLength);
        } else {
            player.heroMoveDirection = CGPointZero;
        }
    };
    controller.extendedGamepad.leftThumbstick.valueChangedHandler = dpadMoveHandler;
    controller.gamepad.dpad.valueChangedHandler = dpadMoveHandler;
    GCControllerButtonValueChangedHandler fireButtonHandler = ^(GCControllerButtonInput *button, float value, BOOL pressed) {
        player.fireAction = pressed;
    };
    controller.gamepad.buttonA.valueChangedHandler = fireButtonHandler;
    controller.gamepad.buttonB.valueChangedHandler = fireButtonHandler;
    ... (Add a hero for the player, if necessary)
}

Adventure:    APAMultiplayerLayeredCharacterScene.m    -update:
- (void)update:(NSTimeInterval)currentTime {
    ...
    for (APAPlayer *player in self.players) {
        ...
        APAHeroCharacter *hero = player.hero;
        ...
        if (player.fireAction) {
            [hero performAttackAction];
        }
        CGPoint heroMoveDirection = player.heroMoveDirection;
        if (hypotf(heroMoveDirection.x, heroMoveDirection.y) > 0.0f) {
            [hero moveInDirection:heroMoveDirection withTimeInterval:timeSinceLast];
        }
    }
}

Adeventure:    APACharacter.m    -moveInDirection:withTimeInterval:
- (void)moveInDirection:(CGPoint)direction withTimeInterval:(NSTimeInterval)timeInterval {
    CGPoint curPosition = self.position;
    CGFloat movementSpeed = self.movementSpeed;
    CGFloat dx = movementSpeed * direction.x;
    CGFloat dy = movementSpeed * direction.y;
    CGFloat dt = movementSpeed * kMinTimeInterval;
 
    CGPoint targetPosition = CGPointMake(curPosition.x + dx, curPosition.y + dy);
    CGFloat ang = APA_POLAR_ADJUST(APARadiansBetweenPoints(targetPosition, curPosition));
    self.zRotation = ang;
 
    CGFloat distRemaining = hypotf(dx, dy);
    if (distRemaining < dt) {
        self.position = targetPosition;
    } else {
        self.position = CGPointMake(curPosition.x - sinf(ang)*dt, curPosition.y + cosf(ang)*dt);
    }
    ... (Set up the walk animation)
}

Adventure:    APAChaseAI.m    -updateWithTimeSinceLastUpdate:
- (void)updateWithTimeSinceLastUpdate:(CFTimeInterval)interval {
    APACharacter *ourCharacter = self.character;
    ... (Return early if our enemy character is dying)
    CGPoint position = ourCharacter.position;
    APAMultiplayerLayeredCharacterScene *scene = [ourCharacter characterScene];
    CGFloat closestHeroDistance = MAXFLOAT;
    for (APAHeroCharacter *hero in scene.heroes) {
        CGPoint heroPosition = hero.position;
        CGFloat distance = APADistanceBetweenPoints(position, heroPosition);
        if (distance < kEnemyAlertRadius && distance < closestHeroDistance && !hero.dying) {
            closestHeroDistance = distance;
            self.target = hero;
        }
    }
    APACharacter *target = self.target;
    ... (Return early if there's no target)
    CGPoint heroPosition = target.position;
    CGFloat chaseRadius = self.chaseRadius;
    if (closestHeroDistance > self.maxAlertRadius) {
        self.target = nil;
    } else if (closestHeroDistance > chaseRadius) {
        [self.chararacter moveTowards:heroPosition];
    } else if (closestHeroDistance < chaseRadius) {
        [self.character faceTo:heroPosition];
        [self.character performAttackAction];
    }
}

Adventure:    APASpawnAI.m    -updateWithTimeSinceLastUpdate:
- (void)updateWithTimeSinceLastUpdate:(CFTimeInterval)interval {
    APACave *cave = (id)self.character;
    ... (Return early if our cave is destroyed)
 
    CGFloat closestHeroDistance = kMinimumHeroDistance;
    CGPoint closestHeroPosition = CGPointZero;
    ... (Calculate the distance to, and get the location of, the closest hero)
 
    CGFloat distScale = (closestHeroDistance / kMinimumHeroDistance);
    cave.timeUntilNextGenerate -= interval;
    NSUInteger goblinCount = [cave.activeGoblins count];
    if (goblinCount < 1 || cave.timeUntilNextGenerate <= 0.0f || (distScale < 0.35f && cave.timeUntilNextGenerate > 5.0f)) {
        if (goblinCount < 1 || (!CGPointEqualToPoint(closestHeroPosition, CGPointZero) && [scene closestHeroPosition from:cave.position])) {
            [cave generate];
        }
        cave.timeUntilNextGenerate = (4.0f * distScale);
    }
}