private IBehaviourTreeNode UnacquaintedTree(IActorStateModel actor)
{
// @formatter:off
return(new BehaviourTreeBuilder()
.Sequence()
.Condition(t => IsEntityState(actor, EntityState.Unacquainted))
.Parallel(1, 1)
.Sequence()
.Do(UnacquaintedTimeout())
.Do(LeaveScreen())
.Do(Deactivate())
.End()
.Selector()
.Sequence()
.Do(FirstTouch())
.End()
.Sequence()
.Do(FollowAvatar())
.Do(Move())
.End()
.Sequence()
.Do(WanderTimeout())
.Do(Wander())
.Do(Move())
.Do(ResetTimeout(TimeoutDataComponent.Storage.WanderTimeout))
.End()
.End() // END Top Selector
.End() // END Parallel
.End() // END Top Sequence
.Build());
// @formatter:on
}
public ResetTimeoutNode(
IActorStateModel actorStateModel,
TimeoutDataComponent.Storage storage)
{
_storage = storage;
_timeoutDataComponent = actorStateModel.Get <TimeoutDataComponent>();
}
private float GetDistanceSquared(IActorStateModel actorA, IActorStateModel actorB)
{
var distance = actorA.Get <TransformDataComponent>().Position -
actorB.Get <TransformDataComponent>().Position;
return(distance.sqrMagnitude);
}
public EntityFacade(
IMonoEntity entity,
IActorStateModel actor,
IPauseStateModel pauseStateModel)
{
Entity = entity;
Actor = actor;
_pauseStateModel = pauseStateModel;
_entityLifecycleDisposable = new SerialDisposable().AddTo(Disposer);
Entity.Setup(Actor);
Actor.Get <TransformDataComponent>()
.SetMonoEntity(Entity);
HealthDataComponent = Actor.Get <HealthDataComponent>();
HealthDataComponent.IsAlive
.DelayFrame(1)
.Subscribe(OnIsAliveChanged)
.AddTo(Disposer);
Observable.EveryUpdate()
.Where(_ => CanTick)
.Subscribe(_ => OnTick())
.AddTo(Disposer);
}
public MoveNode(
IActorStateModel actorStateModel,
AiMovementController aiMovementController)
{
_aiMovementController = aiMovementController;
_blackBoard = actorStateModel.Get <BlackBoardDataComponent>();
}
private void TryRemoveAsAvatar(IActorStateModel actor)
{
if (actor.Get <EntityTypeDataComponent>().EntityType == EntityType.Avatar)
{
Avatar = null;
}
}
private void TryAddAsAvatar(IActorStateModel actor)
{
if (actor.Get <EntityTypeDataComponent>().EntityType == EntityType.Avatar)
{
Avatar = actor;
}
}
public SwitchEntityStateNode(
IActorStateModel actorStateModel,
EntityState targetState)
{
_relationshipDataComponent = actorStateModel.Get <RelationshipDataComponent>();
_targetState = targetState;
}
public AvatarFacade(
IMonoEntity entity,
IActorStateModel actor,
IPauseStateModel pauseStateModel)
: base(entity, actor, pauseStateModel)
{
}
public void Add(IActorStateModel actor)
{
if (!_knownEntities.Contains(actor))
{
_knownEntities.Add(actor);
TryAddAsAvatar(actor);
}
}
public void Remove(IActorStateModel actor)
{
if (_knownEntities.Contains(actor))
{
_knownEntities.Remove(actor);
TryRemoveAsAvatar(actor);
}
}
public FollowAvatarNode(IActorStateModel actorStateModel)
{
_actorStateModel = actorStateModel;
_blackBoard = _actorStateModel.Get <BlackBoardDataComponent>();
_sensorDataComponent = _actorStateModel.Get <SensorDataComponent>();
_transformDataComponent = _actorStateModel.Get <TransformDataComponent>();
_timeoutDataComponent = _actorStateModel.Get <TimeoutDataComponent>();
}
public FirstTouchNode(
IActorStateModel actorStateModel,
BehaviourTreeConfig behaviourTreeConfig)
{
_behaviourTreeConfig = behaviourTreeConfig;
_sensorDataComponent = actorStateModel.Get <SensorDataComponent>();
_relationshipDataComponent = actorStateModel.Get <RelationshipDataComponent>();
}
public IdleTimeoutNode(
IActorStateModel actor,
double timeoutSeconds,
TimeoutDataComponent.Storage storage)
{
_timeoutDataComponent = actor.Get <TimeoutDataComponent>();
_timeoutSeconds = timeoutSeconds;
_storage = storage;
}
public void Remove(IActorStateModel actor, SensorType sensor)
{
_storages[sensor].Remove(actor);
if (_lifetimeSubscriptions.ContainsKey(actor))
{
_lifetimeSubscriptions[actor].Dispose();
_lifetimeSubscriptions.Remove(actor);
}
}
public EnterScreenNode(
IActorStateModel actorStateModel,
AiMovementController aiMovementController,
ScreenSizeModel screenSizeModel)
{
_aiMovementController = aiMovementController;
_screenSizeModel = screenSizeModel;
_originDataComponent = actorStateModel.Get <OriginDataComponent>();
_transformDataComponent = actorStateModel.Get <TransformDataComponent>();
}
public IdleTimeoutRandomNode(
IActorStateModel actor,
double timeoutSeconds,
TimeoutDataComponent.Storage storage,
double randomChance)
{
_timeoutDataComponent = actor.Get <TimeoutDataComponent>();
_timeoutSeconds = timeoutSeconds;
_storage = storage;
_randomChance = randomChance;
}
public EntityStateNotificationSystem(IActorStateModel actor)
: base(actor)
{
_relationshipDataComponent = actor.Get <RelationshipDataComponent>();
_components = actor.GetAll <IEntityStateSensitiveDataComponent>();
_relationshipDataComponent.Relationship
.Subscribe(OnRelationShipChanged)
.AddTo(Disposer);
}
public void Setup(IActorStateModel actor)
{
if (_isSetup)
{
return;
}
_isSetup = true;
Actor = actor;
OnSetup();
}
public WanderNode(
IActorStateModel actorStateModel,
IRandomNumberService randomNumberService,
ScreenSizeModel screenSizeModel)
{
_randomNumberService = randomNumberService;
_screenSizeModel = screenSizeModel;
_blackBoard = actorStateModel.Get <BlackBoardDataComponent>();
_originDataComponent = actorStateModel.Get <OriginDataComponent>();
_wanderDataComponent = actorStateModel.Get <WanderDataComponent>();
_transformDataComponent = actorStateModel.Get <TransformDataComponent>();
}
public void Add(IActorStateModel actor, SensorType sensor)
{
_storages[sensor].Add(actor);
if (!_lifetimeSubscriptions.ContainsKey(actor))
{
var sub = actor.Get <HealthDataComponent>().IsAlive
.IfFalse()
.Subscribe(_ => Remove(actor, sensor))
.AddTo(Disposer);
_lifetimeSubscriptions.Add(actor, sub);
}
}
private IBehaviourTreeNode NeutralTree(IActorStateModel actor)
{
// @formatter:off
return(new BehaviourTreeBuilder()
.Sequence()
.Condition(t => IsEntityState(actor, EntityState.Neutral))
.Sequence()
.Do(NeutralTimeout())
.Do(LeaveScreen())
.Do(Deactivate())
.End()
.End()
.Build());
// @formatter:on
}
private IBehaviourTreeNode SpawningTree(IActorStateModel actor)
{
// @formatter:off
return(new BehaviourTreeBuilder()
.Sequence()
.Condition(t => IsEntityState(actor, EntityState.Spawning))
.Sequence()
.Do(LightSwitch())
.Do(EnterScreen())
.Do(SwitchStateTo(EntityState.Unacquainted))
.End()
.End()
.Build());
// @formatter:on
}
public InputMovementController(
IActorStateModel actorStateModel,
VirtualJoystickModel virtualJoystickModel,
UserInputConfig userInputConfig,
IPauseStateModel pauseStateModel)
: base(actorStateModel)
{
_virtualJoystickModel = virtualJoystickModel;
_userInputConfig = userInputConfig;
_pauseStateModel = pauseStateModel;
Observable.EveryUpdate()
.Subscribe(_ => OnUpdate())
.AddTo(Disposer);
}
public void Initialize()
{
AvatarActor = _avatarActorFactory.CreateAvatar();
var avatarEntity = _entityFactory.Create(
_actorEntitiesConfig.AvatarPrefab);
_avatarFacadeFactory.Create(
avatarEntity,
AvatarActor);
_userInputControllerFactory
.Create(AvatarActor);
_isAvatarSpawned.Value = true;
}
public void Setup(IActorStateModel actorStateModel)
{
if (_isSetup)
{
return;
}
_isSetup = true;
Actor = actorStateModel;
_components = GetComponents <IMonoComponent>();
_components?.ForEach(e => e.Setup(Actor));
_tickableComponents = _components?
.OfType <ITickableMonoComponent>()
.ToArray();
}
public NovatarFacade(
IMonoEntity entity,
IActorStateModel actor,
BehaviourTree behaviourTree,
IPauseStateModel pauseStateModel)
: base(entity, actor, pauseStateModel)
{
_behaviourTree = behaviourTree;
_originDataComponent = Actor.Get <OriginDataComponent>();
_relationshipDataComponent = Actor.Get <RelationshipDataComponent>();
_resettableNodes = _behaviourTree.Nodes
.OfType <IResettableNode>()
.ToList();
_originDataComponent.SpawnPosition
.Subscribe(Entity.SetPosition)
.AddTo(Disposer);
}
private IBehaviourTreeNode EnemyTree(IActorStateModel actor)
{
// @formatter:off
return(new BehaviourTreeBuilder()
.Sequence()
.Condition(t => IsEntityState(actor, EntityState.Enemy))
.Selector()
.Sequence()
.Do(FindDamageReceiver())
.Do(Damage())
.End()
.Sequence()
.Do(EnemyTimeout())
.Do(LeaveScreen())
.Do(Deactivate())
.End()
.End()
.End()
.Build());
// @formatter:on
}
public BehaviourTree Create(
IActorStateModel actor,
AiMovementController aiMovementController)
{
_actorStateModel = actor;
_aiMovementController = aiMovementController;
_generatedNodes = new List <IBehaviourTreeNode>();
// @formatter:off
var startNode = new BehaviourTreeBuilder()
.Selector()
.Splice(SpawningTree(actor))
.Splice(UnacquaintedTree(actor))
.Splice(NeutralTree(actor))
.Splice(FriendTree(actor))
.Splice(EnemyTree(actor))
.End()
.Build();
// @formatter:on
return(new BehaviourTree(startNode, _generatedNodes.ToArray()));
}
private IBehaviourTreeNode FriendTree(IActorStateModel actor)
{
// @formatter:off
return(new BehaviourTreeBuilder()
.Sequence()
.Condition(t => IsEntityState(actor, EntityState.Friend))
.Selector()
.Sequence()
.Do(NearDeath())
.Do(SwitchStateTo(EntityState.Neutral))
.End()
.Sequence()
.Do(FollowAvatarBoid())
.Do(Move())
.End()
.Sequence()
.Do(FriendTimeout())
.Do(SwitchStateTo(EntityState.Neutral))
.End()
.End()
.End()
.Build());
// @formatter:on
}
