private void TestApiPublic(INetworkProvider provider)
{
var ctx = new NetworkProviderContext();
var r = AsyncContext.Run(() => provider.TestPublicApiAsync(ctx));
Assert.IsTrue(r);
}
public static INetworkProvider GetInstance()
{
if (obj == null)
{
obj = new NetworkProvider();
}
return(obj);
}
public EntityManager(GraphicsDevice device, World world, INetworkProvider networkProvider)
{
Network = networkProvider;
World = world;
Device = device;
Entities = new ConcurrentDictionary <long, IEntity>();
EntityByUUID = new ConcurrentDictionary <UUID, IEntity>();
}
public CarDataProvider(IJsonProvider jsonProvider, ICacheDataProvider cacheDataProvider, HttpClient httpClient, INetworkProvider networkProvider, IStatisticDataProvider statisticDataProvider)
{
_httpClient = httpClient;
_jsonProvider = jsonProvider;
_cacheDataProvider = cacheDataProvider;
_networkProvider = networkProvider;
_statisticDataProvider = statisticDataProvider;
}
internal void SetNetworkInformation(INetworkProvider networkProvider)
{
Endpoint = networkProvider.GetLocalEndpoint();
if (networkProvider is ICommunicationProvider networkProvider2)
{
AssemblyQualifiedName = networkProvider2.RemoteNetworkProviderType.AssemblyQualifiedName;
}
}
public BedrockWorldProvider(Alex alex, IPEndPoint endPoint, PlayerProfile profile,
out INetworkProvider networkProvider)
{
Alex = alex;
Client = new BedrockClient(alex, endPoint, profile, new DedicatedThreadPool(new DedicatedThreadPoolSettings(Environment.ProcessorCount, ThreadType.Background, "BedrockClientThread")), this);
networkProvider = Client;
}
public Listener(
IListenerLogger logger,
InlineSocketsOptions options,
INetworkProvider networkProvider)
{
_logger = logger;
_options = options;
_networkProvider = networkProvider;
}
public World(Alex alex, GraphicsDevice graphics, AlexOptions options, Camera camera,
INetworkProvider networkProvider)
{
Alex = alex;
Graphics = graphics;
Camera = camera;
Options = options;
PhysicsEngine = new PhysicsManager(alex, this);
ChunkManager = new ChunkManager(alex, graphics, options, this);
EntityManager = new EntityManager(graphics, this, networkProvider);
Ticker = new TickManager(this);
PlayerList = new PlayerList();
ChunkManager.Start();
var profileService = alex.Services.GetService <IPlayerProfileService>();
string username = string.Empty;
Skin skin = profileService?.CurrentProfile?.Skin;
if (skin == null)
{
alex.Resources.ResourcePack.TryGetBitmap("entity/alex", out Bitmap rawTexture);
var t = TextureUtils.BitmapToTexture2D(graphics, rawTexture);
skin = new Skin()
{
Texture = t,
Slim = true
};
}
if (!string.IsNullOrWhiteSpace(profileService?.CurrentProfile?.Username))
{
username = profileService.CurrentProfile.Username;
}
Player = new Player(graphics, alex, username, this, skin, networkProvider, PlayerIndex.One);
Player.KnownPosition = new PlayerLocation(GetSpawnPoint());
Camera.MoveTo(Player.KnownPosition, Vector3.Zero);
Options.FieldOfVision.ValueChanged += FieldOfVisionOnValueChanged;
Camera.FOV = Options.FieldOfVision.Value;
PhysicsEngine.AddTickable(Player);
Player.Inventory.IsPeInventory = true;
if (ItemFactory.TryGetItem("minecraft:diamond_sword", out var sword))
{
Player.Inventory[Player.Inventory.SelectedSlot] = sword;
Player.Inventory.MainHand = sword;
}
else
{
Log.Warn($"Could not get diamond sword!");
}
}
/// <summary>
/// Installs the specified <see cref="INetworkProvider"/>.
/// </summary>
/// <param name="networkProvider">INetworkProvider</param>
public void SetNetworkProvider(INetworkProvider networkProvider)
{
if (networkProvider == null)
{
throw new InvalidOperationException("Cannot install a null network provider.");
}
this.NetworkProvider.Dispose();
this.NetworkProvider = networkProvider;
}
public static void EnterRate(INetworkProvider provider, NetworkProviderContext context)
{
var limiter = provider.RateLimiter;
if (limiter.IsSafe())
{
return;
}
limiter.Limit();
}
public Transport(
IListenerLogger logger,
InlineSocketsOptions options,
INetworkProvider networkProvider,
IEndPointInformation endPointInformation,
IConnectionDispatcher dispatcher)
{
_listener = new Listener(logger, options, networkProvider);
_logger = logger;
_endPointInformation = endPointInformation;
_dispatcher = dispatcher;
}
public StatisticDataProvider(HttpClient httpClient,
INetworkProvider networkProvider,
IFileSystemProvider fileSystemProvider,
IJsonProvider jsonProvider,
IDeviceInfoProvider deviceInfoProvider)
{
_httpClient = httpClient;
_networkProvider = networkProvider;
_jsonProvider = jsonProvider;
_deviceInfoProvider = deviceInfoProvider;
_fileSystemProvider = fileSystemProvider;
_fileSystemProvider.AddToPath(AppSettings.StatisticFolderName);
}
public Entity(int entityTypeId, World level, INetworkProvider network)
{
Network = network;
EntityId = -1;
Level = level;
EntityTypeId = entityTypeId;
KnownPosition = new PlayerLocation();
Inventory = new Inventory(46);
// HealthManager = new HealthManager(this);
Inventory.SlotChanged += OnInventorySlotChanged;
}
//--//
public SslStream(Socket socket)
: base(socket, false)
{
if (SocketType.Stream != (SocketType)this._socketType)
{
throw new NotSupportedException();
}
this._isServer = false;
this.sslHandle = -1;
this.ni = Socket.DefaultProvider;
}
private void TestPublicApi(INetworkProvider provider)
{
var ctx = new NetworkProviderContext();
try
{
var r = AsyncContext.Run(() => provider.TestPublicApiAsync(ctx));
Assert.IsTrue(r);
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
}
public NetworkScreen(INetworkProvider networkProvider)
{
NetworkProvider = networkProvider;
Anchor = Alignment.Fill;
NetworkInfoElement = new GuiAutoUpdatingTextElement(GetNetworkInfo, true);
NetworkInfoElement.BackgroundOverlay = Color.Black * 0.5f;
NetworkInfoElement.Anchor = Alignment.BottomRight;
NetworkInfoElement.TextOpacity = 0.5f;
NetworkInfoElement.TextColor = TextColor.Red;
NetworkInfoElement.Scale = 0.5f;
AddChild(NetworkInfoElement);
}
public BedrockWorldProvider(Alex alex, IPEndPoint endPoint, PlayerProfile profile, DedicatedThreadPool threadPool,
out INetworkProvider networkProvider)
{
Alex = alex;
var eventDispatcher = alex.Services.GetRequiredService <IEventDispatcher>();
EventDispatcher = eventDispatcher;
//Client = new ExperimentalBedrockClient(alex, alex.Services, this, endPoint);
Client = new BedrockClient(alex, eventDispatcher, endPoint, profile, threadPool, this);
networkProvider = Client;
EventDispatcher.RegisterEvents(this);
}
public LoginViewModel(
IApiService apiService,
IDialogService dialogService,
IMvxNavigationService navigationService,
INetworkProvider networkProvider)
{
this.apiService = apiService;
this.dialogService = dialogService;
this.navigationService = navigationService;
this.networkProvider = networkProvider;
this.Email = "*****@*****.**";
this.Password = "******";
this.IsLoading = false;
}
public InlineSocketsOptionsDefaults(
IListenerLogger listenerLogger,
IConnectionLogger connectionLogger,
INetworkProvider networkProvider)
{
_configure = options =>
{
#if NETSTANDARD2_0
var memoryPool = Microsoft.AspNetCore.Server.Kestrel.Transport.Abstractions.Internal.KestrelMemoryPool.Create();
#else
var socketTransportOptions = new Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets.SocketTransportOptions();
var socketTransportOptionsTypeInfo = socketTransportOptions.GetType().GetTypeInfo();
var memoryPoolFactoryProperty = socketTransportOptionsTypeInfo.GetDeclaredProperty("MemoryPoolFactory");
var memoryPoolFactory = memoryPoolFactoryProperty.GetValue(socketTransportOptions) as Func <MemoryPool <byte> >;
var memoryPool = memoryPoolFactory.Invoke();
#endif
options.MemoryPool = memoryPool;
options.CreateListener = CreateListener;
options.CreateConnection = CreateConnection;
options.CreateSocketPipelines = CreateSocketPipelines;
options.WrapTransportPipelines = WrapTransportPipelines;
Listener CreateListener()
{
return(new Listener(listenerLogger, options, networkProvider));
}
IConnection CreateConnection(INetworkSocket socket)
{
return(new Connection(connectionLogger, options, socket));
}
(PipeReader input, PipeWriter output) CreateSocketPipelines(IConnection connection, INetworkSocket socket)
{
var input = new SocketPipeReader(connectionLogger, options, connection, socket);
var output = new SocketPipeWriter(connectionLogger, options, connection, socket);
return(input, output);
}
static IDuplexPipe WrapTransportPipelines(IConnection connection, IDuplexPipe transport)
{
var input = new CancelNotificationPipeReader(transport.Input, connection.CancelPendingRead);
return(new DuplexPipe(input, transport.Output));
}
};
}
public LoginViewModel(
IApiService apiService,
IDialogService dialogService,
IMvxNavigationService navigationService,
INetworkProvider networkProvider)
{
this.apiService = apiService;
this.dialogService = dialogService;
this.navigationService = navigationService;
this.networkProvider = networkProvider;
this.Email = "*****@*****.**";
this.Password = "******";
this.IsLoading = false;
}
public LoginViewModel(
IApiService apiService,
IDialogService dialogService,
IMvxNavigationService navigationService,
INetworkProvider networkProvider)
{
_apiService = apiService;
_dialogService = dialogService;
_navigationService = navigationService;
_networkProvider = networkProvider;
Email = "*****@*****.**";
Password = "******";
IsLoading = false;
}
private void TestVolumePricingSanity(INetworkProvider provider, List <AssetPair> pairs)
{
// TODO: to be reviewed and tested when there will be new providers that support Volume and Pricing interfaces.
if (IsVolumePricingSanityTested)
{
return;
}
IsVolumePricingSanityTested = true;
if (provider is IPublicVolumeProvider volumeProvider && provider is IPublicPricingProvider pricingProvider)
{
// Single test.
if (pricingProvider.PricingFeatures.Single == null || volumeProvider.VolumeFeatures.Single == null)
{
return;
}
if (pricingProvider.PricingFeatures.Single.CanVolume ^ volumeProvider.VolumeFeatures.Single.CanVolume)
{
return;
}
var priceCtx = new PublicPriceContext(pairs.First());
var rPrice = AsyncContext.Run(() => pricingProvider.GetPricingAsync(priceCtx));
AssetPrice(rPrice, volumeProvider.VolumeFeatures.Single.CanVolumeBase, volumeProvider.VolumeFeatures.Single.CanVolumeQuote);
// Multiple pairs test.
if (pricingProvider.PricingFeatures.Bulk == null || volumeProvider.VolumeFeatures.Bulk == null)
{
return;
}
if (pricingProvider.PricingFeatures.Bulk.CanVolume ^ volumeProvider.VolumeFeatures.Bulk.CanVolume)
{
return;
}
var pricesCtx = new PublicPricesContext(pairs);
var rPrices = AsyncContext.Run(() => pricingProvider.GetPricingAsync(pricesCtx));
AssetPrice(rPrices, volumeProvider.VolumeFeatures.Bulk.CanVolumeBase, volumeProvider.VolumeFeatures.Bulk.CanVolumeQuote);
}
}
public PlayingState(Alex alex, GraphicsDevice graphics, WorldProvider worldProvider, INetworkProvider networkProvider) : base(alex)
{
NetworkProvider = networkProvider;
World = new World(alex.Services, graphics, Options, new FirstPersonCamera(Options.VideoOptions.RenderDistance, Vector3.Zero, Vector3.Zero), networkProvider);
World.Player.IsFirstPersonMode = true;
WorldProvider = worldProvider;
if (worldProvider is SPWorldProvider)
{
World.DoDaylightcycle = false;
//World.Player.SetInventory(new BedrockInventory(46));
if (ItemFactory.TryGetItem("minecraft:diamond_sword", out var sword))
{
World.Player.Inventory.MainHand = sword;
World.Player.Inventory[World.Player.Inventory.SelectedSlot] = sword;
}
}
var title = new TitleComponent();
WorldProvider = worldProvider;
WorldProvider.Init(World, out var info);
World.WorldInfo = info;
WorldProvider.TitleComponent = title;
_playingHud = new PlayingHud(Alex, World.Player, title);
_debugInfo = new GuiDebugInfo();
InitDebugInfo();
MiniMap = new GuiMiniMap(World.ChunkManager)
{
Anchor = Alignment.TopRight
};
var settings = GetService <IOptionsProvider>();
settings.AlexOptions.VideoOptions.Minimap.Bind(OnMinimapSettingChange);
RenderMinimap = settings.AlexOptions.VideoOptions.Minimap.Value;
if (RenderMinimap)
{
_playingHud.AddChild(MiniMap);
}
_networkScreen = new NetworkScreen(NetworkProvider);
}
public Entity(int entityTypeId, World level, INetworkProvider network)
{
Network = network;
EntityId = -1;
Level = level;
EntityTypeId = entityTypeId;
KnownPosition = new PlayerLocation();
Inventory = new Inventory(46);
// HealthManager = new HealthManager(this);
Inventory.SlotChanged += OnInventorySlotChanged;
Inventory.SelectedHotbarSlotChanged += InventoryOnSelectedHotbarSlotChanged;
HideNameTag = true;
ServerEntity = true;
}
public TransportFactory(
IListenerLogger logger,
IOptions <InlineSocketsOptions> options,
INetworkProvider networkProvider)
{
_create = Create;
ITransport Create(
IEndPointInformation endPointInformation,
IConnectionDispatcher dispatcher)
{
return(new Transport(
logger,
options.Value,
networkProvider,
endPointInformation,
dispatcher));
}
}
public BedrockFormManager(INetworkProvider networkProvider, GuiManager guiManager, InputManager input)
{
NetworkProvider = networkProvider;
GuiManager = guiManager;
InputManager = input;
}
public VolumeSource(INetworkProvider provider, Type interfaceType) : base(provider, interfaceType)
{
}
internal AggregatedAssetPairData(AssetPair pair, INetworkProvider provider)
{
ProviderId = provider.Id;
AssetPair = pair;
Id = GetHash(pair);
}
public ContextArgumentException(Exception exception, INetworkProvider provider, string method = "Unknown") : base(exception, provider, method)
{
}
public ContextArgumentException(string message, INetworkProvider provider, string method = "Unknown") : base(message, provider, method)
{
}
public void Load(ISceneProvider draw, IEventProvider events, INetworkProvider network, ISoundProvider sound, IModuleProvider modules, IMovementProvider movement, ICollisionProvider collision, IVoiceChatProvider voicechat, IWorldManager world, ITextureManager texture, ISoundManager soundmanager)
{
this.drawprovider = draw;
this.eventprovider = events;
this.networkprovider = network;
this.soundprovider = sound;
this.moduleprovider = modules;
this.movementprovider = movement;
this.collisionprovider = collision;
this.voicechatprovider = voicechat;
this.texturemanager = texture;
this.worldmanager = world;
this.soundmanager = soundmanager;
this.LoadContexts (drawprovider, eventprovider, networkprovider, soundprovider, moduleprovider, movementprovider,
collisionprovider, voicechatprovider, texturemanager, worldmanager, soundmanager);
}
public void Load(IEngineContext enginecontext)
{
this.context = enginecontext;
this.network = enginecontext.NetworkProvider;
this.scene = (PokeSceneProvider)enginecontext.SceneProvider;
this.networkmovementprovider = new NetworkMovementProvider(enginecontext.CollisionProvider);
// Load the world
this.context.WorldManager.Load(new Uri(Path.Combine(Environment.CurrentDirectory, Path.Combine(this.context.Configuration[EngineConfigurationName.DataRoot], this.context.Configuration[EngineConfigurationName.WorldFile]))), this.context.EventProvider);
// Bind controls
this.KeybindController.AddKey (Keys.Left, "MoveLeft");
this.KeybindController.AddKey (Keys.Up, "MoveUp");
this.KeybindController.AddKey (Keys.Down, "MoveDown");
this.KeybindController.AddKey (Keys.Right, "MoveRight");
this.KeybindController.AddKey (Keys.Q, "Noclip");
this.KeybindController.AddKey (Keys.Add, "ZoomIn");
this.KeybindController.AddKey (Keys.Subtract, "ZoomOut");
this.KeybindController.AddKey (Keys.NumPad6, "SpeedUp");
this.KeybindController.AddKey (Keys.NumPad9, "SlowDown");
this.KeybindController.AddKey (Keys.F1, "ToggleUnderlayer");
this.KeybindController.AddKey (Keys.F2, "ToggleBaselayer");
this.KeybindController.AddKey (Keys.F3, "ToggleMiddlelayer");
this.KeybindController.AddKey (Keys.F4, "ToggleToplayer");
this.KeybindController.AddKey (Keys.F5, "TogglePlayers");
this.KeybindController.AddKey (Keys.T, "VoiceChat");
this.KeybindController.KeyPressed += this.GameModule_KeyPressed;
this.KeybindController.KeyDown += this.GameModule_KeyDown;
this.KeybindController.KeyUp += this.GameModule_KeyUp;
// Setup Network Provider
this.network.MessageReceived += this.Game_MessageReceived;
this.network.Disconnected += this.Game_Disconnected;
this.network.Send(new PlayerRequestListMessage());
// Setup Scene Provider
this.scene.Cameras.AddItem ("camera1", new ValkyrieCamera (0, 0, 800, 600) { WorldName = this.scene.Players["player1"].WorldName });
this.scene.Players ["player1"].StartedMoving += this.GameModule_StartedMoving;
this.scene.Players ["player1"].StoppedMoving += this.GameModule_StoppedMoving;
this.scene.Players ["player1"].TileLocationChanged += this.GameModule_TileLocationChanged;
this.scene.Players ["player1"].Collided += this.GameModule_Collided;
// Setup Voice Chat Provder
this.context.VoiceChatProvider.UserStartedTalking += this.GameModule_UserStartedTalking;
this.context.VoiceChatProvider.UserStoppedTalking += this.GameModule_UserStoppedTalking;
this.context.VoiceChatProvider.Disconnected += VoiceChatProvider_Disconnected;
this.context.VoiceChatProvider.Connected += VoiceChatProvider_Connected;
// Setup Sound MAnager
this.context.SoundManager.AddSound("PalletTown.wav");
// Setup Script Manager
this.scriptmanager = new ScriptManager (this.context);
this.VoiceChatCheckStart ();
this.IsLoaded = true;
}
