anchor.diff:  						  entity_config = BcEntityConfig, 
   						  map = BcMap} = State) ->
   	Range = bc_entity_config:range(BcEntityConfig),
  -	EnemyInRangeVertices = lists:flatten(
  +	EnemyInRangeVertices = 
   		lists:map(
   			fun(EnemyBcEntity) -> 
   				EnemyBcVertices = bc_entity:vertices(EnemyBcEntity),
   				InRangeBcVertices = 
   					bc_map:reaching_neighbors(BcMap, EnemyBcVertices, Range),
   				{EnemyBcEntity, InRangeBcVertices} 
  -			end, EnemyBcEntities)
  -	),
  +			end, EnemyBcEntities),
   	case in_range_enemies(EnemyInRangeVertices, BcEntity) of
   		InRangeEnemyBcEntities when length(InRangeEnemyBcEntities) > 0 ->
   			attack_entities(InRangeEnemyBcEntities, State);
  
positive.code: 										PathBcVertices = compute_path(BcEntity, ClosestBcVertex, State),
  										%% TODO there is deffinitly a faster way to do this
  										case lists:any(fun(PathBcVertex) -> 
  														 lists:member(PathBcVertex, EntitiesBcVertices)
  													   end, PathBcVertices) of
  											true -> undefined;
  											false -> PathBcVertices
  
negative.code: 	Direction = bc_entity_util:move_direction(BcEntity, MoveBcVertex),
  	move(Direction, State).
  	
  choose_path(DistBcVertices, OccupiedBcVertices, #state{entity = BcEntity,
  													   map = BcMap} = State) ->
  	SortedDistBcVertices = 
  		lists:sort(fun({Dist1, _}, 
  					   {Dist2, _}) -> 
  						Dist1 =< Dist2 
  				   end, DistBcVertices),
  	case lists:filter(fun({_, BcVertex}) ->
  						not lists:member(BcVertex, OccupiedBcVertices)
  					  end, SortedDistBcVertices) of
  		UnoccupiedSortedDistBcVertices 
  		  when length(UnoccupiedSortedDistBcVertices) > 0 ->			
  