[cellular-automata.git] / 001 / src / life_time.erl

-module(life_time).
-behaviour(gen_server).


%% API
-export([start_link/3
        ,report_state/3
        ]).

%% Callbacks
-export([init/1
        ,handle_call/3
        ,handle_cast/2
        ,handle_info/2
        ,terminate/2
        ,code_change/3
        ]).


-define(INTERVAL, 100).  % In milliseconds

-define(CHAR_DEAD,   32).  % " "
-define(CHAR_ALIVE, 111).  % "o"
-define(CHAR_BAR,    45).  % "-"


-record(state, {x               :: integer()
               ,y               :: integer()
               ,cells           :: list(atom())
               ,num_cells       :: integer()
               ,num_dead        :: integer()
               ,num_alive       :: integer()
               ,state_pairs     :: list(tuple(integer(), integer())) | []
               ,replies_pending :: integer()
               ,gen_id          :: integer()
               }).


%% ============================================================================
%% API
%% ============================================================================

start_link(X, Y, Cells) ->
    ServerName = {local, ?MODULE},
    Args = [X, Y, Cells],
    Opts = [],
    gen_server:start_link(ServerName, ?MODULE, Args, Opts).


report_state(CellID, GenID, CellState) ->
    gen_server:cast(?MODULE, {report_state, {CellID, GenID, CellState}}).


%% ============================================================================
%% Callbacks (unused)
%% ============================================================================

handle_call(_Msg, _From, State)  -> {reply, ok, State}.
handle_info(_Msg, State)         -> {noreply, State}.
code_change(_Old, State, _Other) -> {ok, State}.
terminate(_Reason, State)        -> {ok, State}.


%% ============================================================================
%% Callbacks
%% ============================================================================

init([X, Y, Cells]) ->
    State = #state{x               = X
                  ,y               = Y
                  ,cells           = Cells
                  ,num_cells       = length(Cells)
                  ,state_pairs     = []
                  ,replies_pending = 0
                  ,gen_id          = 0
                  },
    ok = schedule_next_gen(),
    {ok, State}.


handle_cast(next_gen,
    #state{cells=Cells
          ,num_cells=NumCells
          ,state_pairs=[]
          ,gen_id=GenID
          }=State) ->

    NewGenID = GenID + 1,
    ok = life_lib:cast_one2all(Cells, {next_gen, NewGenID}),
    NewState = State#state{replies_pending=NumCells
                          ,gen_id=NewGenID
                          ,num_dead=0
                          ,num_alive=0
                          },
    {noreply, NewState};

handle_cast({report_state, {CellID, GenID, CellState}},
    #state{x=X
          ,y=Y
          ,num_dead=NDead
          ,num_alive=NAlive
          ,state_pairs=StatePairs
          ,replies_pending=RepliesPending
          ,gen_id=GenID
          ,num_cells=NumCells
          }=State) ->

    NewStatePairs = [{CellID, CellState} | StatePairs],
    NewRepliesPending = RepliesPending - 1,
    {NewNDead, NewNAlive} = increment_dead_or_alive(CellState, NDead, NAlive),
    NewState = State#state{replies_pending=NewRepliesPending
                          ,num_dead=NewNDead
                          ,num_alive=NewNAlive
                          },

    case NewRepliesPending of
        0 ->
            SortedStatePairs = lists:sort(
                fun({A, _}, {B, _}) -> A < B end,
                NewStatePairs
            ),
            StateChars = [state_to_char(S) || {_, S} <- SortedStatePairs],

            ok = io:format(
                "X: ~b Y: ~b CELLS: ~b DEAD: ~b ALIVE: ~b GENERATION: ~b~n",
                [X, Y, NumCells, NewNDead, NewNAlive, GenID]
            ),
            ok = do_print_bar(X),
            ok = do_print_state_chars(X, StateChars),
            ok = timer:sleep(?INTERVAL),
            ok = schedule_next_gen(),
            {noreply, NewState#state{state_pairs=[]}};

        _N ->
            {noreply, NewState#state{state_pairs=NewStatePairs}}
    end;

handle_cast(_Msg, State) ->
    {noreply, State}.


%% ============================================================================
%% Internal
%% ============================================================================

increment_dead_or_alive(0, NDead, NAlive) -> {NDead + 1, NAlive};
increment_dead_or_alive(1, NDead, NAlive) -> {NDead, NAlive + 1}.


schedule_next_gen() ->
    ok = gen_server:cast(?MODULE, next_gen).


state_to_char(0) -> ?CHAR_DEAD;
state_to_char(1) -> ?CHAR_ALIVE.


do_print_state_chars(_, []) -> ok;
do_print_state_chars(X, Chars) ->
    {XChars, RestChars} = lists:split(X, Chars),
    ok = io:format([XChars, $\n]),
    do_print_state_chars(X, RestChars).


do_print_bar(X) ->
    io:format("~s~n", [[?CHAR_BAR || _ <- lists:seq(1, X - 1)]]).
Commit	Line	Data
	1	-module(life_time).
	2	-behaviour(gen_server).
	3
	4
	5	%% API
	6	-export([start_link/3
	7	,report_state/3
	8	]).
	9
	10	%% Callbacks
	11	-export([init/1
	12	,handle_call/3
	13	,handle_cast/2
	14	,handle_info/2
	15	,terminate/2
	16	,code_change/3
	17	]).
	18
	19
	20	-define(INTERVAL, 100). % In milliseconds
	21
	22	-define(CHAR_DEAD, 32). % " "
	23	-define(CHAR_ALIVE, 111). % "o"
	24	-define(CHAR_BAR, 45). % "-"
	25
	26
	27	-record(state, {x :: integer()
	28	,y :: integer()
	29	,cells :: list(atom())
	30	,num_cells :: integer()
	31	,num_dead :: integer()
	32	,num_alive :: integer()
	33	,state_pairs :: list(tuple(integer(), integer())) \| []
	34	,replies_pending :: integer()
	35	,gen_id :: integer()
	36	}).
	37
	38
	39	%% ============================================================================
	40	%% API
	41	%% ============================================================================
	42
	43	start_link(X, Y, Cells) ->
	44	ServerName = {local, ?MODULE},
	45	Args = [X, Y, Cells],
	46	Opts = [],
	47	gen_server:start_link(ServerName, ?MODULE, Args, Opts).
	48
	49
	50	report_state(CellID, GenID, CellState) ->
	51	gen_server:cast(?MODULE, {report_state, {CellID, GenID, CellState}}).
	52
	53
	54	%% ============================================================================
	55	%% Callbacks (unused)
	56	%% ============================================================================
	57
	58	handle_call(_Msg, _From, State) -> {reply, ok, State}.
	59	handle_info(_Msg, State) -> {noreply, State}.
	60	code_change(_Old, State, _Other) -> {ok, State}.
	61	terminate(_Reason, State) -> {ok, State}.
	62
	63
	64	%% ============================================================================
	65	%% Callbacks
	66	%% ============================================================================
	67
	68	init([X, Y, Cells]) ->
	69	State = #state{x = X
	70	,y = Y
	71	,cells = Cells
	72	,num_cells = length(Cells)
	73	,state_pairs = []
	74	,replies_pending = 0
	75	,gen_id = 0
	76	},
	77	ok = schedule_next_gen(),
	78	{ok, State}.
	79
	80
	81	handle_cast(next_gen,
	82	#state{cells=Cells
	83	,num_cells=NumCells
	84	,state_pairs=[]
	85	,gen_id=GenID
	86	}=State) ->
	87
	88	NewGenID = GenID + 1,
	89	ok = life_lib:cast_one2all(Cells, {next_gen, NewGenID}),
	90	NewState = State#state{replies_pending=NumCells
	91	,gen_id=NewGenID
	92	,num_dead=0
	93	,num_alive=0
	94	},
	95	{noreply, NewState};
	96
	97	handle_cast({report_state, {CellID, GenID, CellState}},
	98	#state{x=X
	99	,y=Y
	100	,num_dead=NDead
	101	,num_alive=NAlive
	102	,state_pairs=StatePairs
	103	,replies_pending=RepliesPending
	104	,gen_id=GenID
	105	,num_cells=NumCells
	106	}=State) ->
	107
	108	NewStatePairs = [{CellID, CellState} \| StatePairs],
	109	NewRepliesPending = RepliesPending - 1,
	110	{NewNDead, NewNAlive} = increment_dead_or_alive(CellState, NDead, NAlive),
	111	NewState = State#state{replies_pending=NewRepliesPending
	112	,num_dead=NewNDead
	113	,num_alive=NewNAlive
	114	},
	115
	116	case NewRepliesPending of
	117	0 ->
	118	SortedStatePairs = lists:sort(
	119	fun({A, _}, {B, _}) -> A < B end,
	120	NewStatePairs
	121	),
	122	StateChars = [state_to_char(S) \|\| {_, S} <- SortedStatePairs],
	123
	124	ok = io:format(
	125	"X: ~b Y: ~b CELLS: ~b DEAD: ~b ALIVE: ~b GENERATION: ~b~n",
	126	[X, Y, NumCells, NewNDead, NewNAlive, GenID]
	127	),
	128	ok = do_print_bar(X),
	129	ok = do_print_state_chars(X, StateChars),
	130	ok = timer:sleep(?INTERVAL),
	131	ok = schedule_next_gen(),
	132	{noreply, NewState#state{state_pairs=[]}};
	133
	134	_N ->
	135	{noreply, NewState#state{state_pairs=NewStatePairs}}
	136	end;
	137
	138	handle_cast(_Msg, State) ->
	139	{noreply, State}.
	140
	141
	142	%% ============================================================================
	143	%% Internal
	144	%% ============================================================================
	145
	146	increment_dead_or_alive(0, NDead, NAlive) -> {NDead + 1, NAlive};
	147	increment_dead_or_alive(1, NDead, NAlive) -> {NDead, NAlive + 1}.
	148
	149
	150	schedule_next_gen() ->
	151	ok = gen_server:cast(?MODULE, next_gen).
	152
	153
	154	state_to_char(0) -> ?CHAR_DEAD;
	155	state_to_char(1) -> ?CHAR_ALIVE.
	156
	157
	158	do_print_state_chars(_, []) -> ok;
	159	do_print_state_chars(X, Chars) ->
	160	{XChars, RestChars} = lists:split(X, Chars),
	161	ok = io:format([XChars, $\n]),
	162	do_print_state_chars(X, RestChars).
	163
	164
	165	do_print_bar(X) ->
	166	io:format("~s~n", [[?CHAR_BAR \|\| _ <- lists:seq(1, X - 1)]]).