rework

apps/db/include/table.hrl

@@ -1,50 +1,44 @@
 -ifndef(TABLE_HRL).
 -define(TABLE_HRL, "table.hrl").
 
--include("../../server/include/types.hrl").
 -include_lib("kvs/include/kvs.hrl").
 
--record(game_table, 
-        {
-          ?ITERATOR(feed),
+-record(game_table, {?ITERATOR(feed),
           name,
           gameid,
           trn_id,
           game_type,
-          rounds :: integer() | 'undefined' | '_',
-          sets :: integer() | 'undefined' | '_',
-          owner :: username_type() | '_',
+          rounds,
+          sets,
+          owner,
           timestamp,
-          users = [] :: [username_type()] | '_',
-          users_options = [] :: [username_type()] | '_',
+          users = [],
+          users_options = [],
           game_mode,
           game_options,
           game_speed,
           friends_only,
-          invited_users = [] :: [username_type()] | '_',
-          private :: boolean() | '_',
+          invited_users = [],
+          private :: boolean(),
           feel_lucky = false :: boolean(),
           creator,
           age_limit,
-          groups_only = [] :: [id_type()] | '_',
+          groups_only = [],
           gender_limit,
           location_limit = "",
           paid_only,
-          deny_robots = false :: boolean() | '_',
+          deny_robots = false :: boolean(),
           slang,
           deny_observers,
-          gosterge_finish = false :: boolean() | '_',
+          gosterge_finish = false :: boolean(),
           double_points = 1 :: integer(),
           game_state,
-          game_process :: pid() | '_',
+          game_process :: pid(),
           game_module :: atom(),
-          pointing_rules :: any() | '_', %% #pointing_rule{}
-          pointing_rules_ex :: [] | '_', %% [#pointing_rule{}] - list of additional pointing rules,
-          %% for example IFeelLucky for okey game
-          game_process_monitor :: reference() | '_',
-
+          pointing_rules :: any(),
+          pointing_rules_ex :: [], %% [#pointing_rule{}] - list of additional pointing rules,
+          game_process_monitor :: reference(),
           tournament_type = simple :: simple | paired | paired_lobby | tournament,
-          robots_replacement_allowed = true :: boolean()
-        }).
+          robots_replacement_allowed = true :: boolean()}).
 
 -endif.

apps/face/src/logallow.erl

@@ -3,5 +3,6 @@
 
 log_modules() -> [
     n2o_bullet,
+    game_session,
     okey
 ].

apps/face/src/okey.erl

@@ -7,7 +7,6 @@
 -include_lib("kvs/include/user.hrl").
 
 -define(GAMEID, 1000001).
-%-define(GAMEID, 5000220).
 
 -record(player, {id, label, info, take, discard, history = []}).
 
@@ -89,7 +88,7 @@ body() ->
 event(terminate) -> wf:info(?MODULE,"terminate");
 
 event(init) -> 
-    GamesIds = case game_manager:get_all_games_ids() of
+    GamesIds = case game:get_all_games_ids() of
       [] -> [?GAMEID];
       List -> List end,
     

apps/server/include/basic_types.hrl

@@ -1,11 +1,9 @@
 -ifndef(BASIC_TYPES).
 -define(BASIC_TYPES, true).
--type 'tag'()        :: any().
--type 'PlayerId'()   :: any().
+
+-type 'PlayerId'()   :: any() | 0.
 -type 'GameId'()     :: any().
--type 'ChatId'()     :: any().
 -type 'SocialActionEnum'() :: integer().
-%-type proplist()     :: list(tuple(atom(), any())).
 -type 'MonitorRef'() :: reference().
 
 -record('PlayerInfo', {

apps/server/include/requests.hrl

@@ -1,5 +1,4 @@
 -include("basic_types.hrl").
--include("types.hrl").
 
 -record(session_attach, {token}).
 -record(login, {username, password}).
@@ -7,74 +6,17 @@
 -record(join_game, {game}).
 -record(get_game_info, {game}).
 -record(get_player_info, {player_id :: 'PlayerId'() | 0}).
--record(get_player_stats, {player_id :: 'PlayerId'() | 0, game_type :: binary()}).
+-record(get_player_stats, {player_id :: 'PlayerId'() | 0, game_type}).
 -record(subscribe_player_rels, {players :: list()}).
 -record(unsubscribe_player_rels, {players :: list()}).
--record(chat, {chat_id :: 'GameId'(),message :: string()}).
--record(game_action, { game :: 'GameId'(), action :: any(), args = [] :: proplist()}).
-
--record(game_event, {
-          game      :: 'GameId'(),
-          event     :: any(),
-          args = [] :: proplist()
-         }).
-
--record(dummy_player_change, {
-          player :: 'PlayerId'()
-         }).
-
--record(chat_msg, {
-          chat        :: 'GameId'(),
-          content     :: string(),
-          author_id   :: 'PlayerId'(),
-          author_nick :: string()
-         }).
-
--record(social_action, {
-          game :: 'GameId'(),
-          type :: 'SocialActionEnum'(),
-          recipient :: 'PlayerId'() | null
-         }).
-
--record(social_action_msg, {
-          type :: 'SocialActionEnum'(),
-          game :: 'GameId'(),
-          initiator :: 'PlayerId'(),
-          recipient :: 'PlayerId'() | null
-         }).
-
--record(pause_game, {
-          table_id :: integer(),
-          game    :: 'GameId'(),
-          action  :: string()
-         }).
-
--record(game_paused, {
-          table_id :: integer(),
-          game    :: 'GameId'(),
-          action  :: string(),
-          who     :: 'PlayerId'(),
-          retries :: integer()
-         }).
-
--record(disconnect, {
-          reason_id = null :: null | string(),
-          reason = null :: null | string()
-         }).
-
-%% packet as game_event:
--record(player_left, {
-          player :: 'PlayerId'(),
-          bot_replaced = false :: boolean(),    %% will be replaced by bot?
-          human_replaced = false :: boolean(),  %% will be replaced by human?
-          replacement = null :: 'PlayerId'() | null %% id of replacement player/bot
-         }).
-
--record('TableInfo', {
-          chat    = []      :: list(any()),
-          viewers = []      :: list('PlayerId'()),
-          players = []      :: list('PlayerId'()),
-          game              :: atom(),
-          game_status       :: atom()
-         }).
-
+-record(chat,          {chat_id :: 'GameId'(),message :: string()}).
+-record(game_action,   { game :: 'GameId'(), action :: any(), args = []}).
+
+-record(game_event,    {game :: 'GameId'(), event, args = [] }).
+-record(chat_msg,      {chat :: 'GameId'(), content, author_id::'PlayerId'(),author_nick::string() }).
+-record(social_action, {game :: 'GameId'(),type,recipient::'PlayerId'()}).
+-record(social_action_msg, {type,game::'GameId'(),initiator::'PlayerId'(),recipient::'PlayerId'()}).
+-record(pause_game, {table_id :: integer(),game :: 'GameId'(),action}).
+-record(game_paused, {table_id :: integer(), game :: 'GameId'(),action,who :: 'PlayerId'(),retries}).
+-record(disconnect, {reason_id,reason}).
+-record(player_left, {player :: 'PlayerId'(),human_replaced=false,replacement::'PlayerId'()}).

apps/server/include/types.hrl

@@ -1,10 +0,0 @@
--ifndef(TYPES_HRL).
--define(TYPES_HRL, true).
-
--type username_type() :: string().
--type id_type() :: integer().
--type user_state() :: 'ok' | 'not_verified' | 'banned'.
--type proplist() :: [proplists:property()].
-
-
--endif.

apps/server/src/game.erl

@@ -4,8 +4,8 @@
 -include_lib("server/include/requests.hrl").
 -include_lib("db/include/table.hrl").
 -include_lib("db/include/tournaments.hrl").
--include_lib("stdlib/include/qlc.hrl").
 -include_lib("db/include/scoring.hrl").
+-include_lib("stdlib/include/qlc.hrl").
 
 online() -> [X||X<-qlc:e(gproc:table()),element(1,X)=={p,l,broadcast}].
 
@@ -17,7 +17,7 @@ destroy_game(Pid,Sup) -> game_sup:stop_game(Sup,Pid).
 gen_game_id() ->
     PoolNum = wf:config(nsx_idgen,game_pool,5000000) div 1000000,
     PoolNumStr = integer_to_list(PoolNum),
-    PoolNum*1000000 + 200 + kvs:next_id("game_table", 1).
+    PoolNum*1000000 + 200 + kvs:next_id(game_table, 1).
      %% 200 is reserved for lucky games and for already created games
 
 create_game(GameId, GameFSM, Params) ->
@@ -33,7 +33,7 @@ rank_table(GameId) ->
     end.
 
 get_lucky_pid(Sup) ->
-    [X]=game_manager:get_lucky_table(Sup),
+    [X]=game:get_lucky_table(Sup),
     X#game_table.game_process.
 get_relay_pid(GameId) -> case get_tables(GameId) of [] -> undefined;
     [#game_table{game_process = P} | _] -> gas:info(?MODULE,"GameRelay: ~p",[P]), P end.
@@ -109,7 +109,7 @@ get_tournament(TrnId) ->
 
 %% stress_test(NumberOfRooms) ->
 %%     OkeyPlayers = [begin
-%%           {ok,GameId,A} = game_manager:create_table(game_okey,[{table_name,"okey maxim and alice + 2 robots"},
+%%           {ok,GameId,A} = game:create_table(game_okey,[{table_name,"okey maxim and alice + 2 robots"},
 %%                           {speed,normal},
 %%                           {rounds,80},
 %%                           {sets,1},

apps/server/src/game_session.erl

@@ -309,7 +309,7 @@ handle_client_request(#join_game{game = GameId}, _From,
             {reply, {error, already_joined}, State};
         false ->
             gas:info(?MODULE,"Requesting main relay info...",[]),
-            case game_manager:get_relay_mod_pid(GameId) of
+            case game:get_relay_mod_pid(GameId) of
                 {FLMod, FLPid} ->
                     gas:info(?MODULE,"Found the game: ~p. Trying to register...",[{FLMod, FLPid}]),
                     case FLMod:reg(FLPid, User) of
@@ -320,8 +320,7 @@ handle_client_request(#join_game{game = GameId}, _From,
                             Part = #participation{ref = Ref, game_id = GameId, reg_num = RegNum,
                                                   rel_module = RMod, rel_pid = RPid,
                                                   tab_module = TMod, tab_pid = TPid, role = player},
-                            Res = #'TableInfo'{}, % FIXME: The client should accept 'ok' responce
-                            {reply, Res, State#state{games = [Part | State#state.games]}};
+                            {reply, ok, State#state{games = [Part | State#state.games]}};
                         {error, finished} ->
                             gas:info(?MODULE,"The game is finished: ~p.",[GameId]),
                             ok = send_message_to_player(RPC, #disconnect{reason_id = <<"gameFinished">>,
@@ -403,7 +402,7 @@ handle_relay_kick({rejoin, GameId}, _SubscrId,
                   #state{user = User, games = Games, rpc = RPC} = State) ->
     gas:info(?MODULE,"Requesting main relay info...",[]),
     UserId = User#'PlayerInfo'.id,
-    case game_manager:get_relay_mod_pid(GameId) of
+    case game:get_relay_mod_pid(GameId) of
         {FLMod, FLPid} ->
             gas:info(?MODULE,"Found the game: ~p. Trying to register...",[{FLMod, FLPid}]),
             case FLMod:reg(FLPid, User) of

apps/server/src/game_sup.erl

@@ -21,7 +21,6 @@ init([]) ->
     AuthServer = {auth_server, {auth_server, start_link, []}, Restart, Shutdown, worker, [auth_server]},
     GameLog = {game_log, {game_log, start_link, []}, Restart, Shutdown, worker, [game_log]},
     GameStats = {game_stats, {game_stats, start_link, []}, Restart, Shutdown, worker, [game_stats]},
-    %GameManager = {game_manager, {game_manager, start_link, []}, Restart, Shutdown, worker, [game_manager]},
     TavlaSup = {tavla_sup, {tavla_sup, start_link, []}, Restart, Shutdown, supervisor, [tavla_sup]},
     OkeySup = {okey_sup, {okey_sup, start_link, []}, Restart, Shutdown, supervisor, [okey_sup]},
     LuckySup = {lucky_sup, {lucky_sup, start_link, []}, Restart, Shutdown, supervisor, [lucky_sup]},

apps/server/src/lib/known_records.erl

@@ -1,6 +1,5 @@
 -module(known_records).
 
--include("types.hrl").
 -include("requests.hrl").
 -include("game_okey.hrl").
 -include("game_tavla.hrl").
@@ -9,12 +8,10 @@
 
 -record(unknown_data,{}).
 
-fields(T) when is_tuple(T) ->  fields(element(1, T));
-
+fields(T) when is_tuple(T) ->      fields(element(1, T));
 fields(game_action) ->             record_info(fields, game_action);
 fields(join_game) ->               record_info(fields, join_game);
 fields(get_game_info) ->           record_info(fields, get_game_info);
-fields(dummy_player_change) ->     record_info(fields, dummy_player_change);
 fields(login) ->                   record_info(fields, login);
 fields(session_attach) ->          record_info(fields, session_attach);
 fields(logout) ->                  record_info(fields, logout);
@@ -23,7 +20,6 @@ fields(get_player_stats) ->        record_info(fields, get_player_stats);
 fields(subscribe_player_rels) ->   record_info(fields, subscribe_player_rels);
 fields(unsubscribe_player_rels) -> record_info(fields, unsubscribe_player_rels);
 fields('PlayerInfo') ->            record_info(fields, 'PlayerInfo');
-fields('TableInfo') ->             record_info(fields, 'TableInfo');
 fields(game_event) ->              record_info(fields, game_event);
 fields(chat_msg) ->                record_info(fields, chat_msg);
 fields(social_action) ->           record_info(fields, social_action);
@@ -51,7 +47,6 @@ fields(okey_i_have_8_tashes) ->    record_info(fields, okey_i_have_8_tashes);
 fields(okey_challenge) ->          record_info(fields, okey_challenge);
 fields(okey_game_info) ->          record_info(fields, okey_game_info);
 fields('OkeyTimeouts') ->          record_info(fields, 'OkeyTimeouts');
-%%fields('TavlaTimeouts') ->         record_info(fields, 'TavlaTimeouts');
 fields(okey_game_started) ->       record_info(fields, okey_game_started);
 fields(okey_game_player_state) ->  record_info(fields, okey_game_player_state);
 fields(okey_player_ready) ->       record_info(fields, okey_player_ready);
@@ -68,11 +63,9 @@ fields(okey_series_ended) ->       record_info(fields, okey_series_ended);
 fields(okey_turn_result) ->        record_info(fields, okey_turn_result);
 fields(okey_turn_record) ->        record_info(fields, okey_turn_record);
 fields(okey_playing_tables) ->     record_info(fields, okey_playing_tables);
-
 fields('TavlaAtomicMoveServer') -> record_info(fields, 'TavlaAtomicMoveServer');
 fields(tavla_checkers) ->          record_info(fields, tavla_checkers);
 fields(tavla_game_info) ->         record_info(fields, tavla_game_info);
-%%fields('TavlaPlayer') ->           record_info(fields, 'TavlaPlayer');
 fields('TavlaPlayerScore') ->      record_info(fields, 'TavlaPlayerScore');
 fields(tavla_color_info) ->        record_info(fields, tavla_color_info);
 fields('TavlaGameResults') ->      record_info(fields, 'TavlaGameResults');
@@ -85,9 +78,6 @@ fields(tavla_next_turn) ->         record_info(fields, tavla_next_turn);
 fields(tavla_turn_timeout) ->      record_info(fields, tavla_turn_timeout);
 fields(tavla_rolls) ->             record_info(fields, tavla_rolls);
 fields(tavla_moves) ->             record_info(fields, tavla_moves);
-%%fields(tavla_vidoes) ->            record_info(fields, tavla_vidoes);
-%%fields(tavla_accepts) ->           record_info(fields, tavla_accepts);
-%%fields(tavla_timeouts) ->          record_info(fields, tavla_timeouts);
 fields(tavla_game_ended) ->        record_info(fields, tavla_game_ended);
 fields(tavla_series_ended) ->      record_info(fields, tavla_series_ended);
 fields(tavla_ready) ->             record_info(fields, tavla_ready);
@@ -103,9 +93,7 @@ fields(tavla_surrender) ->         record_info(fields, tavla_surrender);
 fields(tavla_surrender_answer) ->  record_info(fields, tavla_surrender_answer);
 fields(tavla_surrender_request) -> record_info(fields, tavla_surrender_request);
 fields(tavla_ack) ->               record_info(fields, tavla_ack);
-%%fields(tavla_board) ->             record_info(fields, tavla_board);
 fields(tavla_accept_timeout) ->    record_info(fields, tavla_accept_timeout);
 fields(tavla_tour_result) ->       record_info(fields, tavla_tour_result);
 fields(tavla_tour_record) ->       record_info(fields, tavla_tour_record);
-
-fields(_) -> record_info(fields,unknown_data).
+fields(_) ->                       record_info(fields, unknown_data).

apps/server/src/modules/lucky.erl

@@ -764,9 +764,11 @@ get_param(ParamId, Params) ->
 add_points_to_accounts(Points, GameId, GameType, GameMode) ->
     TI = #ti_game_event{game_name = GameType, game_mode = GameMode,
                         id = GameId, double_points = 1,
-                        type = game_end, tournament_type = ?TOURNAMENT_TYPE},    
+                        type = game_end, tournament_type = lucky},    
     [begin
          if GamePoints =/= 0 ->
+         
+                %{UserId,game_points,GameType,GameMode,TournamentType}
 
                  kvs:add(#transaction{
                             id=kvs:next_id(transaction,1),

apps/server/src/okey/game_okey_table.erl

@@ -330,23 +330,23 @@ handle_parent_message(show_round_result, StateName,
     gas:info(?MODULE,"OKEY_NG_TABLE_TRN <~p,~p> RoundScore: ~p Total score: ~p.", [GameId, TableId, RoundScore, TotalScore]),
     Msg = case FinishInfo of
               {win_reveal, Revealer, WrongRejects, _RevealWithColor, _RevealWithOkey, _RevealWithPairs} ->
-                  create_okey_round_ended_reveal(Revealer, true, WrongRejects, RoundScore,
-                                                 TotalScore, AchsPoints, StateData);
+                  create_okey_round_ended_reveal(
+                    Revealer, true, WrongRejects, RoundScore, TotalScore, AchsPoints, StateData);
               {fail_reveal, Revealer} ->
-                  create_okey_round_ended_reveal(Revealer, false, [], RoundScore,
-                                                 TotalScore, AchsPoints, StateData);
+                  create_okey_round_ended_reveal(
+                    Revealer, false, [], RoundScore, TotalScore, AchsPoints, StateData);
               tashes_out ->
-                  create_okey_round_ended_tashes_out(RoundScore, TotalScore, AchsPoints,
-                                                     StateData);
+                  create_okey_round_ended_tashes_out(
+                    RoundScore, TotalScore, AchsPoints, StateData);
               timeout ->
-                  create_okey_round_ended_tashes_out(RoundScore, TotalScore, AchsPoints,
-                                                     StateData);
+                  create_okey_round_ended_tashes_out(
+                    RoundScore, TotalScore, AchsPoints, StateData);
               set_timeout ->
-                  create_okey_round_ended_tashes_out(RoundScore, TotalScore, AchsPoints,
-                                                     StateData);
+                  create_okey_round_ended_tashes_out(
+                    RoundScore, TotalScore, AchsPoints, StateData);
               {gosterge_finish, Winner} ->
-                  create_okey_round_ended_gosterge_finish(Winner, RoundScore, TotalScore,
-                                                          AchsPoints, StateData)
+                  create_okey_round_ended_gosterge_finish(
+                    Winner, RoundScore, TotalScore, AchsPoints, StateData)
           end,
     relay_publish_ge(Relay, Msg, StateData),
     {next_state, StateName, StateData#okey_state{}};
@@ -1228,8 +1228,7 @@ create_player_left(SeatNum, UserInfo, Players) ->
     #player{user_id = OldUserId} = get_player_by_seat_num(SeatNum, Players),
     IsBot = UserInfo#'PlayerInfo'.robot,
     #player_left{player = OldUserId,
-                 human_replaced = not IsBot, %% XXX WTF?
-                 bot_replaced = IsBot,       %% XXX WTF?
+                 human_replaced = not IsBot,
                  replacement = UserInfo}.
 
 
@@ -1271,6 +1270,36 @@ create_okey_tile_discarded(SeatNum, Tash, Timeouted, Players) ->
                          tile = tash_to_ext(Tash),
                          timeouted = Timeouted}.
 
+% OKEY GAME RESULTS
+
+game_results(
+    Reason,
+    Revealer, RevealerWin, WrongRejects, RoundScore,
+    TotalScore, PlayersAchsPoints,
+    State=#okey_state{
+        game_id=GameId,
+        players=Players}) ->
+
+    [begin
+
+        #player{user_id = UserId} = get_player_by_seat_num(SeatNum, Players),
+        IsWinner = if SeatNum == Revealer -> RevealerWin; true -> not RevealerWin end,
+        GoodShot = if SeatNum == Revealer -> RevealerWin; true -> not lists:member(SeatNum, WrongRejects) end,
+        {_, PlayerScoreTotal} = lists:keyfind(SeatNum, 1, TotalScore),
+        {_, PlayerScoreRound} = lists:keyfind(SeatNum, 1, RoundScore),
+
+        player_result(Reason,GameId,UserId,IsWinner,PlayerScoreRound)
+
+    end || SeatNum <- lists:seq(1, ?SEATS_NUM)],
+
+    ok.
+
+player_result(Reason,GameId,UserId,IsWinner,PlayerScoreRound) ->
+
+    
+
+    ok.
+
 create_okey_round_ended_reveal(Revealer, RevealerWin, WrongRejects, RoundScore, TotalScore, PlayersAchsPoints,
                         #okey_state{players = Players}) ->
     PlResults = [begin

apps/server/src/okey/test_okey.erl

@@ -185,7 +185,7 @@ start_test_game_t(MultiOwner, CreateMode, RevealMode) ->
 
             Robots = [robot,robot,robot],
             Humans = [<<"paul">>],%<<"radistao">>, <<"paul">>],
-            {ok, GameId, _A} = game_manager:create_table(game_okey, [{sets,2}, {rounds,20},{game_mode,color}], Robots ++ Humans),
+            {ok, GameId, _A} = game:create_table(game_okey, [{sets,2}, {rounds,20},{game_mode,color}], Robots ++ Humans),
 
 	    gas:info(?MODULE,"created table for Okey Game: gameid ~p",[{GameId,_A}]),
 
@@ -200,7 +200,7 @@ start_test_game_t(MultiOwner, CreateMode, RevealMode) ->
 
         join_game ->
 
-            {ok, GameId, _} = game_manager:create_table(game_okey, [{game_mode, color}, {sets, 2}, {rounds, 2}], Ids),
+            {ok, GameId, _} = game:create_table(game_okey, [{game_mode, color}, {sets, 2}, {rounds, 2}], Ids),
 
             Orders = [],
 
@@ -212,7 +212,7 @@ start_test_game_t(MultiOwner, CreateMode, RevealMode) ->
 
         join_game_new ->
 
-            {ok, GameId, _} = game_manager:create_table(game_okey, [{game_mode, color}, {sets, 2}, {rounds, 2}], Ids),
+            {ok, GameId, _} = game:create_table(game_okey, [{game_mode, color}, {sets, 2}, {rounds, 2}], Ids),
 
             Clients = [ proc_lib:spawn_link(fun() -> 
 			         timer:sleep(crypto:rand_uniform(0, 300)),
@@ -222,7 +222,7 @@ start_test_game_t(MultiOwner, CreateMode, RevealMode) ->
             Orders = [#bo{pid = 2, event = game_ended, event_no = 2, order = stop}];
 
         join_game_countdown ->
-            {ok, GameId, _} = game_manager:create_table(game_okey, [{game_mode, countdown}, {gosterge_finish, true}], Ids),
+            {ok, GameId, _} = game:create_table(game_okey, [{game_mode, countdown}, {gosterge_finish, true}], Ids),
             Orders = [#bo{pid = 2, event = game_ended, event_no = 10, order = stop}],
             Clients = [ proc_lib:spawn_link(fun() -> 
 			      timer:sleep(crypto:rand_uniform(0, 300)),
@@ -230,11 +230,11 @@ start_test_game_t(MultiOwner, CreateMode, RevealMode) ->
 
         join_game_observer ->
 
-             L = [{true, #'TableInfo'{}}, {false, {error, <<"this_game_is_private">>}}],
+             L = [{true, ok}, {false, {error, <<"this_game_is_private">>}}],
 
             lists:map(fun({Setting, ExpectedAnswer}) ->
 
-                    {ok, GameId, _} = game_manager:create_table(game_okey, [{observers, Setting}, 
+                    {ok, GameId, _} = game:create_table(game_okey, [{observers, Setting}, 
 								{game_mode, standard}, {sets, 1}, {rounds, 1}], Ids),
 
                     Bots = [ proc_lib:spawn_link(fun() -> 
@@ -259,7 +259,7 @@ start_test_game_t(MultiOwner, CreateMode, RevealMode) ->
         test_social_actions ->
             SenderFun = fun send_and_receive_social_action/2,
             ReceiverFun = fun receive_social_action/3,
-            {ok, GameId, _} = game_manager:create_table(game_okey, [{game_mode, countdown}, {gosterge_finish, true}], Ids),
+            {ok, GameId, _} = game:create_table(game_okey, [{game_mode, countdown}, {gosterge_finish, true}], Ids),
             A = #bo{pid = 1, event = got_hand, event_no = 1, order = {do_and_continue, SenderFun, [<<"paul">>]}},
             B = #bo{pid = 2, event = got_hand, event_no = 1, order = {do_and_continue, ReceiverFun, [<<"radistao">>, <<"paul">>]}},
             C = #bo{pid = 3, event = got_hand, event_no = 1, order = {do_and_continue, ReceiverFun, [<<"radistao">>, <<"paul">>]}},
@@ -282,8 +282,7 @@ init_with_join_game(Owner, Host, Port, GameId, OwnId, Rematch, Mode) ->
     log(connected),
     Stats = ?TCM:call_rpc(S1, #get_player_stats{game_type = <<"okey">>, player_id = Id}) ,
     #'PlayerOkeyStats'{} = Stats,
-    #'TableInfo'{game = Atom} = ?TCM:call_rpc(S1, #join_game{game = GameId}) ,
-    <<"okey">> = Atom,
+    ok = ?TCM:call_rpc(S1, #join_game{game = GameId}) ,
     State = #state{conn = S1, gid = GameId, uid = Id, acker_fun = standard_acker(Owner)},
     play_set(State, Rematch),
     log(finished),

apps/server/src/sup/okey_sup.erl

@@ -32,7 +32,7 @@ okey_standalone_specs(GamesNum, VirtUsersPerTable) ->
            [];
        true ->
            F = fun(_) ->
-                       GameId = game_manager:gen_game_id(),
+                       GameId = game:gen_game_id(),
                        GameName = "Okey/Crowd game - " ++ erlang:integer_to_list(GameId),
                        Users = nsg_crowd_lib:random_users(VirtUsersPerTable, VirtualUsers),
 %%%                      Users = [robot, robot, robot],

apps/server/src/sup/tavla_sup.erl

@@ -32,7 +32,7 @@ tavla_standalone_specs(GamesNum, VirtUsersPerTable) ->
            [];
        true ->
            F = fun(_) ->
-                       GameId = game_manager:gen_game_id(),
+                       GameId = game:gen_game_id(),
                        GameName = "Tavla/Crowd game: " ++ erlang:integer_to_list(GameId),
                        Users = nsg_crowd_lib:random_users(VirtUsersPerTable, VirtualUsers),
 %%%                    Users = [robot],

apps/server/src/tavla/game_tavla_bot.erl

@@ -131,7 +131,7 @@ robot_init_loop(State) -> % receiving messages from relay
     receive
         join_game ->
             case call_rpc(S, #join_game{game = GameId}) of
-                #'TableInfo'{game = _Atom} -> tavla_client_loop(State);
+                ok -> tavla_client_loop(State);
                 _Err -> gas:info(?MODULE,"ID: ~p failed take with msg ~p", [Id, _Err]),
                         erlang:error(robot_cant_join_game)
             end

apps/server/src/tavla/game_tavla_ng_table.erl

@@ -1402,8 +1402,7 @@ create_player_left(SeatNum, UserInfo, Players) ->
     #player{user_id = OldUserId} = get_player_by_seat_num(SeatNum, Players),
     IsBot = UserInfo#'PlayerInfo'.robot,
     #player_left{player = OldUserId,
-                 human_replaced = not IsBot, %% XXX WTF?
-                 bot_replaced = IsBot,       %% XXX WTF?
+                 human_replaced = not IsBot,
                  replacement = UserInfo}.
 
 

apps/server/src/tavla/test_tavla.erl

@@ -45,7 +45,7 @@ fire_starter(MultiOwner, CreateMode, RevealMode) ->
          join_game_humans ->
 
             Humans = [<<"maxim">>,<<"alice">>], % see authored users in auth_server.erl
-            {ok, GameId, _A} = game_manager:create_table(game_tavla, [{deny_robots,true},{rounds, 1}], Humans),
+            {ok, GameId, _A} = game:create_table(game_tavla, [{deny_robots,true},{rounds, 1}], Humans),
             gas:info(?MODULE,"created table for Tavla Game: gameid ~p",[{GameId,_A}]),
             Clients = [ proc_lib:spawn_link(fun() -> 
                                  timer:sleep(crypto:rand_uniform(0, 10)),
@@ -69,7 +69,7 @@ attach_and_join(Owner, Host, Port, GameId, OwnId, Rematch, Mode) ->
     end,
     #'PlayerInfo'{id = Id} = ?TCM:call_rpc(S1, #session_attach{token = TT}) ,
     log(connected),
-    #'TableInfo'{game = _Atom} = ?TCM:call_rpc(S1, #join_game{game = GameId}) ,
+    ok = ?TCM:call_rpc(S1, #join_game{game = GameId}) ,
     State = #state{conn = S1, gid = GameId, uid = Id, acker_fun = standard_acker(Owner)},
     play_round(State, Rematch),
     log(finished),