public void Initialize()
{
if (_uidDict.IsEmpty())
{
throw new Exception("UidSystem was not init!");
}
Dictionary <string, EcsEntity> uidDict = _uidDict.Components1[0].UidToEntityDict;
foreach (int i in _loadedItems)
{
XElement itemRoot = _loadedItems.Components1[i].ElementRoot;
XElement woundListElement = null;
string elementKey = null;
foreach (XElement child in itemRoot.Elements())
{
string name = child.Name.LocalName;
int trimIndex = name.IndexOf("WoundList", StringComparison.Ordinal);
if (trimIndex < 0)
{
continue;
}
elementKey = name.Substring(0, trimIndex);
woundListElement = child;
}
if (string.IsNullOrEmpty(elementKey) || !woundListElement.HasElements)
{
continue;
}
string woundElementName = elementKey + "Wound";
EcsEntity itemEntity = _loadedItems.Entities[i];
var randomizer = _ecsWorld.AddComponent <WoundRandomizerComponent>(itemEntity);
foreach (XElement woundElement in woundListElement.Elements(woundElementName))
{
string woundUid = woundElement.GetAttributeValue("Uid");
if (!uidDict.ContainsKey(woundUid))
{
throw new Exception($"Entity with Uid {woundUid} not found!");
}
EcsEntity woundEntity = uidDict[woundUid];
var wound = _ecsWorld.GetComponent <WoundComponent>(woundEntity);
if (wound == null)
{
throw new Exception($"Entity with Uid {woundUid} is not wound!");
}
int woundWeight = woundElement.GetInt("Weight");
randomizer.WoundRandomizer.Add(woundEntity, woundWeight);
}
}
}
void IEcsRunSystem.Run()
{
foreach (var i in _barrierCreateEventFilter)
{
EcsEntity barrierAreaEntity = _barrierCreateEventFilter.Components1[i].parentBarrierAreaEntity;
var targetBarrierList =
_world.GetComponent <BarrierListComponent>(barrierAreaEntity).barriers;
var barrierBehaviours = _world.GetComponent <TransformComponent>(barrierAreaEntity)
.transform
.gameObject
.GetComponentsInChildren <BarrierBehaviour>();
foreach (var behaviour in barrierBehaviours)
{
targetBarrierList.Add(behaviour);
}
}
}
public void Run()
{
for (int teleportIndex = 0; teleportIndex < _components.EntitiesCount; teleportIndex++)
{
var teleportComponent = _components.Components1[teleportIndex];
var moveEntity = teleportComponent.MoveEntity;
var moveComponent = _ecsWorld.GetComponent <MoveComponent>(moveEntity);
var positionComponent = _ecsWorld.GetComponent <PositionComponent>(moveEntity);
if (moveComponent != null && positionComponent != null)
{
positionComponent.Position = teleportComponent.TargetPosition.ToVector2Int();
moveComponent.DesiredPosition = teleportComponent.TargetPosition;
moveComponent.Transform.position = teleportComponent.TargetPosition;
}
_ecsWorld.RemoveEntity(_components.Entities[teleportIndex]);
}
}
protected override void RunReactive()
{
for (int i = 0; i < ReactedEntitiesCount; i++)
{
var entity = ReactedEntities[i];
var roomData = _world.GetComponent <RoomData> (entity);
if (roomData.value.ContainsKey(RoomDataConstants.PlayerRole))
{
var roles = Extensions.DeserializeToPlayerRoles(roomData.value[RoomDataConstants.PlayerRole] as byte[]);
_gameState.UpdateRoles(roles);
foreach (var playerRole in roles)
{
var actorNumber = playerRole.Key;
var role = playerRole.Value;
if (_playerCache.Entities.TryGetValue(actorNumber, out var playerEntity))
{
var roleComponent = _world.EnsureComponent <Role> (playerEntity, out var isNew);
if (!isNew)
{
if (roleComponent.value != role)
{
_world.MarkComponentAsUpdated <Role> (playerEntity);
}
}
else
{
_world.MarkComponentAsUpdated <Role> (playerEntity);
}
roleComponent.value = role;
}
}
stringBuilder.Clear();
stringBuilder.AppendLine("Roles");
var values = Enum.GetValues(typeof(PlayerRole)) as PlayerRole[];
for (int j = 1; j < values.Length; j++)
{
var role = values[j];
var playerWithRole = _gameState.GetPlayerWithRole(role);
stringBuilder.Append($"{role} = {( playerWithRole == -1 ? "-" : playerWithRole.ToString() )}");
if (playerWithRole == _photonServer.LocalPlayer.ID)
{
stringBuilder.Append("(me)");
}
stringBuilder.AppendLine();
}
SceneDescription.UI.GameUI.Roles.text = stringBuilder.ToString();
}
}
}
protected override void RunReactive()
{
var entity = ReactedEntities[0];
var target = _world.GetComponent <ChangeShootTarget> (entity);
var shipView = SceneDescription.Ship;
foreach (var cannon in shipView.Cannons)
{
cannon.Root.LookAt(target.value);
}
}
protected override void RunReactive()
{
for (var i = 0; i < ReactedEntitiesCount; i++)
{
var go = GameObject.CreatePrimitive(PrimitiveType.Sphere);
var entity = ReactedEntities[i];
_world.AddComponent <TransformRef>(entity).value = go.transform;
go.transform.position = new Vector3(2 * _world.GetComponent <GamePlayer>(ReactedEntities[i]).number, 0, 0);
}
}
protected override void ResetEffect(Ped ped, EcsEntity pedEntity)
{
var permanent = EcsWorld.GetComponent <PermanentFacialAnimationComponent>(pedEntity);
if (permanent == null)
{
return;
}
EcsWorld.RemoveComponent <PermanentFacialAnimationComponent>(pedEntity);
}
void IEcsUpdateSystem.Update()
{
_snakeCollider = _world.GetComponent <ColliderComponent> (_snakeObjects.Entities[0], _colliderComponentId);
SnakeComponent snakeComponent = _world.GetComponent <SnakeComponent> (_snakeObjects.Entities[0], _snakeComponentId);
foreach (var entity in _collisionObjects.Entities)
{
var eCollider = _world.GetComponent <ColliderComponent> (entity, _colliderComponentId);
if (eCollider.Collider.bounds.Intersects(_snakeCollider.Collider.bounds))
{
snakeComponent.Length++;
_world.PublishEvent <int> (snakeComponent.Length);
var dData = new DestroyEvent();
dData.Index = entity;
_world.PublishEvent <DestroyEvent> (dData);
var sData = new SpawnEvent();
sData.Length = snakeComponent.Length;
_world.PublishEvent <SpawnEvent> (sData);
}
}
}
void IEcsRunSystem.Run()
{
foreach (var resEntity in _resFilter.Entities)
{
var res = _world.GetComponent <ResComponent>(resEntity, _resId);
if (res.type == ResType.none)
{
_world.RemoveComponent <ResViewComponent>(resEntity, _viewId);
_world.RemoveComponent <ResMoveComponent>(resEntity, _moveId);
}
}
foreach (var moveEntity in _moveFilter.Entities)
{
var move = _world.GetComponent <ResMoveComponent>(moveEntity, _moveId);
if (move.curcycle > move.cyclemove)
{
_world.RemoveComponent <ResMoveComponent>(moveEntity, _moveId);
}
}
}
protected override void ResetEffect(Ped ped, EcsEntity pedEntity)
{
bool isPlayer = EcsWorld.GetComponent <PlayerMarkComponent>(pedEntity) != null;
if (!isPlayer)
{
return;
}
NativeFunction.Natives.xB4EDDC19532BFB85();
EcsWorld.RemoveComponent <MainScreenEffectComponent>(pedEntity, true);
}
protected override void ResetEffect(Ped ped, EcsEntity pedEntity)
{
bool isPlayer = EcsWorld.GetComponent <PlayerMarkComponent>(pedEntity) != null;
if (!isPlayer)
{
return;
}
NativeFunction.Natives.STOP_GAMEPLAY_CAM_SHAKING(true);
EcsWorld.RemoveComponent <PermanentCameraShakeComponent>(pedEntity, true);
}
public void Run()
{
foreach (var component in filter)
{
var destructableComponent = filter.Components1[component];
if (destructableComponent.ToDestroy)
{
var droppableComponent = filter.Components2[component];
var parentPositionComponent = world.GetComponent <PositionComponent>(droppableComponent.Entity);
var spriteComponent = world.GetComponent <SpriteComponent>(droppableComponent.Entity);
var size = spriteComponent.Texture.GetLocalBounds();
var scale = spriteComponent.Scale;
droppableComponent.SpawnChildComponent(
world,
droppableComponent.DropObject,
new Vector2f(
parentPositionComponent.Position.X + size.Width / 2 * scale,
parentPositionComponent.Position.Y + size.Height / 2 * scale));
}
}
}
protected override void RunReactive()
{
for (int i = 0; i < ReactedEntitiesCount; i++)
{
var entity = ReactedEntities[i];
var transformRef = _world.GetComponent <TransformRef> (entity);
if (transformRef != null)
{
UnityEngine.Object.Destroy(transformRef.value.gameObject);
}
_world.RemoveEntity(entity);
}
}
void IEcsUpdateSystem.Update()
{
foreach (var entity in _destroyObjects.Entities)
{
var eDestroy = _world.GetComponent <DestroyComponent> (entity, _destroyComponentId);
TimeSpan diff = DateTime.Now - eDestroy.SpawnTime;
if (diff.TotalSeconds >= _lifeTime)
{
Debug.Log("Destroy uneaten food");
_world.RemoveEntity(entity);
}
}
}
protected override void RunReactive()
{
for (int i = 0; i < ReactedEntitiesCount; i++)
{
var entity = ReactedEntities[i];
var kill = _world.GetComponent <KillAsteroids> (entity);
foreach (var id in kill.value)
{
if (_gameState.Asteroids.TryGetValue(id, out var asteroidEntity))
{
_world.EnsureComponent <Destroy> (asteroidEntity, out _);
if (kill.WithEffect)
{
var position = _world.GetComponent <Position> (asteroidEntity);
UnityEngine.Object.Instantiate(_gameConfig.AsteroidDeathEffect, position.value, Quaternion.identity);
}
_gameState.Asteroids.Remove(id);
}
}
}
}
public void Run()
{
WorldComponent world = _world.Components1[0];
foreach (int i in _moveableObjects)
{
Vector2Int newPosition = _moveableObjects.Components1[i].NewPosition;
int movableEntity = _moveableObjects.Entities[i];
foreach (int entity in world.WorldField[newPosition.x][newPosition.y])
{
var portal = _ecsWorld.GetComponent <PortalComponent>(entity);
if (portal == null || portal.EstimateReloadTime > 0)
{
continue;
}
int otherPortalEntity = portal.OtherPortalEntity;
var otherPortal = _ecsWorld.GetComponent <PortalComponent>(otherPortalEntity);
Vector2Int otherPortalPosition = _ecsWorld
.GetComponent <PositionComponent>(otherPortalEntity)
.Position;
_ecsWorld.AddComponent <TeleportingComponent>(movableEntity).NewPosition = otherPortalPosition;
portal.EstimateReloadTime = PORTAL_RELOAD_TIME;
otherPortal.EstimateReloadTime = PORTAL_RELOAD_TIME;
}
}
foreach (int i in _portals)
{
PortalComponent portalComponent = _portals.Components1[i];
if (portalComponent.EstimateReloadTime > 0)
{
portalComponent.EstimateReloadTime -= Time.deltaTime;
}
}
}
public override void RunReact(List <int> entities)
{
foreach (var scoreEntity in _scoreFilter.Entities)
{
var score = _world.GetComponent <ScoreComponent>(scoreEntity, _scoreId);
scoreCount += score.score;
scoreui.text = FormatText();
}
// and remove all received events.
foreach (var entity in entities)
{
_world.RemoveEntity(entity);
}
}
public void Run()
{
if (_photonServer.CurrentRoom != null)
{
if (_player.EntitiesCount > 0)
{
var playerEntity = _player.Entities[0];
var role = _world.GetComponent <Role> (playerEntity);
if (role != null)
{
if (role.value == PlayerRole.Fly)
{
_hashtable.Clear();
var transform = _world.GetComponent <TransformRef> (_gameState.ShipEntity).value;
_hashtable[RoomDataConstants.ShipPosition] = transform.position;
_hashtable[RoomDataConstants.ShipRotation] = transform.rotation;
_photonServer.CurrentRoom.SetCustomProperties(_hashtable);
}
}
}
}
}
public void Run()
{
GunshotWound2.LastSystem = nameof(InstantHealSystem);
for (int i = 0; i < _components.EntitiesCount; i++)
{
int pedEntity = _components.Components1[i].PedEntity;
var woundedPed = _ecsWorld.GetComponent <WoundedPedComponent>(pedEntity);
if (woundedPed != null)
{
if (woundedPed.IsPlayer)
{
Function.Call(Hash._SET_CAM_EFFECT, 0);
Function.Call(Hash.SET_PLAYER_SPRINT, Game.Player, true);
Function.Call(Hash._STOP_ALL_SCREEN_EFFECTS);
woundedPed.Health = _mainConfig.Data.PlayerConfig.MaximalHealth;
_ecsWorld.CreateEntityWith <AdrenalineComponent>().Revert = true;
Game.Player.IgnoredByEveryone = false;
}
else
{
woundedPed.Health = _random.Next(50, _mainConfig.Data.NpcConfig.MaximalStartHealth);
woundedPed.ThisPed.Accuracy = woundedPed.DefaultAccuracy;
}
woundedPed.IsDead = false;
woundedPed.DamagedParts = 0;
woundedPed.PainMeter = 0;
Function.Call(Hash.CLEAR_PED_BLOOD_DAMAGE, woundedPed.ThisPed);
Function.Call(Hash.SET_PED_MOVE_RATE_OVERRIDE, woundedPed.ThisPed, 1f);
woundedPed.ThisPed.Health = (int)woundedPed.Health;
woundedPed.Armor = woundedPed.ThisPed.Armor;
_ecsWorld.CreateEntityWith <NoPainStateComponent>().PedEntity = pedEntity;
}
for (int bleedIndex = 0; bleedIndex < _bleedingComponents.EntitiesCount; bleedIndex++)
{
if (_bleedingComponents.Components1[bleedIndex].PedEntity != pedEntity)
{
continue;
}
_ecsWorld.RemoveEntity(_bleedingComponents.Entities[bleedIndex]);
}
_ecsWorld.RemoveEntity(_components.Entities[i]);
}
}
protected override void ResetEffect(Ped ped, EcsEntity pedEntity)
{
bool isPlayer = EcsWorld.GetComponent <PlayerMarkComponent>(pedEntity) != null;
if (!isPlayer)
{
return;
}
NativeFunction.Natives.SPECIAL_ABILITY_UNLOCK(ped.Model.Hash);
#if DEBUG
Logger.MakeLog("Special Ability unlocked");
#endif
}
void IEcsRunSystem.Run()
{
var map = _barrierAreaMapFilter.Components1[0].map;
List <LinkedList <EcsEntity> > rowsToDelete = new List <LinkedList <EcsEntity> >();
foreach (var row in map)
{
// Find barrier areas out view radius
var barrierAreasToDelete = row.Where(barrierAreaEntity =>
{
TransformComponent barrierAreaTransformComponent =
_world.GetComponent <TransformComponent>(barrierAreaEntity);
SizeComponent barrierAreaSizeComponent = _world.GetComponent <SizeComponent>(barrierAreaEntity);
float viewDiameter = _beatshipFilter.Components3[0].viewRadius * 2;
Bounds barrierAreaBounds = new Bounds(barrierAreaTransformComponent.transform.position,
barrierAreaSizeComponent.size);
Bounds viewAreaBounds = new Bounds(_beatshipFilter.Components2[0].transform.position,
new Vector3(viewDiameter,
viewDiameter,
viewDiameter));
return(!IsRectangleOverlapRectangle(barrierAreaBounds, viewAreaBounds));
});
// Destroy barrier areas out view radius
foreach (var barrierAreaEntity in barrierAreasToDelete)
{
EntityBuilder.Instance(_world)
.CreateEntity()
.AddComponent <BarrierAreaDestroyEvent>(out BarrierAreaDestroyEvent destroyEvent);
destroyEvent.barrierAreaEntity = barrierAreaEntity;
}
}
}
private IList <int> CreateRope(Texture2D ropeTexture, int segmentCount, float totalLength, Vector2 startPosition, Vector2 endPosition)
{
// TODO: spec
float stiffness = 30f;
float damping = 10f;
float mass = 1f;
var currentPosition = startPosition;
var segmentOffset = (endPosition - startPosition) / (segmentCount - 1);
var segmentLength = totalLength / segmentCount;
var segments = new int[segmentCount];
for (int i = 0; i < segmentCount; ++i)
{
var segmentEntity = world.CreateEntity(currentPosition);
var sprite = world.AddComponent <Sprite>(segmentEntity);
sprite.Texture = ropeTexture;
sprite.Origin = new Vector2(ropeTexture.Bounds.Right, ropeTexture.Bounds.Center.Y);
sprite.LayerDepth = 0.8f;
var rope = world.AddComponent <Rope>(segmentEntity);
rope.Index = i;
segments[i] = segmentEntity;
currentPosition += segmentOffset;
}
for (int i = segmentCount - 1; i > 0; --i)
{
var currentEntity = segments[i];
var previousEntity = segments[i - 1];
// Connect the segment to its previous and next segments.
var rope = world.GetComponent <Rope>(currentEntity);
rope.PreviousEntity = previousEntity;
var previousRope = world.GetComponent <Rope>(previousEntity);
previousRope.NextEntity = currentEntity;
// Physically connect the segment to its previous segment with a rigidbody and a spring.
var physics = world.AddComponent <Physics>(currentEntity);
physics.Mass = mass;
physics.Drag = Vector2.One * 0.1f;
physics.ConstantForce = Gravity * mass;
var spring = world.AddComponent <Spring>(currentEntity);
spring.ConnectedEntity = rope.PreviousEntity;
spring.Stiffness = stiffness;
spring.Damping = damping;
spring.RestDistance = segmentLength;
}
return(segments);
}
protected override void ResetEffect(Ped ped, EcsEntity pedEntity)
{
var changedFlags = EcsWorld.GetComponent <ChangedPedFlagsComponent>(pedEntity);
if (changedFlags == null)
{
return;
}
foreach (int changedFlag in changedFlags.ChangedFlags)
{
NativeFunction.Natives.SET_PED_RESET_FLAG(ped, changedFlag, true);
}
changedFlags.ChangedFlags.Clear();
}
public void Run()
{
GunshotWound2.LastSystem = nameof(HitCleanSystem);
for (int i = 0; i < _requestsToClean.EntitiesCount; i++)
{
int pedEntity = _requestsToClean.Components1[i].PedEntity;
var ped = _ecsWorld.GetComponent <WoundedPedComponent>(pedEntity).ThisPed;
Function.Call(Hash.CLEAR_PED_LAST_WEAPON_DAMAGE, ped);
Function.Call(Hash.CLEAR_PED_LAST_DAMAGE_BONE, ped);
_ecsWorld.RemoveEntity(_requestsToClean.Entities[i]);
}
}
protected override void RunReactive()
{
if (_localPlayer.EntitiesCount == 0 || _localPlayer.Components2[0].value == PlayerRole.Fly)
{
return;
}
for (int i = 0; i < ReactedEntitiesCount; i++)
{
var entity = ReactedEntities[i];
var shipPosition = World.GetComponent <ShipPosition> (entity);
SceneDescription.Ship.transform.position = shipPosition.position;
SceneDescription.Ship.transform.rotation = shipPosition.rotation;
}
}
public void Initialize()
{
var playerGo = GameObject.Find("Player");
var playerComponent = new Player();
var player = world.CreateEntityWith(out playerComponent);
playerComponent.gameObject = playerGo;
playerComponent.transform = playerGo.transform;
world.AddComponent <Dynamic>(player).rigidbody = playerGo.GetComponent <Rigidbody2D>();
world.GetComponent <Dynamic>(player).collider = playerGo.GetComponent <Collider2D>();
var recordable = world.AddComponent <Recordable>(player);
recordable.positions = new Vector2[300];
recordable.velocities = new Vector2[300];
world.AddComponent <Controllable>(player);
}
protected override void ProcessWound(Ped ped, EcsEntity pedEntity, EcsEntity woundEntity)
{
var play = EcsWorld.GetComponent <PlayPainComponent>(woundEntity);
if (play == null)
{
return;
}
bool isPlayer = EcsWorld.GetComponent <PlayerMarkComponent>(pedEntity) != null;
bool isMale = ped.IsMale;
if (isPlayer)
{
if (play.Player < 0)
{
return;
}
NativeFunction.Natives.PLAY_PAIN(ped, play.Player, 0, 0);
#if DEBUG
Logger.MakeLog($"Play pain {play.Player} for player");
#endif
}
else if (isMale)
{
if (play.Male < 0)
{
return;
}
NativeFunction.Natives.PLAY_PAIN(ped, play.Male, 0, 0);
#if DEBUG
Logger.MakeLog($"Play pain {play.Male} for male");
#endif
}
else
{
if (play.Female < 0)
{
return;
}
NativeFunction.Natives.PLAY_PAIN(ped, play.Female, 0, 0);
#if DEBUG
Logger.MakeLog($"Play pain {play.Female} for female");
#endif
}
}
public void Run()
{
GunshotWound2.LastSystem = nameof(RagdollSystem);
for (int i = 0; i < _requests.EntitiesCount; i++)
{
var pedEntity = _requests.Components1[i].PedEntity;
var woundedPed = _ecsWorld
.GetComponent <WoundedPedComponent>(pedEntity);
if (woundedPed == null)
{
_ecsWorld.RemoveEntity(_requests.Entities[i]);
continue;
}
if (_requests.Components1[i].Enable)
{
if (woundedPed.ThisPed.IsRagdoll)
{
continue;
}
SendDebug($"Set {pedEntity} to ragdoll");
Function.Call(Hash.SET_PED_TO_RAGDOLL, woundedPed.ThisPed, -1, -1, 0, 0, 0, 0);
woundedPed.GivesInToPain = true;
_ecsWorld.RemoveEntity(_requests.Entities[i]);
}
else
{
if (woundedPed.GivesInToPain)
{
SendDebug($"Unset {pedEntity} from ragdoll");
Function.Call(Hash.SET_PED_TO_RAGDOLL, woundedPed.ThisPed, 1, 1, 1, 0, 0, 0);
woundedPed.GivesInToPain = false;
if (woundedPed.ThisPed.IsPlayer)
{
Game.Player.IgnoredByEveryone = false;
}
}
_ecsWorld.RemoveEntity(_requests.Entities[i]);
}
}
}
protected override void ProcessWound(Ped ped, EcsEntity pedEntity, EcsEntity woundEntity)
{
var ikComponent = EcsWorld.GetComponent <InstantKillComponent>(woundEntity);
var health = EcsWorld.GetComponent <HealthComponent>(pedEntity);
if (ikComponent == null || health == null)
{
return;
}
int newHealth = (int)health.MinHealth - 2;
ped.SetHealth(newHealth);
#if DEBUG
Logger.MakeLog($"{pedEntity.GetEntityName()} was killed due {ikComponent.ReasonKey}!");
#endif
}
protected override void ResetEffect(Ped ped, EcsEntity pedEntity)
{
var disabled = EcsWorld.GetComponent <DisabledVehicleControlComponent>(pedEntity);
if (disabled == null)
{
return;
}
EcsWorld.RemoveComponent <DisabledVehicleControlComponent>(pedEntity);
bool isPlayer = EcsWorld.GetComponent <PlayerMarkComponent>(pedEntity) != null;
if (!isPlayer)
{
ped.BlockPermanentEvents = false;
}
}
