public void AddToTest()
{
var ctx = new SimulationContext(true);
Random random = new Random();
List <Entity> testEntities = CreateEntities(ctx.LocalSpace, 100);
EntityPool original = new EntityPool(ctx);
foreach (var e in testEntities)
{
Assert.IsTrue(original.Insert(e));
}
original.VerifyIntegrity();
var h0 = original.HashDigest;
for (int i = 0; i < 100; i++)
{
EntityPool compare = new EntityPool(ctx);
random.Shuffle(testEntities);
foreach (var e in testEntities)
{
Assert.IsTrue(compare.Insert(e));
}
compare.VerifyIntegrity();
var h1 = compare.HashDigest;
Assert.AreEqual(h0, h1);
}
}
public void EntityMotionTest()
{
int numEntities = 100;
var ctx = new SimulationContext(true);
EntityPool pool = new EntityPool(EntityPoolTests.CreateEntities(ctx.LocalSpace, numEntities, i => new RandomMotion()), ctx);
InconsistencyCoverage ic = InconsistencyCoverage.NewCommon();
for (int i = 0; i < 100; i++)
{
var old = pool.ToArray();
EntityChangeSet set = new EntityChangeSet();
ctx.SetGeneration(i);
var errors = pool.TestEvolve(set, InconsistencyCoverage.NewCommon(), i, TimeSpan.FromSeconds(1));
Assert.IsNull(errors, errors != null ? errors[0].ToString() : "");
Assert.AreEqual(numEntities, set.FindNamedSet("motions").Size);
foreach (var e in old)
{
var m = set.FindMotionOf(e.ID.Guid);
Assert.IsNotNull(m);
Assert.AreNotEqual(m.TargetLocation, m.Origin.Position, i.ToString());
Assert.IsTrue(Simulation.FullSimulationSpace.Contains(m.TargetLocation));
Assert.IsTrue(Simulation.MySpace.Contains(m.TargetLocation));
}
Assert.AreEqual(0, set.Execute(pool, ic, ctx));
Assert.AreEqual(numEntities, pool.Count);
Entity e1;
foreach (var e in old)
{
Assert.IsTrue(pool.Find(e.ID.Guid, out e1));
Assert.AreNotEqual(e.ID.Position, e1.ID.Position);
}
}
}
public static void Initialize()
{
asteroidPool = new EntityPool<Asteroid>(() => { return new Asteroid(); }, 3*InitialAsteroidCount);
laserPool = new EntityPool<Laser>(() => { return new Laser(); }, 300);
shipPool = new EntityPool<Ship>(() => { return new Ship(); }, 8 * InitialShipCount);
planetPool = new EntityPool<Planet>(() => { return new Planet(); }, 3*(int)Planets.Count );
}
public PewLaser(EntityPreset preset, Player player)
: base(preset.Position, "pew_laser", 16, 16, DrawOrder.ENTITIES)
{
immovable = true;
bool isFast = false;
int frame = preset.Frame % 4;
SetFrame(frame);
if (preset.Frame >= 4)
{
isFast = true;
}
facing = (frame) switch
{
1 => Facing.RIGHT,
2 => Facing.UP,
3 => Facing.LEFT,
_ => Facing.DOWN,
};
lasers = new EntityPool <Laser>(5, () => new Laser(facing, isFast));
}
public static void CreateInstance()
{
if (_instance == null)
{
_instance = new EntityPool();
}
}
public void LoadMap(List <TClass> entities, IQueryable <TClass> query)
{
var entityPool = new EntityPool();
var deDupe = GenericProcessor.ProcessEntities(entityPool, query.GetDataContext <IDataContext>(), entities);
entities.Clear();
entities.AddRange(deDupe);
foreach (var propertyAccessor in Properties.OrderBy(x => x.PropertyName))
{
if (propertyAccessor is PropertyAccessor <TClass> accessorImpl)
{
accessorImpl.Load(entityPool, entities, query);
}
else if (typeof(TClass).IsAssignableFrom(propertyAccessor.DeclaringType))
{
dynamic dynamicAccessor = propertyAccessor;
LoadForInheritedType(entityPool, dynamicAccessor, entities, query);
}
else
{
throw new PropertyAccessorNotFoundException($"PropertyAccessor<{typeof(TClass).Name}> not found");
}
}
}
public void SimpleEntityFaultTest()
{
var ctx = new SimulationContext(true);
EntityPool pool = new EntityPool(EntityPoolTests.CreateEntities(ctx.LocalSpace, 100,
new RandomLogic(new Type[] { typeof(ConsistentLogic), typeof(FaultLogic) }).Instantiate), ctx);
InconsistencyCoverage ic = InconsistencyCoverage.NewCommon();
int any = -1;
for (int i = 0; i < 8; i++)
{
EntityChangeSet set = new EntityChangeSet();
ctx.SetGeneration(i);
var errors = pool.TestEvolve(set, ic, i, TimeSpan.FromSeconds(1));
if (errors != null)
{
Assert.IsTrue(ic.OneCount > 0);
if (any == -1)
{
any = i;
}
}
ic = ic.Grow(true);
Assert.IsTrue(ic.Size == InconsistencyCoverage.CommonResolution);
}
if (any == 0)
{
Assert.AreEqual(ic.OneCount, ic.Size.Product);
}
}
public void UpdateEntityTest()
{
var ctx = new SimulationContext(true);
Random random = new Random();
EntityPool pool = new EntityPool(ctx);
var entities = CreateEntities(ctx.LocalSpace, 3);
foreach (var e in entities)
{
Assert.IsTrue(pool.Insert(e));
}
for (int i = 0; i < 10; i++)
{
Entity old = entities[0];
Entity moved = Relocate(old);
Assert.IsTrue(pool.Contains(old.ID));
Assert.IsTrue(pool.UpdateEntity(entities[0], moved), "Update moved entity " + i);
Assert.IsFalse(pool.Contains(old.ID));
entities[0] = moved;
Assert.AreEqual(pool.Count, entities.Count);
foreach (var e in entities)
{
Assert.IsTrue(pool.Contains(e.ID.Guid));
Assert.IsTrue(pool.Contains(e.ID));
}
}
}
public override void Configure()
{
opt.OptionEntity.buff = "buffGiant"; // todo: from biome
string za = string.Join(",", biome.zombies, biome.animals);
opt.OptionEntity.entity = Hashes.Rand(za.Split(','), seed, "giantZombie"); // todo: from biome
EntityPool = new EntityPool(opt.OptionEntity.entity); // TODO: ref to reflect attibut change ?
Printer.Log(60, "Giant Configure: done");
}
private static void LoadForInheritedType <T>(EntityPool entityPool, IPropertyAccessor <T> accessor, List <TClass> propertyEntities, IQueryable <TClass> query)
where T : class
{
var accessorImpl = (PropertyAccessor <T>)accessor;
var entitiesOfType = propertyEntities.OfType <T>().ToList();
var queryOfType = query.OfType <T>();
accessorImpl.Load(entityPool, entitiesOfType, queryOfType);
}
public void Initialize(GameModel gameModel, InputManager inputManager)
{
asteroidPool = new EntityPool <Asteroid>(() => { return(new Asteroid(gameModel)); }, 3 * InitialAsteroidCount);
laserPool = new EntityPool <Laser>(() => { return(new Laser(gameModel)); }, 300);
shipPool = new EntityPool <Ship>(() => { return(new Ship(gameModel)); }, 8 * InitialShipCount);
planetPool = new EntityPool <Planet>(() => { return(new Planet(gameModel)); }, 3 * (int)Planets.Count);
_gameModel = gameModel;
_inputManager = inputManager;
}
public void StateAdvertisementTest()
{
var ctx = new SimulationContext();
EntityPool pool = RandomDefaultPool(100, ctx);
for (int i = 0; i < 100; i++)
{
EntityChangeSet set = new EntityChangeSet();
ctx.SetGeneration(i);
var errors = pool.TestEvolve(set, InconsistencyCoverage.NewCommon(), i, TimeSpan.FromSeconds(5));
Assert.IsNull(errors, errors != null ? errors[0].ToString() : "");
Assert.AreEqual(0, set.Execute(pool, ctx));
HashSet <Guid> env = new HashSet <Guid>();
var state = pool.ToArray();
int it = 0;
foreach (var e in state)
{
env.Clear();
foreach (var e1 in state)
{
float dist = ctx.GetDistance(e.ID.Position, e1.ID.Position);
if (e1.ID.Guid != e.ID.Guid && dist <= Simulation.SensorRange)
{
Console.WriteLine(dist + "/" + Simulation.SensorRange);
env.Add(e1.ID.Guid);
}
}
Assert.AreEqual(env.Count, e.Contacts.Length, i + "." + it + ": " + e);
if (env.Count > 0)
{
it++;
}
foreach (var c in e.Contacts)
{
float dist = ctx.GetDistance(c.ID.Position, e.ID.Position);
Assert.IsTrue(dist <= Simulation.SensorRange, dist + " <= " + Simulation.SensorRange);
Assert.AreNotEqual(c.ID.Guid, e.ID.Guid);
Assert.IsTrue(env.Contains(c.ID.Guid));
}
var app = e.Appearances.Get <ConsistencyAppearance>();
if (i > 0)
{
Assert.IsNotNull(e.Appearances);
Assert.IsNotNull(app);
}
if (app != null)
{
Assert.IsTrue(app.IsConsistent);
}
}
}
}
void Awake()
{
if (instance != null)
{
Debug.LogError("More than 1 instance of EntityPool in the scene!");
return;
}
instance = this;
}
public override void Configure()
{
string[] buffs = biome.buffGhost.Split(',');
// buffs = new string[]{"buffZBShoking"}; // "buffZBFiring"
// TODO: randomize from biome (if we convert everything ...)
opt.OptionEntity.entity = Hashes.Rand(ghosts, seed, "ghost");
opt.OptionEntity.buff = Hashes.Rand(buffs, seed, "buff");
EntityPool = new EntityPool(opt.OptionEntity.entity, 30);
Printer.Log(60, "MovingGhost Configure: done");
}
public static EntityPool RandomPool(int numEntities, EntityChange.ExecutionContext ctx)
{
var rs = new EntityPool(ctx);
var entities = CreateEntities(ctx.LocalSpace, numEntities);
foreach (var e in entities)
{
Assert.IsTrue(rs.Insert(e));
}
return(rs);
}
public Slime(EntityPreset preset, Player player)
: base(preset, preset.Position, "slime", 16, 16, DrawOrder.ENTITIES)
{
_type = preset.Frame == 3 ? SlimeType.Bullet : SlimeType.Normal;
int o = GlobalState.IsCell ? 4 : 0;
AddAnimation("Move", CreateAnimFrameArray(0 + o, 1 + o), 3);
AddAnimation("Hurt", CreateAnimFrameArray(0 + o, 8, 0 + o, 8), 15, false);
AddAnimation("Dying", CreateAnimFrameArray(0 + o, 8, 0 + o, 8), 12, false);
goos = new EntityPool <Goo>(8, () => new Goo());
target = player;
if (_type == SlimeType.Bullet)
{
bullets = new EntityPool <Bullet>(4, () => new Bullet());
_speed *= 2;
}
state = new StateMachineBuilder()
.State <MoveState>("Move")
.Enter((state) =>
{
Play("Move");
state.Advance((float)(DateTime.Now - state.exit_time).TotalSeconds);
if (_type == SlimeType.Bullet)
{
state.AddTimer(1.8f, "ShootTimer");
}
})
.Update((state, time) => SyncSplash(state))
.Event("ShootTimer", (state) => bullets.Spawn(b => b.Spawn(this, target)))
.Event("MoveTimer", (state) => ChangeDir())
.Event <CollisionEvent <Player> >("Player", (state, p) => p.entity.ReceiveDamage(1))
.Event <CollisionEvent <Broom> >("Hit", (state, b) => GetHit(b.entity))
.Exit((s) =>
{
s.exit_time = DateTime.Now;
})
.End()
.State("Hurt")
.Enter((state) => Play("Hurt"))
.Event <CollisionEvent <Player> >("Player", (state, p) => p.entity.ReceiveDamage(1))
.Condition(() => _health <= 0, (state) => state.Parent.ChangeState("Dying"))
.Condition(() => _curAnim.Finished, (state) => state.Parent.ChangeState("Move"))
.End()
.State("Dying")
.Enter((state) => Play("Dying"))
.Condition(() => _curAnim.Finished, (state) => { GlobalState.SpawnEntity(new Explosion(this)); Die(); })
.End()
.Build();
state.ChangeState("Move");
}
public SteamPipe(EntityPreset preset, Player player)
: base(preset.Position, "steam_pipe", 16, 16, DrawOrder.ENTITIES)
{
_player = player;
Vector2 startPos = Vector2.Zero;
SetFrame(preset.Frame);
switch (GetFrame())
{
case 0:
width = 10;
offset = new Vector2(3, 16);
startPos = Position + new Vector2(2, 10);
facing = Facing.DOWN;
break;
case 1:
height = 10;
offset = new Vector2(14, 5);
startPos = Position + new Vector2(14, 5);
facing = Facing.RIGHT;
break;
case 2:
width = 10;
offset = new Vector2(3, -4);
startPos = Position + new Vector2(3, -2);
facing = Facing.UP;
break;
case 3:
height = 10;
offset = new Vector2(-6, 3);
startPos = Position + new Vector2(-6, 3);
facing = Facing.LEFT;
break;
}
Position += offset;
_steam = new EntityPool <Steam>(6, () => new Steam(startPos, this));
_steam.Spawn(s => s.Spawn(), 6);
}
public Face() : base(MapUtilities.GetRoomUpperLeftPos(GlobalState.CurrentMapGrid) + Vector2.UnitX * (160 - 64) / 2, "f_wallboss_face", 64, 32, Drawing.DrawOrder.ENTITIES)
{
AddAnimation("normal", CreateAnimFrameArray(0, 2), 5);
AddAnimation("hurt", CreateAnimFrameArray(3, 5), 14);
AddAnimation("charge", CreateAnimFrameArray(1), 5);
AddAnimation("shoot", CreateAnimFrameArray(4), 10);
Play("normal");
state = StateLogic();
bullets = new(8, () => new(this));
}
public Slime(EntityPreset preset, Player player)
: base(preset.Position, "slime", 16, 16, DrawOrder.ENTITIES)
{
_preset = preset;
_type = _preset.Frame == 3 ? SlimeType.Bullet : SlimeType.Normal;
AddAnimation("Move", CreateAnimFrameArray(0, 1), 3);
AddAnimation("Hurt", CreateAnimFrameArray(0, 8, 0, 8), 15);
AddAnimation("Dying", CreateAnimFrameArray(0, 8, 0, 8), 12, false);
goos = new EntityPool <Goo>(8, () => new Goo());
target = player;
if (_type == SlimeType.Bullet)
{
bullets = new EntityPool <Bullet>(4, () => new Bullet());
_speed *= 2;
}
state = new StateMachineBuilder()
.State <MoveState>("Move")
.Enter((state) =>
{
Play("Move");
state.Reset();
state.AddTimer(0.5f, "MoveTimer");
if (_type == SlimeType.Bullet)
{
state.AddTimer(1.8f, "ShootTimer");
}
})
.Update((state, time) => SyncSplash(state))
.Event("ShootTimer", (state) => bullets.Spawn(b => b.Spawn(this, target)))
.Event("MoveTimer", (state) => ChangeDir())
.Event <CollisionEvent <Player> >("Player", (state, p) => p.entity.ReceiveDamage(1))
.Event <CollisionEvent <Broom> >("Hit", (state, b) => GetHit(b.entity))
.End()
.State("Hurt")
.Enter((state) => Play("Hurt"))
.Event <CollisionEvent <Player> >("Player", (state, p) => p.entity.ReceiveDamage(1))
.Condition(() => _health <= 0, (state) => state.Parent.ChangeState("Dying"))
.Condition(() => finished, (state) => state.Parent.ChangeState("Move"))
.End()
.State("Dying")
.Enter((state) => Play("Dying"))
.Condition(() => finished, (state) => { _preset.Alive = false; Die(); })
.End()
.Build();
state.ChangeState("Move");
}
public static IEnumerator _Ghosts(Vector3 ppos)
{
/* Using bear ghost creates Warning, when ZMoe ghost does not ...
* but moe stops moving ?
*/
//EntityPool EntityPool = new EntityPool("zombieMoeGhost", 20);
// EntityPool EntityPool = new EntityPool("animalBearGhost", 20);
// EntityPool EntityPool = new EntityPool("animalChickenGhost", 20);
EntityPool EntityPool = new EntityPool("animalChickenGhostV2", 20);
HashSet <Entity> done = new HashSet <Entity>();
lastExec = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
while (true)
{
lastExec = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
Bounds area = new Bounds(ppos, new Vector3(40, 40, 40));
EntityPool.Update(area);
foreach (Entity entity in EntityPool.Entities)
{
lastExec = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
if (entity == null)
{
continue;
}
if (entity as EntityAlive == null)
{
continue;
}
if (_StopGhost)
{
Attaching.Remove(entity as EntityAlive, currentName);
// if (done.Contains(entity)) done.Remove(entity);
done.Clear();
}
else
{
if (done.Contains(entity))
{
continue;
}
Attaching.Apply(entity as EntityAlive, currentName);
done.Add(entity);
}
lastExec = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
yield return(new WaitForEndOfFrame());
}
lastExec = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
yield return(new WaitForEndOfFrame());
}
}
// Use this for initialization
void Start()
{
pool = EntityPoolBuilder.FindByName("TestPool");
ZEntity en = pool.CreateEntity(1);
Debug.Log(" en data is " + en.GetComponent <TestComponent4> ().data4.ToString());
//test singleton
TestSingleton test = SingletonEntity <TestSingleton> .Instance;
if (test != null)
{
Debug.Log(" SingletonEntity data is " + test.data2.ToString());
}
}
public Big_Key(EntityPreset preset, Player p) : base(preset.Position, "key_green", 16, 16, Drawing.DrawOrder.ENTITIES)
{
_preset = preset;
_player = p;
SetFrame(preset.Frame);
immovable = true;
width = 9;
offset.X = 4;
Position.X += 4;
shadow = new(this, Vector2.One * 4);
shadow.visible = false;
_sparkles = new(3, () => new());
state = States();
}
public override bool Execute(EntityPool pool, ExecutionContext ctx)
{
if (!ctx.CheckM("Insert", Origin.Position, TargetLocation))
{
return(false);
}
if (!ctx.LocalSpace.Contains(TargetLocation))
{
return(false);
}
pool.ConflictFreeInsert(Origin, new Entity(new EntityID(Guid.NewGuid(), TargetLocation), Vec3.Zero, directState, SerialLogic
#if STATE_ADV
, Appearances
#endif
));
directState = null;
return(true);
}
public Frog(EntityPreset preset, Player p) : base(preset, preset.Position, "frog", 16, 16, Drawing.DrawOrder.ENTITIES, 0.7f)
{
AddAnimation("idle", CreateAnimFrameArray(0, 1), 2, true);
AddAnimation("shoot_d", CreateAnimFrameArray(3), 3, false);
AddAnimation("shoot_r", CreateAnimFrameArray(4), 3, false);
AddAnimation("shoot_l", CreateAnimFrameArray(4), 3, false);
AddAnimation("shoot_u", CreateAnimFrameArray(5), 3, false);
Play("idle");
immovable = true;
_player = p;
int i = 0;
_bullets = new(3, () => new(i++));
_state = new StateMachineBuilder()
.State <TimerState>("Initial")
.Enter((s) =>
{
s.Reset();
s.AddTimer(0.8f, "goToIdle");
})
.Event("goToIdle", (s) => _state.ChangeState("Idle"))
.End()
.State("Idle")
.Enter((s) =>
{
Play("idle");
})
.Condition(() => (Center - _player.Center).LengthSquared() < 64 * 64, (s) =>
{
_bullets.Spawn((b) => b.Spawn(this, _player), 3);
FaceTowards(_player.Center);
PlayFacing("shoot");
SoundManager.PlaySoundEffect("bubble_triple");
_state.ChangeState("BulletsFlying");
})
.End()
.State("BulletsFlying")
.Condition(() => _bullets.Alive == 0, (s) => _state.ChangeState("Idle"))
.End()
.Build();
_state.ChangeState("Initial");
}
public void MotionConflictOrderingTest()
{
var ctx = new SimulationContext(true);
for (int i = 0; i < 10; i++)
{
var entities = CreateEntities(ctx.LocalSpace, 1);
var e = entities[0];
Vec3 original = e.ID.Position;
EntityChange.Motion[] motions = new EntityChange.Motion[10];
for (int j = 0; j < motions.Length; j++)
{
motions[j] = new EntityChange.Motion(new EntityID(e.ID.Guid, random.NextVec3(0, 1)), ctx.LocalSpace.Clamp(original + random.NextVec3(-ctx.Ranges.R, ctx.Ranges.R)), e.MyLogic, null);
}
Entity e0 = null;
for (int j = 0; j < motions.Length; j++)
{
var motions2 = motions.OrderBy(x => random.Next()).ToArray();
EntityPool pool = new EntityPool(entities, ctx);
EntityChangeSet set = new EntityChangeSet();
foreach (var m in motions2)
{
set.Add(m);
}
int errors = set.Execute(pool, InconsistencyCoverage.NewAllOne(), ctx);
Assert.AreEqual(motions.Length - 1, errors); //motions-1 get rejected, one is accepted. must always be the same
var e1 = pool.First();
Assert.AreNotEqual(e1, e); //must have moved
if (e0 == null)
{
e0 = e1;
}
else
{
Assert.AreEqual(e0, e1); //must have moved to the same location
}
}
}
}
public Red_Boss(EntityPreset preset, Player p) : base(preset.Position, "red_boss", 32, 32, Drawing.DrawOrder.ENTITIES)
{
height = 19;
width = 26;
offset = new Vector2(3, 13);
AddAnimation("bob", CreateAnimFrameArray(0), 20);
AddAnimation("close_eyes", CreateAnimFrameArray(1), 10, false);
AddAnimation("warn", CreateAnimFrameArray(2), 24);
AddAnimation("die", CreateAnimFrameArray(0, 1, 2, 1), 3, false);
Play("close_eyes");
ripple = new(this);
Vector2 tl = MapUtilities.GetRoomUpperLeftPos(GlobalState.CurrentMapGrid);
Point splash_start = new(2, 2);
splash_bullets = new(4, () =>
{
splash_start.Y++;
return(new(tl + splash_start.ToVector2() * 16 + Vector2.One * 3));
});
int start = 0;
tentacles = new(4, () => new(start++));
sensors = new ProximitySensor[]
{
new(Touching.LEFT, this),
new(Touching.RIGHT, this),
new(Touching.UP, this),
new(Touching.DOWN, this),
};
small_wave = new(this);
big_wave = new(this);
player = p;
this.preset = preset;
state = State();
}
public override bool Execute(EntityPool pool, ExecutionContext ctx)
{
Vec3?loc;
var rs = pool.CheckFindAndRemove(Target, e => ctx.CheckM("Removal", Target.Position, e), out loc);
switch (rs)
{
case EntityPool.Result.NoError:
return(true);
case EntityPool.Result.IDNotFoundLocationMismatch:
case EntityPool.Result.IDNotFound:
case EntityPool.Result.VerificationFailed:
return(false); //do not distinbuish. these errors could all be either caused by bad node states OR bad entity behavior
default:
throw new IntegrityViolation(Target + ": Unsupported CheckFindAndRemove() return value (" + rs + ")");
}
}
public Burst_Plant(EntityPreset preset, Player p) : base(preset, preset.Position, "burst_plant", 16, 16, Drawing.DrawOrder.ENTITIES, 0.7f)
{
AddAnimation("idle", CreateAnimFrameArray(0));
AddAnimation("charging", CreateAnimFrameArray(0, 1), 8);
AddAnimation("shoot", CreateAnimFrameArray(3));
Play("idle");
immovable = true;
_bullets = new(8, () => new());
_state = new StateMachineBuilder()
.State <TimerState>("Initial")
.Enter((s) => s.AddTimer(0.4f, "goToIdle"))
.Event("goToIdle", (s) => _state.ChangeState("Idle"))
.End()
.State <TimerState>("Idle")
.Enter((s) =>
{
Play("idle");
s.Reset();
s.AddTimer(0.4f + (float)GlobalState.RNG.NextDouble(), "idleTimer");
})
.Event("idleTimer", (s) => _state.ChangeState("Charging"))
.End()
.State <ChargeState>("Charging")
.Enter((s) => Play("charging"))
.Event("Fire", (s) =>
{
int sign = MathUtilities.OneRandomOf(-1, 1);
float max_vel = 10 + 30 * (float)GlobalState.RNG.NextDouble();
_bullets.Spawn((b) => b.SpawnToPlayer(this, max_vel, p)); //one straight to the player
_bullets.Spawn((b) => b.Spawn(this, max_vel, sign), 7);
Play("shoot");
SoundManager.PlaySoundEffect("bubble_triple");
_state.ChangeState("BulletsFlying");
})
.End()
.State("BulletsFlying")
.Condition(() => _bullets.Alive == 0, (s) => _state.ChangeState("Idle"))
.End()
.Build();
_state.ChangeState("Initial");
}
public override bool Execute(EntityPool pool, ExecutionContext ctx)
{
Int3 opCoords = TargetLocation.FloorInt3;
if (ctx.LocalSpace.Contains(Origin.Position))
{
Entity e;
if (!pool.Find(Origin.Guid, out e))
{
return(false);
}
if (!ctx.CheckM("Motion", TargetLocation, e))
{
return(false);
}
if (ctx.LocalSpace.Contains(TargetLocation))
{
pool.ConflictFreeUpdateEntity(Origin, Entity);
}
else
{
pool.ConflictFreeFindAndRemove(e.ID);
}
return(true);
}
else
{
if (!ctx.LocalSpace.Contains(TargetLocation))
{
ctx.LogMessage("Motion: Shard coordinate mismatch. Local=" + ctx.LocalSpace + ", target=" + TargetLocation);
return(false);
}
if (!ctx.CheckM("Motion", Origin.Position, TargetLocation))
{
return(false);
}
pool.ConflictFreeInsert(Origin, Entity);
return(true);
}
}
private void InstantiateSystemsManager()
{
SystemsManager = Instantiate(new GameObject());
SystemsManager.name = "SystemsManager";
movementSystem = SystemsManager.AddComponent <MovementSystem>();
keyboardInputSystem = SystemsManager.AddComponent <KeyboardInputSystem>();
mouseInputSystem = SystemsManager.AddComponent <MouseInputSystem>();
factorySystem = SystemsManager.AddComponent <FactorySystem>();
lSystemSystem = SystemsManager.AddComponent <LSystemSystem>();
lSystemFactorySystem = SystemsManager.AddComponent <LSystemFactorySystem>();
entityPool = SystemsManager.AddComponent <EntityPool>();
entityPool.InitialiseEntitiesList();
movementSystem.entityPool = entityPool;
keyboardInputSystem.entityPool = entityPool;
mouseInputSystem.entityPool = entityPool;
factorySystem.entityPool = entityPool;
lSystemSystem.entityPool = entityPool;
lSystemFactorySystem.entityPool = entityPool;
}
