anchor.diff:  						   targets = [],
   						   timer = TimerRef}}.
   
  +-spec no_action(Event :: timeout | term(), StateData :: term()) -> Result when
  +	Result :: {next_state, NextStateName, NewStateData}
  +			| {next_state, NextStateName, NewStateData, Timeout}
  +			| {next_state, NextStateName, NewStateData, hibernate}
  +			| {stop, Reason, NewStateData},
  +	NextStateName :: atom(),
  +	NewStateData :: term(),
  +	Timeout :: non_neg_integer() | infinity,
  +	Reason :: term().
   no_action(action_complete, State) ->
  +	{next_state, no_action, State};
  +no_action(Event, State) ->
   	{next_state, no_action, State}.
   
  +-spec standing(Event :: timeout | term(), StateData :: term()) -> Result when
  +	Result :: {next_state, NextStateName, NewStateData}
  +			| {next_state, NextStateName, NewStateData, Timeout}
  +			| {next_state, NextStateName, NewStateData, hibernate}
  +			| {stop, Reason, NewStateData},
  +	NextStateName :: atom(),
  +	NewStateData :: term(),
  +	Timeout :: non_neg_integer() | infinity,
  +	Reason :: term().
   standing(action_complete, State) ->
  -	sense(State).
  -
  +	sense(State);
  +standing(Event, State) ->
  +	{next_state, standing, State}.
  +
  +-spec moving(Event :: timeout | term(), StateData :: term()) -> Result when
  +	Result :: {next_state, NextStateName, NewStateData}
  +			| {next_state, NextStateName, NewStateData, Timeout}
  +			| {next_state, NextStateName, NewStateData, hibernate}
  +			| {stop, Reason, NewStateData},
  +	NextStateName :: atom(),
  +	NewStateData :: term(),
  +	Timeout :: non_neg_integer() | infinity,
  +	Reason :: term().
   moving(action_complete, State) ->
  -	sense(State).
  -
  +	sense(State);
  +moving(Event, State) ->
  +	{next_state, moving, State}.
  +
  +-spec attacking(Event :: timeout | term(), StateData :: term()) -> Result when
  +	Result :: {next_state, NextStateName, NewStateData}
  +			| {next_state, NextStateName, NewStateData, Timeout}
  +			| {next_state, NextStateName, NewStateData, hibernate}
  +			| {stop, Reason, NewStateData},
  +	NextStateName :: atom(),
  +	NewStateData :: term(),
  +	Timeout :: non_neg_integer() | infinity,
  +	Reason :: term().
   attacking(action_complete, State) ->
  -	sense(State).
  +	sense(State);
  +attacking(Event, State) ->
  +	{next_state, attacking, State}.
  +
  +%% TODO impl state/3
   
   %% ====================================================================
   %% All State functions
   %% ====================================================================
   
  +-spec handle_event(Event :: term(), StateName :: atom(), StateData :: term()) -> Result when
  +	Result :: {next_state, NextStateName, NewStateData}
  +			| {next_state, NextStateName, NewStateData, Timeout}
  +			| {next_state, NextStateName, NewStateData, hibernate}
  +			| {stop, Reason, NewStateData},
  +	NextStateName :: atom(),
  +	NewStateData :: term(),
  +	Timeout :: non_neg_integer() | infinity,
  +	Reason :: term().
   handle_event({entity_died, EnemyBcEntity}, StateName, #state{timer = TimerRef} = State) ->
   	case StateName of
   		attacking ->
  
positive.code: 											map = BcMap} = State) ->
  	Range = bc_entity_config:range(BcEntityConfig),
  	lists:foldl(
  	  fun(EnemyBcEntity, AccEnemyBcVertexDict) ->
  		  EnemyBcVertices = bc_entity:vertices(EnemyBcEntity),
  		  InRangeBcVertices = 
  			  bc_map:reaching_neighbors(BcMap, EnemyBcVertices, Range),
  		  lists:foldl(
  			fun(InRangeBcVertex, AccAccEnemyBcVertexDict) -> 
  				EnemyBcEntitySet =					
  					case dict:find(InRangeBcVertex, AccAccEnemyBcVertexDict) of
  						{ok, BcEntitySet} ->
  							BcEntitySet;
  						error ->
  							sets:new()
  					end,
  				UpdatedSet = sets:add_element(EnemyBcEntity, EnemyBcEntitySet),
  				dict:store(InRangeBcVertex, UpdatedSet, AccAccEnemyBcVertexDict)
  			end, AccEnemyBcVertexDict, InRangeBcVertices)
  	  end, dict:new(), EnemyBcEntities).
  
  in_range_enemies(InRangeEnemyBcEntityDict, BcEntity) ->
  	BcVertices = bc_entity:vertices(BcEntity),
  	lists:foldl(
  	  fun(BcVertex, AccEnemyBcEntities) -> 
  		  case dict:find(BcVertex, InRangeEnemyBcEntityDict) of 
  			  {ok, EnemyBcEntitySet} ->
  				  EnemyBcEntities = sets:to_list(EnemyBcEntitySet),
  				  lists:append(AccEnemyBcEntities, EnemyBcEntities);
  			  error ->
  				  AccEnemyBcEntities
  		  end
  	  end, [], BcVertices).
  
  attack_entities(InRangeEnemyBcEntities, State) ->
  	case lists:filter(fun(EnemyBcEntity) ->
  						bc_entity:entity_type(EnemyBcEntity) == base
  					  end, InRangeEnemyBcEntities) of
  		InRangeEnemyBaseBcEntity when length(InRangeEnemyBaseBcEntity) > 0 ->
  			EnemyBaseBcEntity = lists:nth(1, InRangeEnemyBaseBcEntity),
  			attack_entity(EnemyBaseBcEntity, State);
  
negative.code: 					BaseQueryRes = bc_map:query_ids(BcMap, BaseUuid),
  					BaseBcVertices = 
  						lists:map(
  							fun(QueryRes) ->
  								maps:get(vertex, QueryRes)
  							end, BaseQueryRes),
  					UpdatedBaseBcEntity = 
  						bc_entity:set_vertices(BaseBcVertices, BaseBcEntity),
  					InRangeEnemyBcEntityDict = 
  