private void DetectWeaponHash(Ped ped, int pedEntity)
{
foreach (int i in _weapons)
{
HashesComponent hashesComponent = _weapons.Components1[i];
foreach (uint hash in hashesComponent.Hashes)
{
if (!NativeFunction.Natives.HAS_PED_BEEN_DAMAGED_BY_WEAPON <bool>(ped, hash, 0))
{
continue;
}
int weaponEntity = _weapons.Entities[i];
int woundEntity = _weapons.Components3[i].WoundRandomizer.NextWithReplacement();
#if DEBUG
string weaponName = weaponEntity.GetEntityName(_ecsWorld);
string woundName = woundEntity.GetEntityName(_ecsWorld);
_logger.MakeLog($"Ped {ped.Name(pedEntity)} was damaged by {weaponName} with wound {woundName}");
#endif
var damaged = _ecsWorld.AddComponent <DamagedByWeaponComponent>(pedEntity);
damaged.WeaponEntity = weaponEntity;
damaged.WoundEntity = woundEntity;
var wounded = _ecsWorld.EnsureComponent <WoundedComponent>(pedEntity, out _);
wounded.WoundEntities.Add(woundEntity);
return;
}
}
_logger.MakeLog($"!!!Ped {ped.Name(pedEntity)} was damaged by UNKNOWN weapon");
}
private void DetectWeaponHash(Ped ped, EcsEntity pedEntity)
{
foreach (int i in _weapons)
{
HashesComponent hashesComponent = _weapons.Components1[i];
foreach (uint hash in hashesComponent.Hashes)
{
if (!NativeFunction.Natives.HAS_PED_BEEN_DAMAGED_BY_WEAPON <bool>(ped, hash, 0))
{
continue;
}
EcsEntity weaponEntity = _weapons.Entities[i];
#if DEBUG
_logger.MakeLog($"{pedEntity.GetEntityName()} was damaged by {weaponEntity.GetEntityName()}({hash})");
#endif
var damaged = _ecsWorld.AddComponent <DamagedByWeaponComponent>(pedEntity);
damaged.WeaponEntity = weaponEntity;
return;
}
}
_logger.MakeLog($"!!!WARNING!!! Ped {pedEntity.GetEntityName()} was damaged by UNKNOWN weapon");
}
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);
}
public void Initialize()
{
foreach (int i in _configParts)
{
XElement root = _configParts.Components1[i].ElementRoot;
var hashesElement = root.Element(HASHES);
if (hashesElement == null)
{
continue;
}
int entity = _configParts.Entities[i];
var hashesComponent = _ecsWorld.AddComponent <HashesComponent>(entity);
var hashStrings = hashesElement.GetAttributeValue("Hashes").Split(';');
foreach (string hashString in hashStrings)
{
if (string.IsNullOrEmpty(hashString))
{
continue;
}
if (uint.TryParse(hashString, out uint hash))
{
hashesComponent.Hashes.Add(hash);
}
else
{
_logger.MakeLog($"Wrong hash: {hashString}");
}
}
_logger.MakeLog($"{entity.GetEntityName(_ecsWorld)} {hashesComponent}");
}
}
protected override void CheckPart(XElement partRoot, EcsEntity partEntity)
{
XElement enable = partRoot.Element("EnableFacialAnimation");
if (enable != null)
{
var component = EcsWorld.AddComponent <EnableFacialAnimationComponent>(partEntity);
component.MaleDict = enable.GetAttributeValue("MaleDict");
component.FemaleDict = enable.GetAttributeValue("FemaleDict");
component.Permanent = enable.GetBool("Permanent");
foreach (string animation in enable.GetAttributeValue("Animations").Split(';'))
{
if (!string.IsNullOrEmpty(animation))
{
component.Animations.Add(animation);
}
}
#if DEBUG
Logger.MakeLog($"{partEntity.GetEntityName()} have got {component}");
#endif
}
XElement disable = partRoot.Element("DisableFacialAnimation");
if (disable != null)
{
EcsWorld.AddComponent <DisableFacialAnimationComponent>(partEntity);
#if DEBUG
Logger.MakeLog($"{partEntity.GetEntityName()} will disable facial animation");
#endif
}
}
public void Run()
{
if (_gameService.GameIsPaused)
{
return;
}
foreach (int i in _peds)
{
Ped ped = _peds.Components1[i].ThisPed;
if (!ped.Exists())
{
continue;
}
bool damaged = NativeFunction.Natives.HAS_ENTITY_BEEN_DAMAGED_BY_ANY_PED <bool>(ped);
if (!damaged)
{
continue;
}
EcsEntity pedEntity = _peds.Entities[i];
_ecsWorld.AddComponent <HasBeenHitMarkComponent>(pedEntity);
#if DEBUG
_logger.MakeLog($"{pedEntity.GetEntityName()} has been damaged");
#endif
}
}
protected override void CheckPart(XElement partRoot, EcsEntity partEntity)
{
XElement ragdoll = partRoot.Element("EnableRagdoll");
if (ragdoll != null)
{
var component = EcsWorld.AddComponent <EnableRagdollComponent>(partEntity);
component.LengthInMs = ragdoll.GetInt("LengthInMs");
component.Type = ragdoll.GetInt("Type");
component.Permanent = ragdoll.GetBool("Permanent");
component.DisableOnlyOnHeal = ragdoll.GetBool("DisableOnlyOnHeal");
#if DEBUG
Logger.MakeLog($"{partEntity.GetEntityName()} have got {component}");
#endif
}
XElement disable = partRoot.Element("DisablePermanentRagdoll");
if (disable != null)
{
EcsWorld.AddComponent <DisablePermanentRagdollComponent>(partEntity);
#if DEBUG
Logger.MakeLog($"{partEntity.GetEntityName()} will disable permanent ragdoll");
#endif
}
}
void IEcsRunSystem.Run()
{
if (Input.GetMouseButtonDown(0))
{
int scoreCount = 1;
var hit = Physics2D.Raycast(Camera.main.ScreenToWorldPoint(Input.mousePosition), Vector2.zero, 100);
if (hit.collider != null)
{
Transform htr = hit.collider.transform;
foreach (var viewEntity in _viewFilter.Entities)
{
var view = _world.GetComponent <ResViewComponent> (viewEntity, _viewId);
var move = _world.GetComponent <ResMoveComponent> (viewEntity, _moveId);
if (view.transform == htr && move == null)
{
var res = _world.GetComponent <ResComponent>(viewEntity, _resId);
if (res.type == ResType.blocker)
{
scoreCount = 10;
}
var score = _world.AddComponent <ScoreComponent>(_world.CreateEntity());
score.score = scoreCount;
res.type = ResType.none;
GameObject.Destroy(view.transform.gameObject);
//_world.RemoveComponent<ResViewComponent>(viewEntity, _viewId);
break;
}
}
}
}
}
protected override void CheckPart(XElement partRoot, EcsEntity partEntity)
{
XElement listElement = partRoot.Element("NaturalMotionMessages");
if (listElement == null)
{
return;
}
Dictionary <string, NaturalMotionMessage> dict = _dict.Components1[0].MessageDict;
var messages = EcsWorld.AddComponent <NaturalMotionMessagesComponent>(partEntity);
string[] messageStrings = listElement.GetAttributeValue("List").Split(';');
foreach (string messageString in messageStrings)
{
if (string.IsNullOrEmpty(messageString))
{
continue;
}
if (!dict.ContainsKey(messageString))
{
throw new Exception($"NaturalMotionMessage {messageString} doesn't exist!");
}
messages.MessageList.Add(messageString);
}
messages.PlayInPermanentRagdoll = listElement.GetBool("PlayInPermanentRagdoll");
#if DEBUG
Logger.MakeLog($"{partEntity.GetEntityName()} have got {messages}");
#endif
}
void IEcsInitSystem.Initialize()
{
for (int i = 0; i < 50000; i++)
{
var res = _world.AddComponent <MainComponent>(_world.CreateEntity());
res.id = i + 1;
}
}
protected override void ProcessWound(Ped ped, EcsEntity pedEntity, EcsEntity woundEntity)
{
var permanentDisabled = EcsWorld.GetComponent <PermanentDisabledSprintComponent>(pedEntity);
var player = EcsWorld.GetComponent <PlayerMarkComponent>(pedEntity);
if (permanentDisabled == null && player != null)
{
var disable = EcsWorld.GetComponent <DisableSprintComponent>(woundEntity);
if (disable != null)
{
NativeFunction.Natives.SET_PLAYER_SPRINT(Game.LocalPlayer, false);
if (disable.RestoreOnlyOnHeal)
{
EcsWorld.AddComponent <PermanentDisabledSprintComponent>(pedEntity);
}
#if DEBUG
Logger.MakeLog($"Sprint disabled for player, permanent = {disable.RestoreOnlyOnHeal}");
#endif
}
var enable = EcsWorld.GetComponent <EnableSprintComponent>(woundEntity);
if (enable != null)
{
NativeFunction.Natives.SET_PLAYER_SPRINT(Game.LocalPlayer, true);
#if DEBUG
Logger.MakeLog("Sprint enabled for player");
#endif
}
}
var permanentRate = EcsWorld.GetComponent <PermanentDisabledSprintComponent>(pedEntity);
if (permanentRate == null)
{
var newRate = EcsWorld.GetComponent <NewMovementRateComponent>(woundEntity);
if (newRate != null)
{
NativeFunction.Natives.SET_PED_MOVE_RATE_OVERRIDE(ped, newRate.Rate);
if (newRate.RestoreOnlyOnHeal)
{
EcsWorld.AddComponent <PermanentDisabledSprintComponent>(pedEntity);
}
#if DEBUG
Logger.MakeLog($"Move rate for {pedEntity.GetEntityName()} " +
$"was changed to {newRate.Rate}, permanent = {newRate.RestoreOnlyOnHeal}");
#endif
}
var restore = EcsWorld.GetComponent <RestoreMovementComponent>(woundEntity);
if (restore != null)
{
NativeFunction.Natives.SET_PED_MOVE_RATE_OVERRIDE(ped, 1.0f);
#if DEBUG
Logger.MakeLog($"Move rate for {pedEntity.GetEntityName()} was restored");
#endif
}
}
}
public void Initialize()
{
if (_uidDict.EntitiesCount <= 0)
{
throw new Exception("UidSystem was not init!");
}
var 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";
int itemEntity = _loadedItems.Entities[i];
var randomizer = _ecsWorld.AddComponent <WoundRandomizerComponent>(itemEntity);
foreach (XElement woundElement in woundListElement.Elements(woundElementName))
{
long woundUid = woundElement.GetLong("Uid");
if (!uidDict.ContainsKey(woundUid))
{
throw new Exception($"Entity with Uid {woundUid} not found!");
}
int 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);
}
}
}
public void Run()
{
foreach (int i in _deadPlayers)
{
PlayerComponent deadPlayer = _deadPlayers.Components1[i];
int playerEntity = _deadPlayers.Entities[i];
Vector2Int spawnPosition = deadPlayer.StartPosition;
if (--deadPlayer.Lives <= 0)
{
deadPlayer.IsDead = true;
spawnPosition = Vector2Int.zero;
_ecsWorld.AddComponent <DestroyedWorldObjectComponent>(playerEntity);
}
_ecsWorld.AddComponent <TeleportingComponent>(playerEntity).NewPosition = spawnPosition;
_ecsWorld.CreateEntityWith <UpdateScoreTableEvent>();
}
}
public void Initialize()
{
GameObject[] walls = GameObject.FindGameObjectsWithTag("Wall");
foreach (GameObject wall in walls)
{
var entity = wall.CreateEntityWithPosition(_ecsWorld);
_ecsWorld.AddComponent <WallComponent>(entity);
}
}
private void SwitchGswPed(Ped ped, WoundedPedComponent oldPed, int oldEntity)
{
oldPed.IsPlayer = false;
oldPed.Health = oldPed.Health - _config.Data.PlayerConfig.MinimalHealth;
oldPed.ThisPed.MaxHealth = _config.Data.NpcConfig.MaxStartHealth;
oldPed.ThisPed.Health = (int)oldPed.Health;
_ecsWorld.RemoveComponent <PlayerMarkComponent>(oldEntity);
_ecsWorld.AddComponent <NpcMarkComponent>(oldEntity);
#if DEBUG
oldPed.ThisPed.AddBlip();
#endif
if (_world.Data.GswPeds.ContainsKey(ped))
{
int newEntity = _world.Data.GswPeds[ped];
var newPed = _ecsWorld.GetComponent <WoundedPedComponent>(newEntity);
newPed.IsPlayer = true;
newPed.IsDead = false;
newPed.Health = _config.Data.PlayerConfig.MinimalHealth + newPed.Health;
newPed.ThisPed.MaxHealth = _config.Data.PlayerConfig.MaximalHealth + 101;
newPed.ThisPed.Health = (int)newPed.Health;
newPed.MaximalPain = _config.Data.PlayerConfig.MaximalPain;
newPed.PainRecoverSpeed = _config.Data.PlayerConfig.PainRecoverSpeed;
newPed.StopBleedingAmount = _config.Data.PlayerConfig.BleedHealingSpeed;
_ecsWorld.RemoveComponent <NpcMarkComponent>(newEntity);
_ecsWorld.AddComponent <PlayerMarkComponent>(newEntity);
_config.Data.PlayerConfig.PlayerEntity = newEntity;
#if DEBUG
SendMessage($"Switched to {newEntity}", newEntity, NotifyLevels.DEBUG);
newPed.ThisPed.CurrentBlip.Remove();
#endif
}
else
{
CreateGswPlayer(ped);
}
}
public void PreInitialize()
{
EcsEntity mainEntity = GunshotWound3.StatsContainerEntity;
var settings = _ecsWorld.AddComponent <NotificationSettingsComponent>(mainEntity);
settings.CombineToOne = true;
_ecsWorld.CreateEntityWith(out NotificationComponent startNotification);
startNotification.Message = $"Great thanks for using ~g~GunShot Wound ~r~3~s~ v.{VERSION} by SH42913";
startNotification.Delay = 20f;
}
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);
}
}
public void Initialize()
{
GameObject[] walls = GameObject.FindGameObjectsWithTag("Wall");
foreach (GameObject wall in walls)
{
WallComponent wallComponent;
int wallEntity = _ecsWorld.CreateEntityWith(out wallComponent);
_ecsWorld.AddComponent <CreateWorldObjectEvent>(wallEntity).Transform = wall.transform;
}
}
public void Initialize()
{
var dict = _ecsWorld.AddComponent <UidToEntityDictComponent>(GunshotWound2Script.StatsContainerEntity);
foreach (int i in _items)
{
XElement itemRoot = _items.Components1[i].ElementRoot;
XElement uidElement = itemRoot.Element("Uid");
if (uidElement == null)
{
continue;
}
int entity = _items.Entities[i];
long uid = uidElement.GetLong();
_ecsWorld.AddComponent <UidComponent>(entity).Uid = uid;
dict.UidToEntityDict.Add(uid, entity);
}
}
public void PreInitialize()
{
var playerConfigBehaviour = Object.FindObjectOfType <PlayerConfigBehaviour>();
if (playerConfigBehaviour == null)
{
throw new Exception("PlayerConfigBehaviour must be created!");
}
if (_world.EntitiesCount <= 0)
{
throw new Exception("World must be init!");
}
int worldEntity = _world.Entities[0];
var config = _ecsWorld.AddComponent <PlayerConfigComponent>(worldEntity);
config.StartSpeed = playerConfigBehaviour.StartSpeed;
config.StartLives = playerConfigBehaviour.StartLives;
config.PlayerCount = 0;
}
public void Swap(int2 lhvPos, int2 rhvPos)
{
var field = _state.StoneField;
if (!field.InRange(lhvPos) || !field.InRange(rhvPos))
{
return;
}
var lhv = _state.StoneField.Get(lhvPos);
var rhv = _state.StoneField.Get(rhvPos);
if (lhv == null || rhv == null || lhv == rhv)
{
return;
}
_world.AddComponent <Swapping>(lhv.eid);
_world.AddComponent <Swapping>(rhv.eid);
_world.ProcessDelayedUpdates();
}
public void Initialize()
{
var component = _ecsWorld.AddComponent <PainStateListComponent>(GunshotWound3.StatsContainerEntity);
var sortedDict = new SortedDictionary <float, EcsEntity>();
foreach (int i in _painStates)
{
PainStateComponent state = _painStates.Components1[i];
EcsEntity stateEntity = _painStates.Entities[i];
sortedDict.Add(state.PainPercent, stateEntity);
}
foreach (KeyValuePair <float, EcsEntity> pair in sortedDict)
{
component.PainStateEntities.Add(pair.Value);
component.PainStatePercents.Add(pair.Key);
#if DEBUG
_logger.MakeLog($"PainState {pair.Value.GetEntityName()} got {pair.Key} percent");
#endif
}
}
public void Run()
{
WorldComponent world = _world.Components1[0];
foreach (int i in _players)
{
Vector2Int newPosition = _players.Components1[i].NewPosition;
int playerEntity = _players.Entities[i];
foreach (int entity in world.WorldField[newPosition.x][newPosition.y])
{
var item = _ecsWorld.GetComponent <ItemComponent>(entity);
if (item == null)
{
continue;
}
_ecsWorld.AddComponent <TakenItemComponent>(entity).PlayerEntity = playerEntity;
_ecsWorld.AddComponent <DestroyedWorldObjectComponent>(entity);
}
}
}
void CreateTable()
{
for (int x = 0; x < countx; x++)
{
for (int y = 0; y < county; y++)
{
var res = _world.AddComponent <ResComponent> (_world.CreateEntity());
res.x = x;
res.y = y;
res.type = (ResType)Random.Range((int)ResType.blocker, (int)ResType.piece5);
}
}
}
public void Run()
{
WorldComponent world = _world.Components1[0];
foreach (int i in _createEvents)
{
Transform newObject = _createEvents.Components1[i].Transform;
int entity = _createEvents.Entities[i];
Vector2Int position = newObject.position.ToVector2Int();
world.WorldField[position.x][position.y].Add(entity);
_ecsWorld.AddComponent <PositionComponent>(entity).Position = position;
_ecsWorld.AddComponent <WorldObjectComponent>(entity).Transform = newObject;
}
foreach (int i in _movedObjects)
{
PositionComponent positionComponent = _movedObjects.Components1[i];
Vector2Int oldPosition = positionComponent.Position;
Vector2Int newPosition = _movedObjects.Components2[i].NewPosition;
int entity = _movedObjects.Entities[i];
world.WorldField[oldPosition.x][oldPosition.y].Remove(entity);
world.WorldField[newPosition.x][newPosition.y].Add(entity);
positionComponent.Position = newPosition;
}
foreach (int i in _destroyedObjects)
{
Transform objectToDestroy = _destroyedObjects.Components1[i].Transform;
Vector2Int position = _destroyedObjects.Components2[i].Position;
int entity = _destroyedObjects.Entities[i];
world.WorldField[position.x][position.y].Remove(entity);
objectToDestroy.gameObject.SetActive(false);
_ecsWorld.RemoveEntity(entity);
}
}
public void Run()
{
for (int i = 0; i < _peds.EntitiesCount; i++)
{
if (!Function.Call <bool>(Hash.HAS_ENTITY_BEEN_DAMAGED_BY_ANY_PED, _peds.Components1[i].ThisPed))
{
continue;
}
_ecsWorld.AddComponent <HaveDamageMarkComponent>(_peds.Entities[i]);
SendMessage($"Ped {_peds.Entities[i]} got damage", NotifyLevels.DEBUG);
}
}
void SpawnSnake()
{
Debug.Log("Spawn snake");
GameObject headPrefab = Resources.Load <GameObject> ("SnakeHead");
GameObject head = GameObject.Instantiate(headPrefab, Vector3.zero, Quaternion.identity);
_snakeEntity = _world.CreateEntity();
SnakeComponent sc = _world.AddComponent <SnakeComponent> (_snakeEntity);
sc.Length = 0;
sc.Tail = new List <Transform> ();
_world.AddComponent <ControlComponent> (_snakeEntity);
_world.AddComponent <GameObjectComponent> (_snakeEntity).Init(head);
_world.AddComponent <ColliderComponent> (_snakeEntity).Collider = head.GetComponent <Collider2D> ();
}
public void Initialize()
{
GameObject[] playerObjects = GameObject.FindGameObjectsWithTag("Player");
foreach (var player in playerObjects)
{
var entity = player.CreateEntityWithPosition(_ecsWorld);
var startPosition = player.transform.position;
var moveComponent = _ecsWorld.AddComponent <MoveComponent>(entity);
moveComponent.Transform = player.transform;
moveComponent.Heading = _createdPlayersCount % 2 != 0
? Directions.RIGHT
: Directions.LEFT;
moveComponent.DesiredPosition = startPosition;
moveComponent.Speed = StartSpeed;
var playerComponent = _ecsWorld.AddComponent <PlayerComponent>(entity);
playerComponent.Lifes = StartLifes;
playerComponent.Num = ++_createdPlayersCount;
playerComponent.StartPosition = startPosition;
}
}
public void PreInitialize()
{
var config = _ecsWorld.AddComponent <PlayerConfigComponent>(GunshotWound3.StatsContainerEntity);
config.PlayerEnabled = true;
foreach (int i in _loadedConfigs)
{
XElement configRoot = _loadedConfigs.Components1[i].ElementRoot;
XElement playerEnabledElement = configRoot.Element("PlayerEnabled");
if (playerEnabledElement == null)
{
continue;
}
config.PlayerEnabled = playerEnabledElement.GetBool();
}
#if DEBUG
_logger.MakeLog(config.ToString());
#endif
_logger.MakeLog("PlayerConfig is loaded!");
}
protected override void CheckPart(XElement partRoot, EcsEntity partEntity)
{
var dropElement = partRoot.Element("DropWeapon");
if (dropElement == null)
{
return;
}
var component = EcsWorld.AddComponent <WeaponDropComponent>(partEntity);
component.TakeCoverDuration = dropElement.GetInt("TakeCoverDuration");
component.FleeIfHasNoWeapons = dropElement.GetBool("FleeIfHasNoWeapons");
}
