public Task AddSingleEntityConnection(VersaCommsID destinationID, string connectionID)
{
if (Store.ConnectionGroupings.GetOrAdd(destinationID, ImmutableList.Create <string>()).Contains(connectionID)
)
{
return(Task.CompletedTask);
}
Store.ConnectionGroupings.AddOrUpdate(destinationID, ImmutableList.Create <string>().Add(connectionID),
(k, l) => l.Add(connectionID));
var AddTasks = new List <Task>
{
hubContext.Groups.AddToGroupAsync(connectionID, "versagen_" + destinationID)
};
foreach (var item in Store.groupItems)
{
if (item.Value.Contains(destinationID))
{
AddTasks.Add(hubContext.Groups.AddToGroupAsync(connectionID, "versagen_" + item.Key));
}
}
return(Task.WhenAll(AddTasks));
}
public DefaultScopedServicesFactory(VersaCommsID id, IServiceProvider baseProvider,
IServiceProvider scenarioProvider)
{
this.baseProvider = baseProvider;
this.scenarioProvider = scenarioProvider;
this.id = id;
}
public IdentityPlayer(VersaCommsID newID) : this()
{
if (newID.IdType != EVersaCommIDType.User)
{
throw new ArgumentOutOfRangeException(nameof(newID), "Object was not provided a User ID value.");
}
}
public IdentityPlayer()
{
VersaID = VersaCommsID.FromEnum(EVersaCommIDType.User, 0);
Currencies = new Dictionary <int, int>();
OwnedCharacters = new List <VersaCommsID>();
PlayerInventory = new List <IItem>();
}
public void TestConfig()
{
var one = VersaCommsID.FromEnum(EVersaCommIDType.User, ulong.MinValue);
var two = VersaCommsID.FromEnum(EVersaCommIDType.User, ulong.MaxValue);
Assert.True(true);
}
public VersaSignalRWriter(VersaCommsID destID, IClientProxy sender, string functionName, HtmlEncoder encoder)
{
DestinationID = destID;
proxy = sender;
this.functionName = functionName;
Encoder = encoder;
}
public IVersaGroupWriter GetOrCreateGroup(VersaCommsID id)
{
if (!Store.groupItems.ContainsKey(id))
{
Store.groupItems.AddOrUpdate(id, ImmutableList.Create <VersaCommsID>(), (k, l) => l);
}
return(new SignalRVersaGroupWriter <THub>(id, this,
hubContext.Clients.Group("versagen_" + id), config.NameOfWriterFunction, encoder));
}
public static ModelBuilder SupportIPlayerIdentity <TIdentity, TKey>(this ModelBuilder b) where TIdentity : IdentityUser <TKey>, IPlayer where TKey : IEquatable <TKey>
{
b.HasSequence <long>("IDEnumerator", "versagen")
.IncrementsBy(1)
.StartsAt(Convert.ToInt64(VersaCommsID.FromEnum(EVersaCommIDType.User, ulong.MinValue)))
.HasMax(Convert.ToInt64(VersaCommsID.FromEnum(EVersaCommIDType.User, ulong.MaxValue)))
.IsCyclic();
b.ApplyConfiguration(new IdentityPlayerConfig <TIdentity, TKey>());
return(b);
}
public Entity(VersaCommsID Id, IEnumerable <IVersaCommand> initCommands = default, IReaction[] reactions = default)
{
this.Id = Id;
Reactions = reactions;
ActAsCommands = new CommandGroup("self", "/commands/self/" + Id);
ActAsCommands.Preconditions.Add(new LambdaRule("IsEntity", "", (context, provider) => Task.FromResult((context.ActingEntity == this, "wrongEntity"))));
initCommands.ForEach(x => ActAsCommands.TryAdd(x));
Stats = new ConcurrentDictionary <string, IStat>();
_owners = new List <VersaCommsID>();
}
protected virtual VersaCommsID CreateNewUser(TExternalID externalUser)
{
//TODO: fire off other functions needed to create a new user, like creating tables for them in the database and such.
var rand = new Random();
byte[] buf = new byte[8];
rand.NextBytes(buf);
ulong resul = BitConverter.ToUInt64(buf, 0);
return(VersaCommsID.FromEnum(EVersaCommIDType.User, resul));
}
public bool DeleteGroupWriter(VersaCommsID id)
{
if (!Store.groupItems.ContainsKey(id))
{
return(false);
}
foreach (var x in Store.groupItems[id])
{
RemoveFromSignalRConnection(id, x).Wait();
}
Store.groupItems.Remove(id, out _);
return(true);
}
public Task RemoveFromSignalRConnection(VersaCommsID groupID, VersaCommsID connectionGroupingID)
{
if (!Store.ConnectionGroupings.ContainsKey(connectionGroupingID))
{
return(Task.CompletedTask);
}
if (Store.groupItems.ContainsKey(groupID))
{
Store.groupItems.AddOrUpdate(groupID, ImmutableList.Create <VersaCommsID>(), (k, l) => l.Remove(connectionGroupingID));
}
return(Task.WhenAll(Store.ConnectionGroupings[connectionGroupingID]
.Select(c => hubContext.Groups.RemoveFromGroupAsync(c, "versagen_" + groupID))));
}
public async void AsyncDisposeTest()
{
pipe = new EventPipe();
var endThing = new TaskCompletionSource <bool>();
var disposer = new RefCountDisposable(Disposable.Create(() => endThing.SetResult(true)));
for (var i = 0; i < 100; i++)
{
pipe.ObserveFirst.Subscribe(new TestObserver(i, outp, "first", disposer.GetDisposable()));
pipe.ObserveConcurrent.Subscribe(new TestObserver(i, outp, "reader", disposer.GetDisposable()));
pipe.ObserveSynchronous.Subscribe(new TestObserver(i, outp, "writer", disposer.GetDisposable()));
}
disposer.Dispose();
//var testTask = new List<Task>();
var totalDisposer = new RefCountDisposable(Disposable.Create(() => pipe.Complete()));
var rand = new Random();
Parallel.ForEach(Enumerable.Range(0, 99), async x =>
{
using (totalDisposer.GetDisposable())
{
using (var scp = testProv.CreateScope())
{
var e = new MessageEvent
{
IgnoreThis = false,
Services = scp.ServiceProvider.CreateScope().ServiceProvider,
Scenario = VersaCommsID.FromEnum(EVersaCommIDType.Scenario, 0),
Player = new UnionType <VersaCommsID, IPlayer>(0),
Terminal = new UnionType <VersaCommsID, IVersaWriter>(0),
FullMessage = x.ToString(),
Entity = new UnionType <VersaCommsID, IEntity>(0),
};
await Task.Yield();
await pipe.ProcessEvent(e);
}
}
});
//totalDisposer.Dispose();
//scp.Dispose();
//await Task.WhenAll(testTask);
await Task.Delay(200);
totalDisposer.Dispose();
//await Task.Delay(200);
await endThing.Task;
//pipe.Dispose();
}
public Scenario(VersaCommsID scenarioId, IServiceProvider provider)
{
ScenarioID = scenarioId;
tokenSource = new CancellationTokenSource();
scScope = provider.GetRequiredService <IScenarioScopeFactory>()
.ConfigureScenarioServices(scenarioId);
GMs = new ImmutableArray <IPlayer>();
var tempProv = scScope.GetScenarioServiceProvider(provider);
Pipe = tempProv.GetRequiredService <IEventPipe>();
Pipe.SubscribePreprocess(new EventObjectFetcher(this));
comServ = tempProv.GetRequiredService <ICommandService>();
var repeater = tempProv.GetRequiredService <MessageRepeater>();
Pipe.ObserveSynchronous.Subscribe(comServ);
Pipe.ObserveFirst.Subscribe(repeater);
tempProv.GetService <RootLocationHolder>();
}
public Player(VersaCommsID ID)
{
this.VersaID = ID;
}
bool IsCustomGroupable(VersaCommsID id) => (!id.IdType.HasFlag(EVersaCommIDType.Unicast));
public Task <TKey> GetExternalID(VersaCommsID identifier) => Users .Where(user => user.VersaID == identifier) .Select(user => user.Id) .ToAsyncEnumerable().SingleOrDefault();
public bool AddOwner(VersaCommsID id)
{
_owners.Add(id);
return(true);
}
public IVersaWriter GetWriter(VersaCommsID Id)
{
//Ignoring users method b/c generic usage. Someone might not be using Identity with this so it may be a different user that is contacted.
return(new VersaSignalRWriter(Id, hubContext.Clients.Group("versagen_" + Id), config.NameOfWriterFunction,
encoder));
}
IPlayer IPlayerStore.GetPlayer(VersaCommsID id)
{
return(GetPlayer(id));
}
public IVersaGroupWriter CreateGroup(EVersaCommIDType type)
{
return(GetOrCreateGroup(VersaCommsID.RandomOutsideRange(type, Store.groupItems.Keys)));
}
Task <TVersaIdentity> IPlayerStore <TVersaIdentity> .GetPlayerAsync(VersaCommsID id)
{
return(TranslatePlayerAsync(id));
}
internal ScenarioServiceProvider(VersaCommsID scenarioID, IServiceProvider baseProvider, IServiceProvider scenarioScope, params object[] instanceObjects)
{
ScenarioID = scenarioID;
this.BaseProvider = baseProvider;
this.ScenarioProvider = scenarioScope;
}
public bool setIDIfUnset(VersaCommsID id)
{
throw new NotImplementedException();
}
public DefaultScenarioServicesScope(VersaCommsID id, IServiceScope baseScope, IServiceScope scenarioScope)
{
this.baseScope = baseScope;
this.scenarioScope = scenarioScope;
ServiceProvider = new ScenarioServiceProvider(id, baseScope.ServiceProvider, scenarioScope.ServiceProvider);
}
public IScenario BuildWorldScenario(IServiceProvider provider)
{
return(_Scenarios.GetOrAdd(VersaCommsID.FromEnum(EVersaCommIDType.Scenario, 0), new Scenario(VersaCommsID.FromEnum(EVersaCommIDType.Scenario, 0), provider)));
}
public IScenario CreateScenario(IServiceProvider provider, VersaCommsID gameMasterID, VersaCommsID[] partyIDs)
{
throw new NotImplementedException();
}
async Task <IPlayer> IPlayerStore.GetPlayerAsync(VersaCommsID id)
{
return(await TranslatePlayerAsync(id));
}
public bool RemoveOwner(VersaCommsID id)
{
return(_owners.Remove(id));
}
public ScenarioScope(VersaCommsID scenarioID, IServiceProvider scenarioProvider)
{
this.ScenarioID = scenarioID;
ScenarioProviderUnscoped = scenarioProvider;
}
