anchor.diff:  -spec handle_cast(any(), state()) -> {noreply, state()}.
   handle_cast({user_update, Address, KnownServerTick, Direction},
               State = #state{users = Users, games = Games, tick = CurrentTick}) ->
  -  UserId = get_id_by_address(Address, Users),
  -  NewGames = handle_user_update(UserId,
  +  User = get_user_by_address(Address, Users),
  +  NewGames = handle_user_update(User,
                                   KnownServerTick, % Last tick the user received
                                   CurrentTick, % The actual tick of the server
                                   Direction, % The movement direction (as a uchar)
  
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:        {{UserId, UserName, _Address} = _User, _Events} <- GameUsers]
    end.
  
  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 = [{TheUser,
                         clear_messages_older_than(UserId,
                                                   TheUser,
                                                   Events,
                                                   KnownServerTick) ++ NewEvents}
                        || {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 ->
  