anchor.diff:         {{UserId, UserName, _Address} = _User, _Events} <- GameUsers]
     end.
   
  -handle_user_update(UserId, KnownServerTick, CurrentTick, Direction, Games) ->
  +handle_user_update(User, KnownServerTick, CurrentTick, Direction, Games) ->
  +  {UserId, UserName, _Address} = User,
     GameId = get_game_id(UserId, Games),
     case lists:keytake(GameId, 1, Games) of
       false ->
         lager:error("invalid update of user ~p on game ~p", [UserId, GameId]),
         Games;
       {value, {GameId, GameName, GameUsers}, Tail} ->
  +      % Update the direction (if needed)
  +      ok = case get_direction_atom(Direction) of
  +             ignore ->
  +               ok;
  +             DirectionAtom ->
  +               spts_core:turn(GameId, UserName, DirectionAtom)
  +           end,
         % Notify everyone of the move event, also call the function to clear the
         % old events
         NewEvents = [build_moved(UserId, CurrentTick, Direction)],
  -      NewGameUsers = [{User,
  +      NewGameUsers = [{TheUser,
                          clear_messages_older_than(UserId,
  -                                                 User,
  +                                                 TheUser,
                                                    Events,
                                                    KnownServerTick) ++ NewEvents}
  -                      || {User, Events} <- GameUsers],
  +                      || {TheUser, Events} <- GameUsers],
         [{GameId, GameName, NewGameUsers} | Tail]
     end.
   
   handle_get_games(KnownGames) ->
     AllGameNames = [spts_games:id(Game) || Game <- spts_core:all_games()],
  +  lager:critical("all_games: ~p", [spts_core:all_games()]),
  +  lager:critical("AllGameNames: ~p", [AllGameNames]),
     lists:foldl(fun(GameName, Acc) ->
                   NewGame = case lists:keytake(GameName, 2, KnownGames) of
                               false ->
  
positive.code: subscribe_to(GameName) ->
    spts_core:subscribe(GameName, {?MODULE, self()}, self()).
  
  get_id_by_address(Address, Users) ->
    case lists:keyfind(Address, 3, Users) of
      false ->
        undefined;
      {UserId, _Name, Address} ->
        UserId
    end.
  
  update_all_users(CurrentTick, Users) ->
  
negative.code:             NameSize:?UCHAR>>,
            Name]}.
  
  %build_user_left(UserId, Tick) ->
  %  LeftCommand = get_command(left),
  %  {Tick, <<Tick:?USHORT, LeftCommand:?UCHAR, UserId:?UINT>>}.
  
  build_moved(UserId, Tick, Direction) ->
    MovedCommand = get_command(moved),
  