public void Initialize(EntityRegistry registry, EventSystem eventSystem) { mPostProcessList = new List <Entity>(registry.Capacity); registry.SetupSlice(ref mRectNoShape); registry.SetupSlice(ref mNoRect); registry.SetupSlice(ref mHasRect); }
private void UpdateControlState(EntityRegistry registry) { int count = mPlayersSlice.Player.Count; for (int i = 0; i < count; ++i) { int playerIndex = mPlayersSlice.Player[i].Index; GamePadState state = GamePad.GetState(playerIndex); FrogControlState controlState = new FrogControlState(); controlState.JumpSignal = state.IsButtonDown(Buttons.A); controlState.ToungueSignalState = state.IsButtonDown(Buttons.X); Vector2 direction = state.ThumbSticks.Left; float rawMagnitude = direction.Length(); if (rawMagnitude >= kMinMagnitude) { direction.Normalize(); } else { direction = Vector2.Zero; } controlState.InputDirection = direction; Entity controlledFrog = mPlayersSlice.ControlledEntity[i].Entity; registry.SetComponent(controlledFrog, controlState); } }
public void Update(EntityRegistry registry, EventSystem eventSystem) { mDevice.Clear(Color.SkyBlue); const float kCharachterDepth = 10f; int frogCount = mFrogRectSlice.Rect.Count; for (int i = 0; i < frogCount; ++i) { mFrogRenderer.PushFrog(mFrogRectSlice.Rect[i], kCharachterDepth, mFrogRectSlice.Animation[i]); } mFrogRenderer.Render(mCameraMatrix, mDevice); RenderLilies(); int rectCount = mColoredRectSlice.Rect.Count; for (int i = 0; i < rectCount; ++i) { mRenderer.PushRect(mColoredRectSlice.Rect[i], kCharachterDepth, mColoredRectSlice.Color[i]); } RenderLetterBox(); RenderUI(); RenderWaterBackground(); mRenderer.RenderAndFlush(mDevice, mBasicEffect); RenderWater(); }
public void Update(EntityRegistry registry, EventSystem eventSystem) { int count = mTounguesWithPosition.Entity.Count; for (int i = 0; i < count; ++i) { Entity parentFrog = mTounguesWithPosition.ParentFrog[i].Parent; //TODO: The following could be done with a frog slice if there was a clean way to fetch random entities from the slice. Entity output could do that. Debug.Assert(registry.IsValid(parentFrog)); Debug.Assert(registry.HasComponent <Facing>(parentFrog)); Debug.Assert(registry.HasComponent <Rect>(parentFrog)); Rect frogRect = registry.GetComponent <Rect>(parentFrog); int facing = registry.GetComponent <Facing>(parentFrog).CurrentFacing; Vector2 extendDirection; Vector2 anchor; if (facing >= 0f) { extendDirection = Vector2.UnitX; anchor = frogRect.MaxCorner; } else { extendDirection = -Vector2.UnitX; anchor = frogRect.MinMaxCorner; } RectShape toungueShape = mTounguesWithPosition.CurrentShape[i]; anchor -= (toungueShape.Height * mShapeData.RelativeVerticalOffset * Vector2.UnitY); anchor += toungueShape.Width * extendDirection * 0.5f; Entity toungueEntity = mTounguesWithPosition.Entity[i]; registry.SetComponent <Position>(toungueEntity, new Position(anchor)); } }
private void SetAnimationFrame(EntityRegistry registry, Entity entity, int frameIndex) { float minX = frameIndex * mFrameWidth; float maxX = minX + mFrameWidth; registry.SetComponent(entity, new AnimationState(minX, maxX)); }
public void Update(EntityRegistry registry, EventSystem eventSystem) { SetAnimationFrames(registry, mLandedFrog.Entity, mData.LandedFrame); SetAnimationFrames(registry, mJumpingFrogSlice.Entity, mData.JumpingFrame); UpdateSwimAnimation(registry); UpdateFacing(registry); }
private void CheckOutOfBoundsFlies(EntityRegistry registry) { int waitingCount = mWaitingToChange.Entity.Count; for (int i = waitingCount - 1; i >= 0; --i) { bool flyingLow = mWaitingToChange.Position[i].Value.Y < (mFlyData.MinHeight + mPond.WaterLevel); bool forceChange = flyingLow || (mWaitingToChange.Position[i].Value.Y > (mFlyData.MaxHeight + mPond.WaterLevel)); if (forceChange) { Vector2 velocity = mWaitingToChange.Velocity[i].Value; float angle = mChangeData.TurnAroundRate * mTime.DeltaTime; if ((velocity.X < 0) && flyingLow) { angle = -angle; } else if ((velocity.X > 0) && !flyingLow) { angle = -angle; } Vector2 newVelocity = MathExtensions.Rotate(velocity, angle); registry.SetComponent(mWaitingToChange.Entity[i], new Velocity(newVelocity)); } } }
public void Update(EntityRegistry registry, EventSystem eventSystem) { mDevice.Clear(Color.DimGray); RenderLilies(); int frogCount = mFrogRectSlice.Rect.Count; for (int i = 0; i < frogCount; ++i) { mFrogRenderer.PushFrog(mFrogRectSlice.Rect[i], mFrogRectSlice.Animation[i]); } mFrogRenderer.Render(mCameraMatrix, mDevice); int rectCount = mColoredRectSlice.Rect.Count; for (int i = 0; i < rectCount; ++i) { mRenderer.PushRect(mColoredRectSlice.Rect[i], mColoredRectSlice.Color[i]); } RenderWater(); mRenderer.Render(mCameraMatrix, mDevice); RenderUI(); }
public void Update(EntityRegistry registry, EventSystem eventSystem) { for (int i = mRectNoShape.Entities.Count - 1; i >= 0; --i) { registry.RemoveComponent <Rect>(mRectNoShape.Entities[i]); } int noRectCount = mNoRect.Entities.Count; for (int i = 0; i < noRectCount; ++i) { mPostProcessList.Add(mNoRect.Entities[i]); } foreach (Entity entity in mPostProcessList) { registry.AddComponent(entity, new Rect()); //The right data will be updated by the next slice } mPostProcessList.Clear(); int hasRectCount = mHasRect.Entities.Count; for (int i = 0; i < hasRectCount; ++i) { Vector2 position = mHasRect.Position[i].Value; RectShape rectShape = mHasRect.RectShape[i]; Rect rect = new Rect(position, rectShape.Width, rectShape.Height); registry.SetComponent(mHasRect.Entities[i], rect); } }
public void Update(EntityRegistry registry, EventSystem eventSystem) { UpdateControlState(registry); UpdateNoToungueFrogs(registry); UpdateLandedFrogs(registry); UpdateSwimingFrogs(registry); }
public void Initialize(EntityRegistry registry, EventSystem eventSystem) { registry.SetupSlice(ref mPlayersSlice); registry.SetupSlice(ref mLandedFrogs); registry.SetupSlice(ref mNoToungueFrogs); registry.SetupSlice(ref mWaterborneFrogs); }
private void UpdateSwimingFrogs(EntityRegistry registry) { int count = mWaterborneFrogs.Frogs.Count; for (int i = 0; i < count; ++i) { float swimKickPhase = mWaterborneFrogs.Waterborne[i].SwimKickPhase; if (swimKickPhase < 0f) { swimKickPhase = swimKickPhase + mTime.DeltaTime; if (swimKickPhase >= 0f) { swimKickPhase = mSwimData.SwimKickDuration; } } else if ((swimKickPhase > 0f) && (mWaterborneFrogs.ControlState[i].InputDirection != Vector2.Zero)) { swimKickPhase = Math.Max(0f, swimKickPhase - mTime.DeltaTime); } else if ((swimKickPhase != mSwimData.SwimKickDuration) && (mWaterborneFrogs.ControlState[i].InputDirection == Vector2.Zero)) { swimKickPhase = -mSwimData.SwimKickRecharge; } //TODO: Worth to validate the data changed? Waterborne waterBorne = new Waterborne(swimKickPhase); registry.SetComponent(mWaterborneFrogs.Frogs[i], waterBorne); } }
public void Update(EntityRegistry registry, EventSystem eventSystem) { int noScoreCount = mNoScoreSlice.Entity.Count; for (int i = noScoreCount - 1; i >= 0; --i) { registry.AddComponent(mNoScoreSlice.Entity[i], new Score()); } if (mScoreBuffer.Count > 0) { int playerCount = mScoreSlice.Entity.Count; for (int i = 0; i < playerCount; ++i) { int currentScore = mScoreSlice.Score[i].Value; Entity controlledFrog = mScoreSlice.ControlledEntity[i].Entity; foreach (Entity frog in mScoreBuffer) { if (frog == controlledFrog) { ++currentScore; } } registry.SetComponent(mScoreSlice.Entity[i], new Score(currentScore)); } mScoreBuffer.Clear(); } }
public void Initialize(EntityRegistry registry, EventSystem eventSystem) { registry.SetupSlice(ref mLandedFrog); registry.SetupSlice(ref mJumpingFrogSlice); registry.SetupSlice(ref mSwimingFrogSlice); registry.SetupSlice(ref mFacingSlice); }
private void SetAnimationFrames(EntityRegistry registry, SliceEntityOutput entities, int frameIndex) { int count = entities.Count; for (int i = 0; i < count; ++i) { SetAnimationFrame(registry, entities[i], frameIndex); } }
public void ReSendUsersLoaded(UsersLoadedEvent e, SingleNode <ClientSessionComponent> session) { EntityRegistry entityRegistry = Flow.Current.EntityRegistry; if (entityRegistry.ContainsEntity(e.RequestEntityId)) { base.ScheduleEvent <UsersLoadedInternalEvent>(entityRegistry.GetEntity(e.RequestEntityId)); } }
private Vector2 UpdateFrogSwimAndGetAcceleration(EntityRegistry registry, int iterationIndex) { Vector2 swimAcceleration = Vector2.Zero; if (mWetFrogs.Waterborne[iterationIndex].SwimKickPhase > 0f) { swimAcceleration = mSwimData.SwimAccelerationModule * mWetFrogs.Control[iterationIndex].InputDirection; } return(swimAcceleration); }
public void TestComponents() { EntityRegistry registry = new EntityRegistry(100); Entity entity1 = registry.Create(); Entity entity2 = registry.Create(); PositionComponent pos1 = new PositionComponent(1, 0); PositionComponent pos2 = new PositionComponent(0, 1); registry.AddComponent(entity1, new TagComponent()); registry.AddComponent(entity1, pos1); registry.AddComponent(entity2, pos2); registry.AddComponent(entity2, new ParentedComponent(entity1)); Assert.IsTrue(registry.HasComponent <TagComponent>(entity1)); Assert.IsFalse(registry.HasComponent <TagComponent>(entity2)); Assert.IsTrue(registry.HasComponent <PositionComponent>(entity1)); Assert.IsTrue(registry.HasComponent <PositionComponent>(entity2)); Assert.IsFalse(registry.HasComponent <ParentedComponent>(entity1)); Assert.IsTrue(registry.HasComponent <ParentedComponent>(entity2)); Assert.AreEqual(registry.GetComponent <PositionComponent>(entity1), pos1); Assert.AreEqual(registry.GetComponent <PositionComponent>(entity2), pos2); registry.Destroy(entity1); Assert.AreEqual(registry.GetComponent <PositionComponent>(entity2) , pos2); Assert.IsFalse(registry.IsValid(registry.GetComponent <ParentedComponent>(entity2).Parent)); Assert.IsFalse(registry.HasComponent <TagComponent>(entity2)); Assert.IsTrue(registry.HasComponent <PositionComponent>(entity2)); Assert.IsTrue(registry.HasComponent <ParentedComponent>(entity2)); Entity entity3 = registry.Create(); Entity entity4 = registry.Create(); registry.AddComponent(entity4, pos1); registry.AddComponent(entity3, pos1); registry.AddComponent(entity3, new ParentedComponent()); registry.AddComponent(entity4, new ParentedComponent()); Assert.IsFalse(registry.HasComponent <TagComponent>(entity3)); Assert.IsTrue(registry.HasComponent <PositionComponent>(entity3)); Assert.IsTrue(registry.HasComponent <PositionComponent>(entity4)); Assert.IsTrue(registry.HasComponent <ParentedComponent>(entity3)); Assert.IsTrue(registry.HasComponent <ParentedComponent>(entity4)); Assert.IsFalse(registry.HasComponent <TagComponent>(entity2)); Assert.IsTrue(registry.HasComponent <PositionComponent>(entity2)); Assert.IsTrue(registry.HasComponent <ParentedComponent>(entity2)); }
public virtual NbtCompound writeToNbt(NbtCompound tag) { tag.Add(new NbtInt("id", EntityRegistry.getIdFromEntity(this))); tag.Add(NbtHelper.writeVector3("position", this.transform.position)); tag.Add(NbtHelper.writeVector3("rotation", this.transform.eulerAngles)); tag.Add(NbtHelper.writeVector3("velocity", this.rBody.velocity)); tag.Add(NbtHelper.writeVector3("angularVelocity", this.rBody.angularVelocity)); return(tag); }
private void UpdateControlState(EntityRegistry registry) { int count = mPlayersSlice.Player.Count; for (int i = 0; i < count; ++i) { int playerIndex = mPlayersSlice.Player[i].Index; GamePadState state = GamePad.GetState(playerIndex); FrogControlState controlState = new FrogControlState(); Vector2 direction = Vector2.Zero; if (state.IsConnected) { controlState.JumpSignal = state.IsButtonDown(Buttons.A); controlState.ToungueSignalState = state.IsButtonDown(Buttons.X); direction = state.ThumbSticks.Left; } else { KeyboardState keyboardState = Keyboard.GetState(); if (keyboardState.IsKeyDown(Keys.Left)) { direction.X -= 1.0f; } if (keyboardState.IsKeyDown(Keys.Right)) { direction.X += 1.0f; } if (keyboardState.IsKeyDown(Keys.Down)) { direction.Y -= 1.0f; } if (keyboardState.IsKeyDown(Keys.Up)) { direction.Y += 1.0f; } controlState.JumpSignal = keyboardState.IsKeyDown(Keys.LeftControl); controlState.ToungueSignalState = keyboardState.IsKeyDown(Keys.Space); } float rawMagnitude = direction.Length(); if (rawMagnitude >= kMinMagnitude) { direction.Normalize(); } else { direction = Vector2.Zero; } controlState.InputDirection = direction; Entity controlledFrog = mPlayersSlice.ControlledEntity[i].Entity; registry.SetComponent(controlledFrog, controlState); } }
public void Update(EntityRegistry registry, EventSystem eventSystem) { int hasRectCount = mHasParentedRect.Entities.Count; for (int i = 0; i < hasRectCount; ++i) { Vector2 position = mHasParentedRect.Position[i].Value; RectShape rectShape = mHasParentedRect.RectShape[i]; Rect rect = new Rect(position, rectShape.Width, rectShape.Height); registry.SetComponent(mHasParentedRect.Entities[i], rect); } }
public Registry() { ScriptLoader.LoadScript("Entity", "Entity.lua"); ScriptLoader.AddCategory("Generator"); partRegistry = new PartRegistry(); entityRegistry = new EntityRegistry(); namesRegistry = new NameRegistry(); generator = new Generator(); }
public void TestEntityCreationAndDestruction() { const int kEntitiesToTest = 1000; int tests = 100; EntityRegistry registry = new EntityRegistry(kEntitiesToTest); Assert.IsFalse(registry.IsValid(Entity.NullEntity)); List <Entity> validEntities = new List <Entity>(kEntitiesToTest * 100); List <Entity> invalidEntities = new List <Entity>(kEntitiesToTest * 100); for (int i = 0; i < kEntitiesToTest; ++i) { validEntities.Add(registry.Create()); } Random randomizer = new Random(457); while (tests > 0) { --tests; for (int i = validEntities.Count - 1; i >= 0; --i) { Entity entity = validEntities[i]; if (randomizer.NextDouble() < 0.01) { Assert.IsTrue(registry.IsValid(entity)); registry.Destroy(entity); validEntities.RemoveAt(i); invalidEntities.Add(entity); } } for (int i = validEntities.Count; i < kEntitiesToTest; ++i) { if (randomizer.NextDouble() < 0.01) { Entity replacement = registry.Create(); validEntities.Add(replacement); } } } foreach (Entity entity in validEntities) { Assert.IsTrue(registry.IsValid(entity)); } foreach (Entity entity in invalidEntities) { Assert.IsFalse(registry.IsValid(entity)); } }
public void KeyValue(Edict pentKeyvalue, KeyValueData pkvd) { //Log.Message($"Entity {EntityDictionary.EntityIndex(pentKeyvalue)}/{EntityDictionary.Max} KeyValue ClassName=\"{pkvd.ClassName}\" Key=\"{pkvd.KeyName}\" Value=\"{pkvd.Value}\""); if (pkvd.KeyName == "classname") { if (pentKeyvalue.PrivateData == null) { Log.Message($"Creating entity \"{pkvd.Value}\""); //Create the entity instance EntityRegistry.CreateInstance <BaseEntity>(pentKeyvalue); Log.Message("Created entity"); } else { var ent = (BaseEntity)pentKeyvalue.PrivateData; //This should never happen if (pkvd.Value != ent.ClassName) { throw new InvalidOperationException($"Second occurence of classname keyvalue has different value (Expected: {ent.ClassName}, actual:{pkvd.Value})"); } pkvd.Handled = true; return; } } if (pentKeyvalue.PrivateData == null) { throw new InvalidOperationException($"Cannot set keyvalue \"{pkvd.KeyName}={pkvd.Value}\" on null entity of class {pkvd.ClassName}"); } pkvd.Handled = false; var entity = (BaseEntity)pentKeyvalue.PrivateData; //TODO: uniformly handle keyvalue initialization switch (pkvd.KeyName) { case "classname": { entity.ClassName = pkvd.Value; pkvd.Handled = true; break; } } }
public void Update(EntityRegistry registry, EventSystem eventSystem) { int count = mFallingEntities.Entities.Count; for (int i = 0; i < count; ++i) { Vector2 velocityDelta = Dynamics.NewtonianVelocityDelta(PondSimState.kGravity, mTime); //TODO: Data drive gravity! Vector2 newVelocity = mFallingEntities.Velocities[i].Value + velocityDelta; Vector2 frogPositionDelta = Dynamics.NewtonianPositionDelta(mFallingEntities.Velocities[i].Value, PondSimState.kGravity, mTime); Vector2 newPosition = mFallingEntities.Positions[i].Value + frogPositionDelta; //TODO: Deferred registry commands registry.SetComponent(mFallingEntities.Entities[i], new Velocity(newVelocity)); registry.SetComponent(mFallingEntities.Entities[i], new Position(newPosition)); } }
private void MakeToungue(EntityRegistry registry, Entity parentFrog) { Entity toungue = registry.Create(); ToungueState state = new ToungueState(ToungueStages.Extending, mData.GetStateTime(ToungueStages.Extending)); registry.AddComponent(toungue, state); registry.AddComponent(toungue, new RectShape()); registry.AddComponent(toungue, new Position()); registry.AddComponent(toungue, Color.Red); registry.AddComponent(toungue, new ParentEntity(parentFrog, new Vector2())); ControlledEntity controlledToungue = new ControlledEntity(toungue); registry.AddComponent(parentFrog, controlledToungue); }
public void Update(EntityRegistry registry, EventSystem eventSystem) { int count = mMovingFliesSlice.Entity.Count; for (int i = 0; i < count; ++i) { Vector2 newPosition = mMovingFliesSlice.Position[i].Value + mTime.DeltaTime * mMovingFliesSlice.Velocity[i].Value; mPositionBuffer[i] = new Position(newPosition); } //TODO: Is it *really* more efficient to use a buffer? for (int i = 0; i < count; ++i) { registry.SetComponent(mMovingFliesSlice.Entity[i], mPositionBuffer[i]); } }
public Entity MakeFrog(int index, EntityRegistry registry) { Entity frogEntity = registry.Create(); //Controller state FrogControlState controlState = new FrogControlState(); registry.AddComponent(frogEntity, controlState); //Position Component int spawnIndex = index % mPondData.FrogSpawns.Length; float spawnX = mPondData.FrogSpawns[spawnIndex]; float spawnY = mPondData.Height + mFrogData.Height; Vector2 positionValue = new Vector2(spawnX, spawnY); Position spawnPosition = new Position(positionValue); registry.AddComponent(frogEntity, spawnPosition); //Facing Facing facing = new Facing(); registry.AddComponent(frogEntity, facing); //Velocity Velocity velocity = new Velocity(); registry.AddComponent(frogEntity, velocity); //Shape RectShape rectShape = new RectShape(mFrogData.Width, mFrogData.Height); registry.AddComponent(frogEntity, rectShape); //Rect - Added automatically by the RectUpkeepSystem, but I don't want to worry about the first frame this being missing Rect rect = new Rect(spawnPosition.Value, rectShape.Width, rectShape.Height); //Gravity - Spawned in the air! Gravity gravity = new Gravity(); registry.AddComponent(frogEntity, gravity); //Animation AnimationState animation = new AnimationState(); registry.AddComponent(frogEntity, animation); return(frogEntity); }
public Entity MakePlayer(int index, EntityRegistry registry) { AssertIndexIsNotUsed(index); Entity playerEntity = registry.Create(); registry.AddComponent(playerEntity, new Player(index)); Entity frogEntity = mFrogFactory.MakeFrog(index, registry); ControlledEntity controlledEntity = new ControlledEntity(frogEntity); registry.AddComponent(playerEntity, controlledEntity); return(playerEntity); }
/// <summary> /// First time database initialization. /// </summary> /// <param name="entityRegistry">The storage of trade objects.</param> /// <param name="databaseRaw">Raw bytes of database file.</param> /// <param name="init">Initialization callback.</param> /// <returns>Path to the database file.</returns> public static string FirstTimeInit(this EntityRegistry entityRegistry, byte[] databaseRaw, Action <Database> init = null) { if (entityRegistry == null) { throw new ArgumentNullException(nameof(entityRegistry)); } if (databaseRaw == null) { throw new ArgumentNullException(nameof(databaseRaw)); } var database = entityRegistry.Storage as Database; return(database?.FirstTimeInit(databaseRaw, init)); }
public void Register() { EntityRegistry = new EntityRegistry(); LevelRegistry = new LevelRegistry(); SkillRegistry = new SkillRegistry(); CategoryRegistry = new CategoryRegistry(); Anvil = new AnvilRegistry(); Anvil.GetMods(); Anvil.ModsPreInit(); Anvil.ModsLoad(); Anvil.ModsPostInit(); RegisterStatsAndCategories(); Entities.RegisterEntities(); Skills.RegisterSkills(); //Levels.RegisterLevels(); UIMain.GenerateFirstSkills(); new Character(new Rogue(), new Halfling()); }