void Start ()
{
targetEnemy = null;
goapBrain = new GoapCore();
goapBrain.Init(this);
}
public void OnAttack(ItemProperty itemProperty)
{
_playerBase.GetComponent<Animator>().Play("attack");
_actorBase = GetComponent<ActorBase> ();
_animator = _actorBase.GetComponent<Animator>();
_animator.Play("attack");
attack (itemProperty);
}
public void ActorMessage(ActorBase actor, string message, params object[] args)
{
if (this.IsEnabled())
{
string finalMessage = string.Format(message, args);
this.ActorMessage(
actor.GetType().ToString(),
actor.Id.ToString(),
actor.ActorService.Context.CodePackageActivationContext.ApplicationTypeName,
actor.ActorService.Context.CodePackageActivationContext.ApplicationName,
actor.ActorService.Context.ServiceTypeName,
actor.ActorService.Context.ServiceName.ToString(),
actor.ActorService.Context.PartitionId,
actor.ActorService.Context.ReplicaId,
FabricRuntime.GetNodeContext().NodeName,
finalMessage);
}
}
public void ActorMessage(ActorBase actor, string message, params object[] args)
{
if (IsEnabled() && actor.Id != null && actor.ActorService?.Context?.CodePackageActivationContext != null)
{
string finalMessage = string.Format(message, args);
ActorMessage(
actor.GetType().ToString(),
actor.Id.ToString(),
actor.ActorService.Context.CodePackageActivationContext.ApplicationTypeName,
actor.ActorService.Context.CodePackageActivationContext.ApplicationName,
actor.ActorService.Context.ServiceTypeName,
actor.ActorService.Context.ServiceName.ToString(),
actor.ActorService.Context.PartitionId,
actor.ActorService.Context.ReplicaId,
actor.ActorService.Context.NodeContext.NodeName,
finalMessage);
}
}
public TestBase() : base(AkkaConfig.Config)
{
Func <Type> generateType = TestHelper.GetRandomTypeGenerator();
// Create mocks
DependencyResolverAdderMock = new Mock <IDependencyResolverAdder>();
TestProbeChildActorCreatorMock = new Mock <ITestProbeChildActorCreator>();
TestProbeCreatorMock = new Mock <ITestProbeCreator>();
ResolvedTestProbeStoreMock = new Mock <IResolvedTestProbeStore>();
ChildWaiterMock = new Mock <IWaiter>();
TestProbeChildActorWithHandlersMock = new Mock <ITestProbeChildActor>();
TestProbeChildActorWithoutHandlersMock = new Mock <ITestProbeChildActor>();
// Create objects used by mocks
CallOrder = new List <string>();
// Create objects passed into ActorFactory
ActorWithHandlersType = generateType();
ActorWithoutHandlersType = generateType();
// Create objects passed into sut methods
DependencyResolverAdder = DependencyResolverAdderMock.Object;
TestProbeChildActorCreator = TestProbeChildActorCreatorMock.Object;
TestProbeCreator = TestProbeCreatorMock.Object;
ResolvedTestProbeStore = ResolvedTestProbeStoreMock.Object;
ChildWaiter = ChildWaiterMock.Object;
ActorHandlers = ImmutableDictionary <Type, Func <object, object> >
.Empty
.Add(generateType(), mess => TestHelper.Generate <object>());
Handlers = ImmutableDictionary <Type, ImmutableDictionary <Type, Func <object, object> > >
.Empty
.Add(ActorWithHandlersType, ActorHandlers);
// Create values returned by mocks
ResolvedActorWithHandlers = new Mock <ActorBase>().Object;
ResolvedActorPathWithHandlers = TestHelper.Generate <ActorPath>();
ResolvedTestProbeWithHandlers = CreateTestProbe();
ResolvedSupervisorStrategyWithHandlers = new AllForOneStrategy(
TestHelper.GenerateNumber(),
TestHelper.GenerateNumber(),
exception => TestHelper.Generate <Directive>());
ResolvedActorWithoutHandlers = new Mock <ActorBase>().Object;
ResolvedActorPathWithoutHandlers = TestHelper.Generate <ActorPath>();
ResolvedTestProbeWithoutHandlers = CreateTestProbe();
ResolvedSupervisorStrategyWithoutHandlers = new OneForOneStrategy(
TestHelper.GenerateNumber(),
TestHelper.GenerateNumber(),
exception => TestHelper.Generate <Directive>());
// Set up mocks
TestProbeChildActorWithHandlersMock
.Setup(actor => actor.Actor)
.Returns(() => ResolvedActorWithHandlers);
TestProbeChildActorWithHandlersMock
.Setup(actor => actor.ActorPath)
.Returns(() => ResolvedActorPathWithHandlers);
TestProbeChildActorWithHandlersMock
.Setup(actor => actor.TestProbe)
.Returns(() => ResolvedTestProbeWithHandlers);
TestProbeChildActorWithHandlersMock
.Setup(actor => actor.PropsSupervisorStrategy)
.Returns(() => ResolvedSupervisorStrategyWithHandlers);
TestProbeChildActorWithoutHandlersMock
.Setup(actor => actor.Actor)
.Returns(() => ResolvedActorWithoutHandlers);
TestProbeChildActorWithoutHandlersMock
.Setup(actor => actor.ActorPath)
.Returns(() => ResolvedActorPathWithoutHandlers);
TestProbeChildActorWithoutHandlersMock
.Setup(actor => actor.TestProbe)
.Returns(() => ResolvedTestProbeWithoutHandlers);
TestProbeChildActorWithoutHandlersMock
.Setup(actor => actor.PropsSupervisorStrategy)
.Returns(() => ResolvedSupervisorStrategyWithoutHandlers);
TestProbeChildActorCreatorMock
.Setup(creator => creator.Create(TestProbeCreator, this, ActorHandlers))
.Returns(() => TestProbeChildActorWithHandlersMock.Object);
TestProbeChildActorCreatorMock
.Setup(creator => creator.Create(TestProbeCreator, this, null))
.Returns(() => TestProbeChildActorWithoutHandlersMock.Object);
ResolvedTestProbeStoreMock
.Setup(store => store.ResolveProbe(It.IsAny <ActorPath>(), It.IsAny <Type>(), It.IsAny <TestProbe>(), It.IsAny <SupervisorStrategy>()))
.Callback(() => CallOrder.Add(nameof(IResolvedTestProbeStore.ResolveProbe)));
ChildWaiterMock
.Setup(waiter => waiter.ResolveEvent())
.Callback(() => CallOrder.Add(nameof(IWaiter.ResolveEvent)));
DependencyResolverAdderMock
.Setup(adder => adder.Add(this, It.IsAny <Func <Type, ActorBase> >()))
.Callback((TestKitBase testKit, Func <Type, ActorBase> actorFactory) => ActorFactory = actorFactory);
}
/*
void RunStep(int stepId) {
foreach (CutsceneStep step in steps) {
if (step.stepId == stepId) {
DoStep (step);
break;
}
}
}
*/
public void MakeTalk(ActorBase actor, int dialog, Transform target) {
if (dialog > 0) {
//gbl.DisplaySubtitle(dialogs[World.langIdx][dialog].caption, actor);
actor.TalkTo(dialogs[World.langIdx][dialog].clip, target, CutsceneStep.Action.TalkTo);
}
}
/// <summary>
/// Signals the service collection to remove it's reference to the actor.
/// </summary>
/// <param name="actor">The actor to remove from the container</param>
public void Release(ActorBase actor)
{
var serviceDescriptor = _serviceCollection.FirstOrDefault(descriptor => descriptor.ServiceType == typeof(ActorBase));
_serviceCollection.Remove(serviceDescriptor);
}
/// <summary>
/// Invokes <see cref="ActorBase.InvokeOnPostActorMethodAsync"/> and returns the resulting task.
/// Call <see cref="MockActorMethodContextFactory.ActorMethodContextCreateForActor"/>
/// /<see cref="MockActorMethodContextFactory.ActorMethodContextCreateForReminder"/>
/// /<see cref="MockActorMethodContextFactory.ActorMethodContextCreateForTimer"/>
/// to create an <see cref="ActorMethodContext"/>./// </summary>
/// <param name="actor"></param>
/// <param name="actorMethodContext"> An <see cref="ActorMethodContext" /> describing the method that will be invoked by actor runtime after this method finishes.</param>
/// <returns></returns>
public static Task InvokeOnPostActorMethodAsync(this ActorBase actor, ActorMethodContext actorMethodContext)
{
return((Task)typeof(ActorBase)
.GetMethod("OnPostActorMethodAsync", BindingFlags.Instance | BindingFlags.NonPublic)
.Invoke(actor, new object[] { actorMethodContext }));
}
public void Release(ActorBase actor)
{
}
protected override bool OnPerish(ActorBase collider)
{
Explosion.Create(levelHandler, Transform.Pos + Speed, Explosion.RF);
return(base.OnPerish(collider));
}
public void Start()
{
_actorBase = GetComponent<ActorBase> ();
}
/// <summary>
/// TBD
/// </summary>
/// <param name="actor">TBD</param>
/// <returns>TBD</returns>
public void Release(ActorBase actor)
{
actor = null;
}
public override void OnHandleCollision(ActorBase other)
{
// Nothing to do...
}
/// <summary>
/// Compares the presence of the actor's team compared to the enemy team.
/// </summary>
/// <returns>The relative presence.</returns>
public float ComparePresence(ActorBase _actor)
{
//if there are no enemies
if (enemyData.Count == 0)
{
return 1;
}
//take own health proportion
float ally = _actor.health / _actor.maxHealth;
float enemy = 0f;
//take ally health proportion / distance
foreach (ActorBase _ally in allies)
{
ally += _ally.health / _ally.maxHealth;
}
if (ally != 0f)
{
ally /= allies.Count + 1;
}
foreach (EnemyPosition _enemyDat in enemyData)
{
enemy += _enemyDat.enemy.health / _enemyDat.enemy.maxHealth;
}
enemy /= enemyData.Count;
return 1 - ((ally / enemy) / (allies.Count + enemyData.Count));
}
private bool ResolveCollisions(ActorBase actor)
{
collisions.Add(actor);
return(true);
}
/// <summary>
/// This method is used to signal the DI Container that it can
/// release it's reference to the actor. <see href="http://www.amazon.com/Dependency-Injection-NET-Mark-Seemann/dp/1935182501/ref=sr_1_1?ie=UTF8&qid=1425861096&sr=8-1&keywords=mark+seemann">HERE</see>
/// </summary>
/// <param name="actor"></param>
public void Release(ActorBase actor)
{
dependencyResolver.Release(actor);
}
public void Start()
{
_actorBase = GetComponent<ActorBase> ();
_actorBase.ActorHealth.OnHealthChanged += OnHealthChanged;
_animator = _actorBase.GetComponent<Animator>();
}
public void ActorRequestStop(ActorBase a, string requestName)
{
this.ActorRequestStop(a.GetType().ToString(), a.Id.ToString(), requestName);
}
public void ActorDeactivatedStop(ActorBase a)
{
this.ActorActivatedStop(a.GetType().ToString(), a.Id.ToString(), a.ActorService.Context.PartitionId);
}
protected override bool OnPerish(ActorBase collider)
{
Explosion.Create(api, Transform.Pos + Speed, Explosion.SmokeWhite);
return(base.OnPerish(collider));
}
static public void RestoreParts(ActorBase actor) {
if (dicActorParts.Count == 0)
return;
if (actor == null) {
ActorBase[] objs = GameObject.FindObjectsOfType(typeof(ActorBase)) as ActorBase[];
foreach (ActorBase obj in objs) {
RestoreParts(obj);
}
} else if (dicActorParts.ContainsKey(actor.name)) {
foreach (Transform form in dicActorParts[actor.name].parts) {
actor.ChangeInto(form, 0);
}
}
}
static public void ClearAttach( ActorBase actor, Transform parts) {
if (parts == null)
return;
string name = actor.name;
ActorParts actorParts;
if (dicActorParts.ContainsKey(name)) {
actorParts = dicActorParts[name];
}
else
return;
actorParts.parts.Remove(parts);
actor.ClearAttach(parts);
}
public FailingInnerActor(ActorBase fail)
{
Fail = fail;
}
void ReadLoopActionData(ActorBase actor) {
LcCutsceneEditor.ReadLoopActionData(actor);
}
public FailingChildInnerActor(ActorBase fail)
: base(fail)
{
Fail = new InnerActor();
}
void IDependencyResolver.Release(ActorBase actor)
{
}
public FailingOuterActor(IActorRef inner)
{
_inner = inner;
Fail = new InnerActor();
}
public override void OnHandleCollision(ActorBase other)
{
}
public virtual void ActorDead(ActorBase actor)
{
}
/// <summary>
/// Signals the container to release it's reference to the actor.
/// </summary>
/// <param name="actor">The actor to remove from the container</param>
public void Release(ActorBase actor)
{
this.container.Release(actor);
}
internal void LoadActorStateStart(ActorBase actor)
{
var diagCtx = actor.DiagnosticsContext;
diagCtx.StateStopwatch.Restart();
}
/// <summary>
/// Invokes <see cref="ActorBase.OnDeactivateAsync"/> and returns the resulting task.
/// </summary>
/// <param name="actor"></param>
/// <returns></returns>
public static Task InvokeOnDeactivateAsync(this ActorBase actor)
{
return((Task)typeof(ActorBase)
.GetMethod("OnDeactivateAsync", BindingFlags.Instance | BindingFlags.NonPublic)
.Invoke(actor, null));
}
internal void AcquireActorLockFailed(ActorBase actor)
{
Interlocked.Decrement(ref actor.DiagnosticsContext.PendingActorMethodCalls);
}
/// <summary>
/// Gets all registered reminders for the provided ActorBase.
/// </summary>
/// <param name="actor"></param>
/// <returns></returns>
public static IEnumerable <IActorReminder> GetActorReminders(this ActorBase actor)
{
var reminderCollection = actor.ActorService.StateProvider.LoadRemindersAsync().ConfigureAwait(false).GetAwaiter().GetResult();
return(reminderCollection[actor.Id]);
}
internal void ActorOnActivateAsyncStart(ActorBase actor)
{
var diagCtx = actor.DiagnosticsContext;
diagCtx.OnActivateAsyncStopwatch.Restart();
}
protected override bool OnPerish(ActorBase collider)
{
CreateParticleDebris();
return(base.OnPerish(collider));
}
public ActorReminderCalled(ActorBase actor, string reminderName) : base(actor)
{
this.ActorId = actor.Id.ToString();
this.ActorName = actor.ActorService.ActorTypeInformation.ServiceName;
ReminderName = reminderName;
}
protected void Start()
{
_actorBase = GetComponent<ActorBase> ();
_actorBase.ActorCollision.projectileCollision += OnProjectileCollision;
}
public void AddActor(ActorBase actor)
{
levelHandler.AddActor(actor);
}
static void ReadLoopActionData(ActorBase actor) {
if( loopActionReadDic == null )
return;
if (loopActionReadDic.ContainsKey(actor))
return;
ActorChar actorChar = actor.GetComponent<ActorChar>();
if (actorChar != null) {
actorChar.ReadLoopActionData();
}
loopActionReadDic[actor] = actor;
}
public void RemoveActor(ActorBase actor)
{
levelHandler.RemoveActor(actor);
}
public void FindCollisionActorsByAABB(ActorBase self, AABB aabb, Func <ActorBase, bool> callback)
{
levelHandler.FindCollisionActorsByAABB(self, aabb, callback);
}
public bool IsPositionEmpty(ActorBase self, ref AABB aabb, bool downwards)
{
return(levelHandler.IsPositionEmpty(self, ref aabb, downwards));
}
public void MakeTalk(ActorBase actor, AudioClip clip, string dialog, Transform target) {
//gbl.DisplaySubtitle(dialog, actor);
actor.TalkTo(clip, target, CutsceneStep.Action.TalkTo);
}
public void WarpCameraToTarget(ActorBase target)
{
levelHandler.WarpCameraToTarget(target);
}
static public void ClearParts(ActorBase actor) {
if (actor == null) {
dicActorParts.Clear ();
} else {
dicActorParts.Remove(actor.name);
}
}
public void PlayCommonSound(ActorBase target, string name, float gain = 1f, float pitch = 1f)
{
levelHandler.PlayCommonSound(name, target, gain, pitch);
}
public void DisplaySubtitle(string msg, ActorBase src) {
subtitle = msg;
subtitleSource = src;
}
public ActorSteps(ActorBase _actor) {
actor = _actor;
}
