anchor.diff:  					on_moved(State#state{entity = ReorientedBcEntity,
   										 path = UpdatedPath});
   				{error, _} ->
  -					{next_state, standing, State#state{timer = 
  -												gen_fsm:send_event_after(100, action_complete)}}
  +					stand(State)
   			end;
   		false ->
  -			{next_state, standing, State#state{timer = 
  -												gen_fsm:send_event_after(100, action_complete)}}
  +			stand(State)
   	end.
   
   update_path(_, undefined) ->
  
positive.code: 	
  choose_path(DistBcVertices, DistEntities, #state{entity = BcEntity,
  												 map = BcMap} = State) ->
  	SortedDistBcVertices = 
  		lists:sort(fun({Dist1, _}, 
  					   {Dist2, _}) -> 
  						Dist1 =< Dist2 
  				   end, DistBcVertices),
  	{_, ClosestBcVertex} = lists:nth(1, SortedDistBcVertices),
  	EntitiesBcVertices = lists:flatten(
  		lists:map(fun({_, NearbyBcEntity}) -> 
  					bc_entity:vertices(NearbyBcEntity) 
  				  end, DistEntities)
  	),
  	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, EntitiesBcVertices)
  											   end, PathBcVertices) of
  									true -> undefined;
  									false -> PathBcVertices
  								end
  						end 
  					end, undefined, SortedDistBcVertices) of
  		Path when is_list(Path) andalso length(Path) > 0 ->
  			Path;
  		undefined ->
  			{_, FirstBcVertex} = lists:nth(1, SortedDistBcVertices),
  			compute_path(BcEntity, FirstBcVertex, State)
  	end.
  
  compute_path(BcEntity, BcVertex, #state{map = BcMap} = State) ->
  
negative.code: 	TimerRef = send_action_complete(MoveSpeed),
  	{next_state, moving, State#state{timer = TimerRef}}.
  
  stand(State) ->
  	{next_state, standing, State#state{timer = 
  										gen_fsm:send_event_after(100, action_complete)}}.
  
  send_action_complete(Speed) ->
  	DelayFloat = 1000 - (1000 * Speed),
  	DelayInt = erlang:trunc(DelayFloat),
  