public static void Activate()
{
EntityActor actor = The.World.Avatar.Actor;
if (!actor)
{
return;
}
if (actor.transform.Find(TypeFullName))
{
return;
}
GameObject gameObject = GameObject.Instantiate <GameObject>(The.AssetManager.Load <GameObject>(PrefabPath), actor.transform);
gameObject.name = TypeFullName;
gameObject.transform.localScale = Vector3.one * InteractiveRange.Radius * 2f;
MeshRenderer renderer = gameObject.GetComponent <MeshRenderer>();
if (renderer)
{
renderer.material.SetColor("_Color", Colors.Green);
}
}
public void TestStop()
{
var mockOrder = new Mock <IOrder>();
mockOrder.Setup(o => o.IsValid(It.IsAny <Entity>())).Returns(true);
mockOrder.Setup(o => o.IsComplete(It.IsAny <Entity>())).Returns(false);
mockOrder.Setup(o => o.Update(It.IsAny <Entity>(), It.IsAny <GameTime>()))
.Callback(() => TestActor.Tell("Failed"));
var entity = new Entity();
var mockComponentActorFactory = new Mock <IComponentActorFactory>();
mockComponentActorFactory.Setup(f => f.GetOrCreateActorForComponent(It.IsAny <EntityComponent>()))
.Returns((EntityComponent component) => ActorRefs.Nobody);
IActorRef entityActor =
ActorOfAsTestActorRef <EntityActor>(EntityActor.Props(entity, mockComponentActorFactory.Object),
TestActor);
entityActor.Tell(new EnqueueOrder(entity.Id, mockOrder.Object));
entityActor.Tell(new Update(new GameTime()));
ExpectMsg("Failed");
entityActor.Tell(new Stop(entity.Id));
entityActor.Tell(new Update(new GameTime()));
ExpectNoMsg(500);
}
public void TestOrders()
{
var mockOrder = new Mock <IOrder>();
mockOrder.Setup(o => o.IsValid(It.IsAny <Entity>())).Returns(false);
var entity = new Entity();
var mockComponentActorFactory = new Mock <IComponentActorFactory>();
mockComponentActorFactory.Setup(f => f.GetOrCreateActorForComponent(It.IsAny <EntityComponent>()))
.Returns((EntityComponent component) => ActorRefs.Nobody);
IActorRef entityActor =
ActorOfAsTestActorRef <EntityActor>(EntityActor.Props(entity, mockComponentActorFactory.Object),
TestActor);
entityActor.Tell(new EnqueueOrder(entity.Id, mockOrder.Object));
entityActor.Tell(new Update(new GameTime()));
ExpectMsg <InvalidOrder>();
mockOrder.Reset();
mockOrder.Setup(o => o.IsValid(It.IsAny <Entity>())).Returns(true);
mockOrder.Setup(o => o.IsComplete(It.IsAny <Entity>())).Returns(false);
entityActor.Tell(new EnqueueOrder(entity.Id, mockOrder.Object));
entityActor.Tell(new Update(new GameTime()));
ExpectNoMsg();
mockOrder.Verify(o => o.IsComplete(It.IsAny <Entity>()), Times.AtMostOnce);
mockOrder.Verify(o => o.IsValid(It.IsAny <Entity>()), Times.Once);
mockOrder.Verify(o => o.Update(It.IsAny <Entity>(), It.IsAny <GameTime>()), Times.Once);
mockOrder.Invocations.Clear();
mockOrder.Setup(o => o.IsComplete(It.IsAny <Entity>())).Returns(true);
entityActor.Tell(new Update(new GameTime()));
ExpectNoMsg(100);
mockOrder.Verify(o => o.IsComplete(It.IsAny <Entity>()), Times.Once);
mockOrder.Verify(o => o.IsValid(It.IsAny <Entity>()), Times.AtMostOnce);
mockOrder.Verify(o => o.Update(It.IsAny <Entity>(), It.IsAny <GameTime>()), Times.Never);
}
/// <summary>
/// Create a new renderer for the given entity
/// </summary>
/// <param name="entity">Entity for which the renderer will be created</param>
private void CreateEntity(IMap map, Entity entity, bool isPlayer)
{
GameObject instance = Instantiate(entityPrefab, Vector3.zero, Quaternion.identity);
EntityActor actor = instance.AddComponent(
isPlayer ? typeof(PlayerActor) : typeof(AIActor)
) as EntityActor;
actor.Init(map, entity);
instance.transform.parent = transform;
EntityRenderer renderer = instance.GetComponent <EntityRenderer>();
renderer.Init(entity);
}
public void TestAnyMessage()
{
var entity = new Entity();
var mockComponentActorFactory = new Mock <IComponentActorFactory>();
IActorRef entityActor =
ActorOfAsTestActorRef <EntityActor>(EntityActor.Props(entity, mockComponentActorFactory.Object),
TestActor);
// ReSharper disable once SuggestVarOrType_SimpleTypes
entityActor.Tell(new TestMessage());
ExpectMsg <TestMessage>();
}
public void Update(MyInput input)
{
if (_BattleMap.MyState.GetType() == typeof(PrototypeBattleLogic.P_BMSPlayerSelectingTile))
{
PrototypeBattleLogic.P_BMSPlayerSelectingTile mapstate =
_BattleMap.MyState as PrototypeBattleLogic.P_BMSPlayerSelectingTile;
Tile selectedtile = mapstate._Cursor.Owner as Tile;
if (selectedtile != TileImViewing)
{
TileImViewing = selectedtile;
string one = "", two = "", thr = "", fou = "", fiv = "", six = "", sev = "", eig = "";
one = "Tile: " + selectedtile.TileName;
two = "Role: " + selectedtile.Role.ToString();
if (selectedtile.TileFeatureList.Count > 0)
{
thr = "Feature: " + selectedtile.TileFeatureList[0].Name;
}
fou = "Passable: " + selectedtile.IsTilePassable().ToString();
fiv = "SeeThru: " + selectedtile.IsTileSeeThru().ToString();
if (selectedtile.EntityList.Count > 0)
{
six = "Entity: " + selectedtile.EntityList[0].Name + "/" + selectedtile.EntityList[0].GetType().Name;
sev = "Faction: " + selectedtile.EntityList[0].Faction.ToString();
if (selectedtile.EntityList[0].GetType() == typeof(EntityActor))
{
EntityActor dude = selectedtile.EntityList[0] as EntityActor;
eig = "Movement: " + dude.MovementPoints + "/" + dude.MovementType + "/" + dude.TurnStatus;
}
}
one = PadString(one, _Render.SizeX);
two = PadString(two, _Render.SizeX);
thr = PadString(thr, _Render.SizeX);
fou = PadString(fou, _Render.SizeX);
fiv = PadString(fiv, _Render.SizeX);
six = PadString(six, _Render.SizeX);
sev = PadString(sev, _Render.SizeX);
eig = PadString(eig, _Render.SizeX);
char[] textblob = new char[_Render.SizeX * _Render.SizeY];
string bigstring = one + two + thr + fou + fiv + six + sev + eig;
bigstring.ToCharArray().CopyTo(textblob, 0);
_Render.Graphic = textblob;
}
}
}
public static void Deactivate()
{
EntityActor actor = The.World.Avatar.Actor;
if (!actor)
{
return;
}
Transform visualizer = actor.transform.Find(TypeFullName);
if (visualizer)
{
GameObject.Destroy(visualizer.gameObject);
}
}
public IP_BattleMapState Update(P_BattleMap battlemap, MyInput input)
{
switch (input)
{
case MyInput.Confirm:
Tile selectedtile = _Cursor.Owner as Tile;
if (selectedtile == null)
{
break;
}
if (selectedtile.EntityList.Count > 0)
{
if (selectedtile.EntityList[0].GetType() == typeof(EntityActor))
{
EntityActor selectedactor = selectedtile.EntityList[0] as EntityActor;
if (selectedactor.TurnStatus == EntityCharacterTurnStatus.MyTurn)
{
this.Exit(battlemap);
return(new P_BMSChose_Movement(battlemap, selectedactor));
}
}
}
break;
case MyInput.Escape:
battlemap.GenerateNewMap();
this.Exit(battlemap);
return(this);
case MyInput.DownLeft:
case MyInput.DownRight:
case MyInput.Left:
case MyInput.Right:
case MyInput.UpLeft:
case MyInput.UpRight:
P_BMS.MoveTileCursor(battlemap, P_BMS.InputToDirection(input), _Cursor, ref CursorIndex);
break;
default:
break;
}
P_BMS.CursorOffScreen(battlemap, _Cursor);
return(this);
}
public void TestMessageToComponent()
{
var entity = new Entity
{
new TestComponent()
};
var mockComponentActorFactory = new Mock <IComponentActorFactory>();
mockComponentActorFactory.Setup(f => f.GetOrCreateActorForComponent(It.IsAny <EntityComponent>()))
.Returns((EntityComponent component) => Sys.ActorOf(Props.Create(() => new ComponentActor())));
IActorRef entityActor =
ActorOfAsTestActorRef <EntityActor>(EntityActor.Props(entity, mockComponentActorFactory.Object),
TestActor);
// ReSharper disable once SuggestVarOrType_SimpleTypes
var message = Guid.NewGuid();
entityActor.Tell(new TestComponentMessage(entity.Id, message));
ExpectMsg(message);
}
public void TestMessageToEntityComponentFirstOfType()
{
var mockMessage = new Mock <IMessageToEntityComponentFirstOfType>();
var mockComponentActorFactory = new Mock <IComponentActorFactory>();
mockComponentActorFactory.Setup(f => f.GetOrCreateActorForComponent(It.IsAny <EntityComponent>())).Returns(
(EntityComponent component) =>
{
return(Sys.ActorOf(Props.Create(() => new EntityTestActor(component.Id)), $"{component.Id}"));
}
);
var testComponent = new Utils.TestComponent();
var entity = new Entity
{
testComponent,
new Utils.TestComponent()
};
mockMessage.Setup(m => m.EntityId).Returns(entity.Id);
mockMessage.Setup(m => m.ComponentType).Returns(typeof(Utils.TestComponent));
mockMessage.Setup(m => m.Message).Returns("Test");
IActorRef entityActor = Sys.ActorOf(EntityActor.Props(entity, mockComponentActorFactory.Object));
entityActor.Tell(mockMessage.Object);
ExpectMsg(testComponent.Id);
entity.RemoveAll <EntityComponent>();
entity.Dispose();
entity = new Entity
{
new Utils.TestComponent(),
testComponent
};
entityActor = Sys.ActorOf(EntityActor.Props(entity, mockComponentActorFactory.Object));
entityActor.Tell(mockMessage.Object);
ExpectMsg <Guid>(guid => guid != testComponent.Id);
}
public Boolean IsValid(Entity entity, out Single distanceSqr)
{
PositionModule module = entity.GetModule <PositionModule>();
if (module != null)
{
distanceSqr = (module.WorldPosition - _position).sqrMagnitude;
return(_rangeSqr >= distanceSqr);
}
EntityActor actor = entity.Actor;
if (actor != null)
{
distanceSqr = (actor.transform.position - _position).sqrMagnitude;
return(_rangeSqr >= distanceSqr);
}
distanceSqr = 0f;
return(false);
}
public void Clear()
{
if (this is EntityMyself && PlayerManager.singleton.MySelf == null)
{
return;
}
if (this.timer.Count != 0)
{
foreach (var id in timer)
{
TimerManager.DelTimer(id);
}
this.timer.Clear();
}
if (this.Effcets.Count != 0)
{
foreach (var effect in this.Effcets)
{
PoolManager.Pools[PoolManager.EffectPoolName].Despawn(effect.transform);
}
this.Effcets.Clear();
}
PoolManager.Pools[PoolManager.EffectPoolName].Despawn(Transform);
this.collider2d.enabled = false;
this.entityActor.enabled = false;
this.animator = null;
this.fsmMotion = null;
_2dxFX_DesintegrationFX deadFx = this.GameObject.GetComponent <_2dxFX_DesintegrationFX>();
if (deadFx != null)
{
deadFx.Desintegration = 0;
}
this.entityActor = null;
this.audioSource.clip = null;
this.audioSource = null;
}
public P_BMSPlayerSelectingTile(P_BattleMap map)
{
map.MyState = this;
Random rng = new Random();
DebugBox = new TilerIsADummy.PrototypeMapGen.PrototypeTextBox.P_DebugBattleBox(map);
DebugBox.AcceptP_Render(map.Renderer);
DebugBox.AcceptUpdater(map.Updater);
while (true)
{
int num = rng.Next(0, map.MapEntity.Count);
if (map.MapEntity[num].GetType() == typeof(EntityActor))
{
EntityActor check = map.MapEntity[num] as EntityActor;
if (check.TurnStatus == EntityCharacterTurnStatus.MyTurn && check.MyTileIndex > 0)
{
_Cursor = new P_SelectionCursor(check.MyLocation);
_Cursor.AcceptP_Render(map.Renderer);
CursorIndex = check.MyTileIndex;
break;
}
}
}
}
public void TestUpdate()
{
var mockComponentActorFactory = new Mock <IComponentActorFactory>();
mockComponentActorFactory.Setup(f => f.GetOrCreateActorForComponent(It.IsAny <EntityComponent>())).Returns(
(EntityComponent component) =>
{
return(Sys.ActorOf(Props.Create(() => new EntityTestActor(component.Id)), $"{component.Id}"));
}
);
var entity = new Entity
{
new Utils.TestComponent(),
new Utils.TestComponent(),
new Utils.TestComponent()
};
IActorRef entityActor = Sys.ActorOf(EntityActor.Props(entity, mockComponentActorFactory.Object));
entityActor.Tell(new Update(new GameTime()));
ExpectMsgAllOf(entity.Select(c => c.Id).ToArray());
ExpectNoMsg(500);
}
protected void HasRootEntity <TAccessor>(TAccessor accessor, IBulkRepository <TRootEntity> repository, params IActor[] valueObjectActors)
where TAccessor : IStorageBasedDataObjectAccessor <TRootEntity>, IDataChangesHandler <TRootEntity>
{
_root = new EntityActor <TRootEntity>(_query, repository, _equalityComparerFactory, accessor, accessor, valueObjectActors);
}
public P_ActorRenderComponent(EntityActor actor)
{
_Graphic = new char[1];
_Graphic[0] = '@';
_MyActor = actor;
}
