public Entity New()
{
// Try to reuse a previously used entity ID.
if (!_unusedEntityIDs.TryDequeue(out var entityID))
{
// If none are available, get the next fresh entity ID.
// And resize the entities array if necessary.
if (_nextUnusedID >= Capacity)
{
Resize(Capacity << 1);
}
entityID = _nextUnusedID++;
}
ref var entry = ref _entities[entityID];
entry.Occupied = true;
entry.Generation++;
Count++;
var entity = new Entity(entityID, entry.Generation);
OnEntityCreated?.Invoke(entity);
return(entity);
}
/// Creates a new entity or gets a reusable entity from the
/// internal ObjectPool for entities.
public TEntity CreateEntity()
{
TEntity entity;
if (_reusableEntities.Count > 0)
{
entity = _reusableEntities.Pop();
entity.Reactivate(_creationIndex++);
}
else
{
entity = _entityFactory();
entity.Initialize(_creationIndex++, totalComponents, componentPools, contextInfo, _aercFactory(entity));
}
_entities.Add(entity);
entity.Retain(this);
_entitiesCache = null;
entity.OnComponentAdded += _cachedEntityChanged;
entity.OnComponentRemoved += _cachedEntityChanged;
entity.OnComponentReplaced += _cachedComponentReplaced;
entity.OnEntityReleased += _cachedEntityReleased;
entity.OnDestroyEntity += _cachedDestroyEntity;
OnEntityCreated?.Invoke(this, entity);
return(entity);
}
public static void Subscribe(bool isSubscribing)
{
OnEntityCreated.Subscribe(typeof(IdComponent), ReplaceId, isSubscribing);
#if (!ENTITAS_DISABLE_VISUAL_DEBUGGING && UNITY_EDITOR)
OnEntityCreated.Subscribe(typeof(AuditComponent), AuditOnRetained, isSubscribing);
#endif
}
/// <summary>
/// Adds the specified entity
/// </summary>
/// <param name="entity">Entity</param>
private void AddEntity(IEntity entity)
{
string key = entity.GUID.ToString();
if (!entities.ContainsKey(key))
{
entities.Add(key, entity);
OnEntityCreated?.Invoke(entity);
}
}
public int CreateEntity()
{
int ent;
if (gaps.First != null)
{
ent = gaps.First.Value;
gaps.RemoveFirst();
}
else
{
ent = EntityCount;
}
entities.AddValue(ent);
OnEntityCreated?.Invoke(ent);
return(ent);
}
/// Creates a new entity or gets a reusable entity from the internal ObjectPool for entities.
public virtual Entity <T> CreateEntity()
{
var entity = _reusableEntities.Count > 0 ? _reusableEntities.Pop() : new Entity <T>(_componentPools, _metaData);
entity._isEnabled = true;
entity._creationIndex = _creationIndex++;
entity.Retain(this);
_entities.Add(entity);
_entitiesCache = null;
entity.OnComponentAdded += _cachedUpdateGroupsComponentAddedOrRemoved;
entity.OnComponentRemoved += _cachedUpdateGroupsComponentAddedOrRemoved;
entity.OnComponentReplaced += _cachedUpdateGroupsComponentReplaced;
entity.OnEntityReleased += _cachedOnEntityReleased;
OnEntityCreated?.Invoke(this, entity);
return(entity);
}
public virtual void RegisterEntity(Entity ent)
{
SubscribeToEntityEvents(ent);
switch (ent.Team)
{
case EntityTeam.Players:
players.Add(ent);
OnPlayerCreated.Invoke(ent);
break;
case EntityTeam.Allies:
allies.Add(ent);
break;
case EntityTeam.Enemies:
enemies.Add(ent);
OnEnemyCreated.Invoke(ent);
break;
}
OnEntityCreated.Invoke(ent);
}
public int CreateEntity(float x, float y, float rotation = 0f, int parentEntity = ROOT_ENTITY)
{
if (!IsAtEntityCapacity)
{
int entity = entities[EntityCount++];
// All entities should have a transform by default. Anything that doesn't need a transform is better suited to being a separate process or system.
AddComponent(entity, new Transform(x, y, rotation));
Parent(entity, parentEntity);
Console.WriteLine("Created " + entity);
OnEntityCreated?.Invoke(entity);
return(entity);
}
else
{
Console.WriteLine("The number of entities is already at capacity " + EntityCount + " / " + EntityCapacity);
return(NO_ENTITY);
}
}
// TODO: Locks?
public int Create()
{
if (EntityCountLong >= long.MaxValue)
{
throw new ArgumentOutOfRangeException("Entity limit reached");
}
var createdEntityId = _lastEntityId + 1;
while (Exists(createdEntityId) || createdEntityId == NonExistingEntityId)
{
unchecked
{
createdEntityId++;
}
}
_lastEntityId = createdEntityId;
_existingEntityIds.Add(createdEntityId);
Interlocked.Increment(ref _entityCount);
OnEntityCreated?.Invoke(this, new EntityIdEventArgs(createdEntityId));
return(createdEntityId);
}
internal void EntityCreated(IEntity entity)
{
OnEntityCreated?.Invoke(this, entity);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="peer">Peer</param>
/// <param name="token">Token</param>
public ClientSynchronizer(IPeer peer, string token) : base()
{
Peer = peer ?? throw new ArgumentNullException(nameof(peer));
AddAutomaticMessageParserWithFatality <AuthentificationAcknowledgedMessageData>
(
(_, message, __) =>
{
if (IsAuthentificated)
{
SendErrorMessageToPeer <AuthentificationAcknowledgedMessageData>(peer, EErrorType.InvalidMessageContext, "Authentification has been already acknowledged.", true);
}
else
{
Token = message.Token;
user = new ClientUser(message.GUID);
RegisterUserEvents(user);
OnAuthentificationAcknowledged?.Invoke(User);
}
}
);
AddAutomaticMessageParser <AuthentificationFailedMessageData>((currentPeer, message, _) => OnAuthentificationFailed?.Invoke(currentPeer, message.Message, message.Reason));
AddAutomaticMessageParser <ListLobbyResultsMessageData>
(
(_, message, __) =>
{
ILobbyView[] lobbies = new ILobbyView[message.Lobbies.Count];
Parallel.For(0, lobbies.Length, (index) => lobbies[index] = (LobbyView)message.Lobbies[index]);
OnLobbiesListed?.Invoke(lobbies);
}
);
AddAutomaticMessageParser <ListLobbiesFailedMessageData>((currentPeer, message, _) => OnListLobbiesFailed?.Invoke(currentPeer, message.Message, message.Reason));
AddAutomaticMessageParser <ListAvailableGameModeResultsMessageData>((_, message, __) => OnAvailableGameModesListed?.Invoke(message.GameModes));
AddAutomaticMessageParser <ListAvailableGameModesFailedMessageData>((currentPeer, message, _) => OnListAvailableGameModesFailed?.Invoke(currentPeer, message.Message, message.Reason));
AddAutomaticMessageParser <JoinLobbyAcknowledgedMessageData>
(
(_, message, __) => AssertIsUserAuthentificated <JoinLobbyAcknowledgedMessageData>
(
(clientUser) =>
{
if (clientUser.Lobby == null)
{
Dictionary <string, IUser> users = new Dictionary <string, IUser>();
List <IInternalClientUser> user_list = new List <IInternalClientUser>();
foreach (UserData user in message.Users)
{
IInternalClientUser client_user;
if (user.GUID == clientUser.GUID)
{
client_user = clientUser;
this.user.SetNameInternally(user.Name, false);
this.user.SetLobbyColorInternally(user.LobbyColor, false);
}
else
{
client_user = new ClientUser(user.GUID, user.GameColor, user.Name, user.LobbyColor);
RegisterUserEvents(client_user);
}
users.Add(user.GUID.ToString(), client_user);
user_list.Add(client_user);
}
IInternalClientLobby client_lobby = new ClientLobby(this, message.Rules.LobbyCode, message.Rules.Name, message.Rules.GameMode, message.Rules.IsPrivate, message.Rules.MinimalUserCount, message.Rules.MaximalUserCount, message.Rules.IsStartingGameAutomatically, message.Rules.GameModeRules, users[message.OwnerGUID.ToString()], users);
client_lobby.OnUserJoined += (user) => OnUserJoined?.Invoke(client_lobby, user);
client_lobby.OnUserLeft += (user, reason, leaveMessage) => OnUserLeft?.Invoke(client_lobby, user, reason, leaveMessage);
client_lobby.OnLobbyOwnershipChanged += () => OnLobbyOwnershipChanged?.Invoke(client_lobby);
client_lobby.OnLobbyRulesChanged += () => OnLobbyRulesChanged?.Invoke(client_lobby);
client_lobby.OnGameStarted += () => OnGameStarted?.Invoke(client_lobby);
client_lobby.OnGameStartRequested += (time) => OnGameStartRequested?.Invoke(client_lobby, time);
client_lobby.OnGameRestarted += () => OnGameRestarted?.Invoke(client_lobby);
client_lobby.OnGameRestartRequested += (time) => OnGameRestartRequested?.Invoke(client_lobby, time);
client_lobby.OnGameStopped += (gameStopUsers, results) => OnGameStopped?.Invoke(client_lobby, gameStopUsers, results);
client_lobby.OnGameStopRequested += (time) => OnGameStopRequested?.Invoke(client_lobby, time);
client_lobby.OnStartGameCancelled += () => OnStartGameCancelled?.Invoke(client_lobby);
client_lobby.OnRestartGameCancelled += () => OnRestartGameCancelled?.Invoke(client_lobby);
client_lobby.OnStopGameCancelled += () => OnStopGameCancelled?.Invoke(client_lobby);
client_lobby.OnUserEntityCreated += (user) => OnUserEntityCreated?.Invoke(client_lobby, user);
client_lobby.OnUserEntityUpdated += (user) => OnUserEntityUpdated?.Invoke(client_lobby, user);
client_lobby.OnUserEntityDestroyed += (user) => OnUserEntityDestroyed?.Invoke(client_lobby, user);
client_lobby.OnEntityCreated += (entity) => OnEntityCreated?.Invoke(client_lobby, entity);
client_lobby.OnEntityUpdated += (entity) => OnEntityUpdated?.Invoke(client_lobby, entity);
client_lobby.OnEntityDestroyed += (entity) => OnEntityDestroyed?.Invoke(client_lobby, entity);
user.ClientLobby = client_lobby;
foreach (IInternalClientUser client_user in user_list)
{
client_user.ClientLobby = client_lobby;
}
user_list.Clear();
OnLobbyJoinAcknowledged?.Invoke(client_lobby);
user.InvokeUsernameUpdatedEvent();
user.InvokeUserLobbyColorUpdatedEvent();
}
else
{
SendInvalidMessageContextErrorMessageToPeer <JoinLobbyAcknowledgedMessageData>(peer, $"User is already in lobby \"{ clientUser.Lobby.Name }\" with lobby code \"{ clientUser.Lobby.LobbyCode }\".");
}
}
)
);
AddAutomaticMessageParser <JoinLobbyFailedMessageData>((currentPeer, message, _) => OnJoinLobbyFailed?.Invoke(currentPeer, message.Message, message.Reason));
AddAutomaticMessageParser <CreateLobbyFailedMessageData>((currentPeer, message, _) => OnCreateLobbyFailed?.Invoke(currentPeer, message.Message, message.Reason));
AddAutomaticMessageParser <LobbyRulesChangedMessageData>
(
(_, message, __) => AssertIsUserInLobby <LobbyRulesChangedMessageData>
(
(clientUser, clientLobby) =>
{
LobbyRulesData rules = message.Rules;
clientLobby.ChangeLobbyRulesInternally
(
rules.LobbyCode,
rules.Name,
rules.GameMode,
rules.IsPrivate,
rules.MinimalUserCount,
rules.MaximalUserCount,
rules.IsStartingGameAutomatically,
rules.GameModeRules
);
}
)
);
AddAutomaticMessageParser <UserJoinedMessageData>
(
(_, message, __) => AssertIsUserInLobby <UserJoinedMessageData>
(
(clientUser, clientLobby) =>
{
IUser user = new ClientUser(message.GUID, message.GameColor, message.Name, message.LobbyColor);
RegisterUserEvents(user);
if (!clientLobby.AddUserInternally(user))
{
SendInvalidMessageContextErrorMessageToPeer <UserJoinedMessageData>(peer, $"Failed to add user \"{ user.Name }\" with GUID \"{ user.GUID }\" to lobby \"{ clientLobby.Name }\" with lobby code \"{ clientLobby.LobbyCode }\".");
}
}
)
);
AddAutomaticMessageParser <UserLeftMessageData>
(
(_, message, __) => AssertTargetLobbyUser <UserLeftMessageData>
(
message.GUID,
(clientUser, clientLobby, targetUser) =>
{
if (!clientLobby.RemoveUserInternally(targetUser, message.Reason, message.Message))
{
SendInvalidMessageContextErrorMessageToPeer <UserLeftMessageData>(peer, $"Failed to remove user \"{ targetUser.Name }\" with GUID \"{ targetUser.GUID }\" from lobby \"{ clientLobby.Name }\" with lobby code \"{ clientLobby.LobbyCode }\".");
}
targetUser.ClientLobby = null;
}
)
);
AddAutomaticMessageParser <LobbyOwnershipChangedMessageData>((_, message, __) => AssertTargetLobbyUser <LobbyOwnershipChangedMessageData>(message.NewOwnerGUID, (clientUser, clientLobby, targetUser) => clientLobby.ChangeLobbyOwnershipInternally(targetUser)));
AddAutomaticMessageParser <UsernameChangedMessageData>((_, message, __) => AssertTargetLobbyUser <UsernameChangedMessageData>(message.GUID, (clientUser, clientLobby, targetUser) => targetUser.SetNameInternally(message.NewUsername)));
AddAutomaticMessageParser <ChangeUsernameFailedMessageData>((currentPeer, message, _) => OnChangeUsernameFailed?.Invoke(currentPeer, message.Message, message.Reason));
AddAutomaticMessageParser <UserLobbyColorChangedMessageData>((_, message, __) => AssertTargetLobbyUser <UserLobbyColorChangedMessageData>(message.GUID, (clientUser, clientLobby, targetUser) => targetUser.SetLobbyColorInternally(message.NewLobbyColor)));
AddAutomaticMessageParser <ChangeUserLobbyColorFailedMessageData>((currentPeer, message, _) => OnChangeUserLobbyColorFailed?.Invoke(currentPeer, message.Message, message.Reason));
AddAutomaticMessageParser <ChangeLobbyRulesFailedMessageData>((currentPeer, message, _) => OnChangeLobbyRulesFailed?.Invoke(currentPeer, message.Message, message.Reason));
AddAutomaticMessageParser <KickUserFailedMessageData>((currentPeer, message, _) => OnKickUserFailed?.Invoke(currentPeer, message.Message, message.Reason));
AddAutomaticMessageParser <GameStartRequestedMessageData>((_, message, __) => AssertIsUserInLobby <GameStartRequestedMessageData>((clientUser, clientLobby) => clientLobby.InvokeGameStartRequestedEventInternally(message.Time)));
AddAutomaticMessageParser <GameStartedMessageData>((_, message, __) => AssertIsUserInLobby <GameStartedMessageData>((clientUser, clientLobby) => clientLobby.InvokeGameStartedEventInternally()));
AddAutomaticMessageParser <StartGameFailedMessageData>((currentPeer, message, _) => OnStartGameFailed?.Invoke(currentPeer, message.Message, message.Reason));
AddAutomaticMessageParser <GameRestartRequestedMessageData>((_, message, __) => AssertIsUserInLobby <GameRestartRequestedMessageData>((clientUser, clientLobby) => clientLobby.InvokeGameRestartRequestedEventInternally(message.Time)));
AddAutomaticMessageParser <GameRestartedMessageData>((_, message, js__on) => AssertIsUserInLobby <GameRestartedMessageData>((clientUser, clientLobby) => clientLobby.InvokeGameRestartedEventInternally()));
AddAutomaticMessageParser <RestartGameFailedMessageData>((currentPeer, message, _) => OnRestartGameFailed?.Invoke(currentPeer, message.Message, message.Reason));
AddAutomaticMessageParser <GameStopRequestedMessageData>((_, message, __) => AssertIsUserInLobby <GameStopRequestedMessageData>((clientUser, clientLobby) => clientLobby.InvokeGameStopRequestedEventInternally(message.Time)));
AddAutomaticMessageParser <GameStoppedMessageData>
(
(_, message, __) => AssertIsUserInLobby <GameStoppedMessageData>
(
(clientUser, clientLobby) =>
{
Dictionary <string, UserWithResults> users = new Dictionary <string, UserWithResults>();
foreach (GameEndUserData user in message.Users)
{
string key = user.GUID.ToString();
if (clientLobby.Users.ContainsKey(key))
{
users.Add(key, new UserWithResults(clientLobby.Users[key], user.Results));
}
else
{
SendErrorMessage <GameStoppedMessageData>(EErrorType.InvalidMessageContext, $"User with GUID \"{ key }\" is not in lobby \"{ clientLobby.Name }\" with lobby code \"{ clientLobby.LobbyCode }\".");
}
}
clientLobby.InvokeGameStoppedEventInternally(users, message.Results);
}
)
);
AddAutomaticMessageParser <StopGameFailedMessageData>((currentPeer, message, _) => OnStopGameFailed?.Invoke(currentPeer, message.Message, message.Reason));
AddAutomaticMessageParser <StartGameCancelledMessageData>((currentPeer, message, _) => AssertIsUserInLobby <GameStoppedMessageData>((__, clientLobby) => clientLobby.InvokeStartGameCancelledEventInternally()));
AddAutomaticMessageParser <RestartGameCancelledMessageData>((currentPeer, message, _) => AssertIsUserInLobby <GameStoppedMessageData>((__, clientLobby) => clientLobby.InvokeRestartGameCancelledEventInternally()));
AddAutomaticMessageParser <StopGameCancelledMessageData>((currentPeer, message, _) => AssertIsUserInLobby <GameStoppedMessageData>((__, clientLobby) => clientLobby.InvokeStopGameCancelledEventInternally()));
AddAutomaticMessageParser <CancelStartRestartStopGameTimerFailedMessageData>((currentPeer, message, _) => OnCancelStartRestartStopGameTimerFailed?.Invoke(currentPeer, message.Message, message.Reason));
AddAutomaticMessageParser <ServerGameLoadingProcessFinishedMessageData>((currentPeer, message, _) => AssertTargetLobbyUser <ServerGameLoadingProcessFinishedMessageData>(message.UserGUID, (__, ___, targetUser) => targetUser.InvokeServerGameLoadingProcessFinishedEvent()));
AddMessageParser <ServerTickMessageData>
(
(_, message, __) => AssertIsUserInLobby <ServerTickMessageData>((clientUser, clientLobby) => clientLobby.ProcessServerTickInternally(message.Time, message.Entities, message.Hits)),
(_, message, __) => SendServerTickFailedMessage(message, EServerTickFailedReason.Unknown),
MessageParseFailedEvent <ServerTickMessageData>
);
AddAutomaticMessageParser <ClientTickFailedMessageData>((currentPeer, message, _) => OnClientTickFailed?.Invoke(currentPeer, message.Message, message.Reason));
OnPeerConnected += (_) => SendAuthenticateMessage(token);
}
public Task Handle(OnEntityCreated <GarmentAvalProductItem> notification, CancellationToken cancellationToken)
{
return(Task.CompletedTask);
}
public Task Handle(OnEntityCreated <ManufactureOrder> notification, CancellationToken cancellationToken)
{
return(Task.CompletedTask);
}
public override Tuple <Option <IEntityWrapper>, IEnumerable <ValidationRule> > Bootstrap(IReadableAtom <EA.Repository> eaRepository)
{
var entityWrapper = new AdEntityWrapper();
var entityRepository = new AdRepository(eaRepository, entityWrapper);
var migrator = new Migrator(technology);
var tvClipboard = new Atom <TaggedValuesClipboard>(new TaggedValuesClipboard());
var updateMetadataCommand = new UpdateMetadataOfNewElementsCommand(entityRepository);
var updateStateOnAlternativesChanged = new UpdateProblemOccurrenceStateOnAlternativesChanged(entityRepository);
var updateStateOnAlternativesAdded = new UpdateProblemOccurrenceStateOnAlternativesAdded(entityRepository);
var updateStateOnRemoveAlternative = new UpdateProblemOccurrenceStateOnAlternativeRemoved(entityRepository);
var populateDependenciesCommand = new PopulateDependenciesCommand(
entityRepository, new DependencySelectorForm(entityRepository));
var instantiateProblemSpace = new InstantiateProblemSpaceCommand(entityRepository, new InstantiateSolutionForm());
var exportProblemSpace = new ExportProblemSpaceCommand(
entityRepository, new TailorPackageExportForm(), new XmlExporter.Factory(entityRepository, eaRepository), new SelectExportPathDialog());
Register(new Menu(AddInName,
new MenuItem("Copy Tagged Values",
new CopyTaggedValuesCommand(tvClipboard).ToMenuHandler()),
new MenuItem("Paste Tagged Values",
new PasteTaggedValuesCommand(tvClipboard, entityRepository).ToMenuHandler()),
new MenuItem("Paste Tagged Values into Descendant Elements",
new PasteTaggedValuesIntoChildrenCommand(tvClipboard, entityRepository).ToMenuHandler()),
new Separator(),
new MenuItem("Choose Selected and Neglect not chosen Alternatives",
new ChooseOptionOccurrenceCommand <Unit>(entityRepository, updateStateOnAlternativesChanged).ToMenuHandler()),
new MenuItem("Neglect all Alternatives",
new NeglectAllOptionsCommand(entityRepository).ToMenuHandler()),
new Separator(),
new MenuItem("Tailor Problem Space",
exportProblemSpace.ToMenuHandler()),
new MenuItem("Create Solution Space from Problem Space",
instantiateProblemSpace.ToMenuHandler()),
new MenuItem("Locate Option/Problem",
new GoToClassifierCommand(entityRepository).ToMenuHandler()),
new MenuItem("Establish Dependencies from Problem Space",
populateDependenciesCommand.ToMenuHandler()),
new MenuItem("Migrate Element(s) to Current Model Version",
new MigrateModelEntitiesCommand(migrator).ToMenuHandler()),
new Separator(),
new MenuItem("Package Metrics",
new AnalysePackageCommand(entityRepository, new DisplayMetricsForm()).ToMenuHandler())));
OnEntityCreated.Add(updateMetadataCommand.ToEntityCreatedHandler());
OnEntityCreated.Add(updateStateOnAlternativesAdded.ToEntityCreatedHandler());
OnEntityModified.Add(updateStateOnAlternativesChanged.ToEntityModifiedHandler());
OnDeleteEntity.Add(updateStateOnRemoveAlternative.AsOnDeleteEntityHandler());
var rules = new[] {
ValidationRule.FromCommand(AddInName, new ValidateProblemOptionCompositionCommand(entityRepository)),
ValidationRule.FromCommand(AddInName, new ValidateProblemOccurrenceStateCommand(entityRepository)),
ValidationRule.FromCommand(AddInName, new ValidateConflictingOptionsCommand(entityRepository)),
ValidationRule.FromCommand(AddInName, new MultipleProblemsAddressedByAnOptionCommand(entityRepository)),
ValidationRule.FromCommand(AddInName, migrator.GetValidator()),
new ElementNotUsedDiagramRule(AddInName, entityRepository)
};
return(Tuple.Create(
Options.Some(entityWrapper as IEntityWrapper),
rules.AsEnumerable()));
}
public Task Handle(OnEntityCreated <GarmentDeliveryReturn> notification, CancellationToken cancellationToken)
{
return(Task.CompletedTask);
}
public Task Handle(OnEntityCreated <GarmentPreparing> notification, CancellationToken cancellationToken)
{
return(Task.CompletedTask);
}
internal static void RaiseEntityCreated(Entity entity)
{
OnEntityCreated?.Invoke(entity);
}
