anchor.diff:  					bc_entity_util:vertex_distance(BcEntity, BcVertex),
   				{Distance, BcVertex} 
   			end, InRangeBcVertices),
  -	OccupiedBcVertices =
  -		lists:flatmap(
  -			fun(NearbyBcEntity) -> 
  -				bc_entity:vertices(NearbyBcEntity) 
  -			end, NearbyBcEntities),
  -	case choose_path(DistBcVertices, OccupiedBcVertices, State) of
  -		PathBcVertices when is_list(PathBcVertices) andalso 
  -								length(PathBcVertices) > 0 ->
  -			move_on_path(State#state{path = PathBcVertices});
  -		undefined ->
  -			%% TODO move closer to enemy if possible
  -			stand(State#state{path = undefined})
  -	end.
  -
  -move_on_path(#state{entity = BcEntity,
  -					path = PathBcVertices} = State) ->
  -	MoveBcVertex = lists:nth(1, PathBcVertices),
  -	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 ->			
  -			%% TODO fold over UnoccupiedSortedDistBcVertices to find best path
  -			{_, ClosestBcVertex} = lists:nth(1, UnoccupiedSortedDistBcVertices),
  -			case lists:foldl(fun({_, BcVertex}, AccPath) -> 
  -								case AccPath of
  -									Path when is_list(Path) andalso length(Path) > 0 ->
  -										Path;
  -									undefined ->  
  -										PathBcVertices = compute_path(BcEntity, ClosestBcVertex, State),
  -										%% TODO there is deffinitly a faster way to do this
  -										case lists:any(fun(PathBcVertex) -> 
  -														 lists:member(PathBcVertex, OccupiedBcVertices)
  -													   end, PathBcVertices) of
  -											true -> undefined;
  -											false -> PathBcVertices
  -										end
  -								end 
  -							end, undefined, SortedDistBcVertices) of
  -				Path when is_list(Path) andalso length(Path) > 0 ->
  -					Path;
  -				undefined ->
  -					undefined
  -			end;
  -		_ ->
  -			undefined
  -	end.
  +	lists:sort(fun({Dist1, _}, 
  +				   {Dist2, _}) ->
  +				 Dist1 =< Dist2
  +			   end, DistBcVertices).
   
   compute_path(BcEntity, BcVertex, #state{map = BcMap} = State) ->
   	ClosestEntityBcVertex = 
  
positive.code: 			BaseBcVertices = bc_map:base_vertices(BcMap, EnemyNum),
  			Range = bc_entity_config:range(BcEntityConfig),
  			InRangeBcVertices = bc_map:reaching_neighbors(BcMap, BaseBcVertices, Range),
  			DistEntities = dist_entities(State),
  			move_in_range(InRangeBcVertices, DistEntities, State)
  	end.
  
  move(Direction, #state{entity = BcEntity, 
  
negative.code: 	case bc_map:compute_path(BcMap, ClosestEntityBcVertex, BcVertex) of
  		Path when is_list(Path) andalso length(Path) > 1 ->
  			lists:sublist(Path, 2, length(Path) + 1);
  		_EmptyPath ->
  			[]
  	end.
  
  