public ForgeDownloadItem(MinecraftVersion MCVersion, string ForgeVersion, string Url, bool UseBMCL)
{
this.MCVersion = MCVersion;
this.ForgeVersion = ForgeVersion;
this.Url = Url;
this.UseBMCL = UseBMCL;
}
public void RunMinecraft(MinecraftVersion ver)
{
Settings.Save();
var PlayerName = this.Settings.PlayerName;
var LogWindow = new ConsoleWindow();
var LaunchMaker = new MinecraftOfflineLaunchMaker(ver, PlayerName, LogWindow);
MainForm.Hide();
Task MCWatcherTask = Task.Factory.StartNew(LaunchMaker.Launch);
if (Settings.NeedDebug)
{
Task.Factory.StartNew(LogWindow.ShowDialogSafely);
}
while (!MCWatcherTask.IsCompleted)
{
Application.DoEvents();
Thread.Sleep(100);
}
if (!Settings.NeedDebug)
{
LogWindow.Close();
}
MainForm.Show();
}
private void GatherChanges(MinecraftVersion minBlockVersionNumber, MinecraftVersion maxBlockVersionNumber, int suggestedMaxBlockRequests,
MinecraftVersion minPlayerVersionNumber, MinecraftVersion maxPlayerVersionNumber, int suggestedMaxPlayerRequests,
BlockMetaData[] blocks, PlayerMetaData[] players,
ref BlockMetaData[] blocksResult, ref PlayerMetaData[] playerResult,
out int nBlocks, out int nPlayers,
out int nBlocksLeft, out int nPlayersLeft,
out MinecraftVersion lastBlockUsedVersion, out MinecraftVersion lastPlayerUsedVersion)
{
nBlocks = 0;
var blockRange = new BlockEnumerateRange(blocks);
GetRangeInfo(blockRange, minBlockVersionNumber, maxBlockVersionNumber, suggestedMaxBlockRequests, out int firstIndex, out nBlocks, out nBlocksLeft, out lastBlockUsedVersion);
if (nBlocks > 0)
{
blocksResult = new BlockMetaData[nBlocks];
Array.Copy(blocks, firstIndex, blocksResult, 0, nBlocks);
}
nPlayers = 0;
var playerRange = new PlayersEnumerateRange(players);
GetRangeInfo(playerRange, minPlayerVersionNumber, maxPlayerVersionNumber, suggestedMaxPlayerRequests, out firstIndex, out nPlayers, out nPlayersLeft, out lastPlayerUsedVersion);
if (nPlayers > 0)
{
playerResult = new PlayerMetaData[nPlayers];
Array.Copy(players, firstIndex, playerResult, 0, nPlayers);
}
}
public async Task CheckImageAsync(ApplicationDbContext context, MinecraftVersion minecraftVersion, CancellationToken cancellationToken)
{
var repo = _dockerSetting.ImageName;
var tag = $"mc-{minecraftVersion.Version}-{minecraftVersion.DockerImageVersion}";
var images = await _client.Images.ListImagesAsync(new ImagesListParameters(), cancellationToken);
if (images.Any(i => i.RepoTags.Contains($"{repo}:{tag}")))
{
return;
}
_logger.LogInformation($"Image '{repo}:{tag}' has not been pulled.");
_logger.LogInformation("Start pulling image.");
try
{
await _client.Images.CreateImageAsync(new ImagesCreateParameters
{
Repo = repo,
Tag = tag
}, null, null, cancellationToken);
_logger.LogInformation($"Pull image '{repo}:{tag}' successfully!");
}
catch (Exception ex)
{
_logger.LogError($"Failed to pull image '{repo}:{tag}'. Reason: {ex.Message}");
}
}
public Task <ResponseToChunkUpdateMessage> InformOfChange(List <IPlayerObserver> initObservers, List <IPlayerObserver> updateObservers, MinecraftVersion lastPlayerVersion, int suggestedMaxPlayerRequests, MinecraftVersion lastBlockVersion, int suggestedMaxBlockRequests)
{
//gather new changes from the last delta of changes with the max requested being filled out
int nBlocksLeft, nPlayersLeft;
MinecraftVersion lastBlockUsedVersion;
MinecraftVersion lastPlayerUsedVersion;
var maxVersion = MinecraftVersion.GetNext();
GatherChangesAndUpdateObservers(updateObservers, lastBlockVersion, maxVersion, suggestedMaxBlockRequests,
lastPlayerVersion, maxVersion, suggestedMaxPlayerRequests,
out nBlocksLeft, out nPlayersLeft, out lastBlockUsedVersion, out lastPlayerUsedVersion);
//information needed to calculate the ask for next request
var response = new ResponseToChunkUpdateMessage();
response.mChunkID = this.mID;
response.mAvailableBlocks = nBlocksLeft;
response.mAvailablePlayers = nPlayersLeft;
response.mLastPlayersVersion = lastPlayerUsedVersion;
response.mLastBlockVersion = lastBlockUsedVersion;
//bring all new observers up to the same place as everyone else, but this might not be everything
if (initObservers.Count > 0)
{
GatherChangesAndUpdateObservers(initObservers, MinecraftVersion.MinValue, response.mLastBlockVersion, int.MaxValue,
MinecraftVersion.MinValue, response.mLastPlayersVersion, int.MaxValue, out nBlocksLeft, out nPlayersLeft, out lastBlockUsedVersion, out lastPlayerUsedVersion);
}
return(Task.FromResult <ResponseToChunkUpdateMessage>(response));
}
public Task <string> UpdatePlayer(string playerSessionID, IPlayerObserver playerObserver, Vec3 position)
{
int idx = mActivePlayers.FindIndex(item => (item.mID == playerSessionID));
if (idx >= 0)
{
if ((position.x < mMinLocation.x) || (position.y < mMinLocation.y) || (position.z < mMinLocation.z) ||
(position.x > mMaxLocation.x) || (position.y > mMaxLocation.y) || (position.z > mMaxLocation.z))
{
IChunkGrain transfer = TransferPlayerTo(playerSessionID, playerObserver, ref position, mActivePlayers[idx].mPosition);
if (transfer != null)
{
LeavePlayer(playerSessionID);
return(Task.FromResult <string>(transfer.GetPrimaryKeyString()));
}
}
mActivePlayers[idx].mPosition = position;
mActivePlayers[idx].mVersion = MinecraftVersion.GetNext();
return(Task.FromResult <string>(this.GetPrimaryKeyString()));
}
return(Task.FromResult <string>(null));
}
private void GatherChanges(MinecraftVersion minBlockVersionNumber, MinecraftVersion maxBlockVersionNumber, int suggestedMaxBlockRequests,
MinecraftVersion minPlayerVersionNumber, MinecraftVersion maxPlayerVersionNumber, int suggestedMaxPlayerRequests,
ref BlockInfo[] blocks, ref PlayerInfo[] players,
out int nBlocks, out int nPlayers,
out int nBlocksLeft, out int nPlayersLeft,
out MinecraftVersion lastBlockUsedVersion, out MinecraftVersion lastPlayerUsedVersion)
{
int firstIndex = 0;
nBlocks = 0;
var blockRange = new BlockEnumerateRange(mBlocks);
GetRangeInfo(blockRange, minBlockVersionNumber, maxBlockVersionNumber, suggestedMaxBlockRequests, out firstIndex, out nBlocks, out nBlocksLeft, out lastBlockUsedVersion);
if (nBlocks > 0)
{
blocks = new BlockInfo[nBlocks];
mBlocks.CopyTo(firstIndex, blocks, 0, nBlocks);
}
nPlayers = 0;
var playerRange = new PlayersEnumerateRange(mActivePlayers);
GetRangeInfo(playerRange, minPlayerVersionNumber, maxPlayerVersionNumber, suggestedMaxPlayerRequests, out firstIndex, out nPlayers, out nPlayersLeft, out lastPlayerUsedVersion);
if (nPlayers > 0)
{
players = new PlayerInfo[nPlayers];
mActivePlayers.CopyTo(firstIndex, players, 0, nPlayers);
}
}
public OptifineDownloadItem(MinecraftVersion MCVersion, string Type, string Patch, string Url)
{
this.MCVersion = MCVersion;
this.Type = Type;
this.Patch = Patch;
this.Url = Url;
}
private void GatherChangesAndUpdateObservers(ActorId[] observers,
MinecraftVersion minBlockVersionNumber, MinecraftVersion maxBlockVersionNumber, int suggestedMaxBlocksRequests,
MinecraftVersion minPlayerVersionNumber, MinecraftVersion maxPlayerVersionNumber, int suggestedMaxPlayerRequests,
out int nBlocksLeft, out int nPlayersLeft,
out MinecraftVersion lastBlockUsedVersion, out MinecraftVersion lastPlayerUsedVersion,
BlockMetaData[] blocks, PlayerMetaData[] players)
{
BlockMetaData[] resultBlocks = null;
PlayerMetaData[] resultPlayers = null;
GatherChanges(minBlockVersionNumber, maxBlockVersionNumber, suggestedMaxBlocksRequests,
minPlayerVersionNumber, maxPlayerVersionNumber, suggestedMaxPlayerRequests,
blocks, players,
ref resultBlocks, ref resultPlayers,
out int nBlocks, out int nPlayers, out nBlocksLeft, out nPlayersLeft,
out lastBlockUsedVersion, out lastPlayerUsedVersion);
//if something to update, tell the observers
if ((nBlocks != 0) || (nPlayers != 0))
{
foreach (var id in observers)
{
var playerAgent = ActorProxy.Create <PlayerAgent>(id, this.ServiceUri);
playerAgent.Update(resultBlocks, resultPlayers);
}
}
}
public override void WriteToStream(Stream TargetStream, MinecraftVersion Version)
{
if (invalidated)
{
update();
}
TargetStream.WriteString(JSON);
}
public override int GetLength(MinecraftVersion Version)
{
if (invalidated)
{
update();
}
return(DataUtils.MeasureString(JSON));
}
public void ShowDownloadForgeList(MinecraftVersion version)
{
Settings.Save();
var downloader = new ForgeDownloader(Settings.UseBMCL, version);
var downloadDialog = new DownloadWindow(downloader);
downloadDialog.ShowDialog(MainForm);
downloadDialog.Dispose();
}
public Preset_Create(PresetsPage presetsPage, MinecraftVersion version)
{
ReferencePresets = presetsPage;
Version = version;
//ModsToAdd = new List<Mod>();
ModsToAdd = new List <string>();
InitializeComponent();
}
/// <summary>
/// Adds a Minecraft Version to the List Versions.
/// </summary>
/// <param name="version"></param>
public void AddVersion(MinecraftVersion version)
{
Versions.Add(version);
version.Presets = new List <Preset>();
//version.ForeverMods = new List<Mod>();
version.ForeverMods = new List <string>();
versionsTable.Rows.Add(version.Name, version.Id);
}
public Task <FeedbackMessage> StartPlayer(string playerSessionID, IPlayerObserver playerObserver, Vec3 position, string[] fromGrain)
{
//Is player already here?
int idx = mActivePlayers.FindIndex(item => (item.mID == playerSessionID));
if (idx >= 0)
{
return(Task.FromResult <FeedbackMessage>(new FeedbackMessage(FeedbackMessage.Responces.Error, "Already Exist")));
}
//Add this player to the active list for other to monitors
PlayerInfo update = new PlayerInfo();
update.mPosition = position;
update.mVersion = MinecraftVersion.GetNext();
update.mID = playerSessionID;
mActivePlayers.Add(update);
//this player want to listen to all associated blocks
mNeedsInitObservers.Add(playerObserver);
//each associated grain needs to update this one
foreach (var pair in mAssociatedGrains)
{
bool bFound = false;
if (fromGrain != null)
{
foreach (var id in fromGrain)
{
if (id == pair.Key)
{
bFound = true;
break;
}
}
}
if (bFound == false)
{
var tracking = pair.Value;
tracking.mNeedInitObservers.Add(playerObserver);
}
}
//if no updates are occuring, now we have a player to update
if (mTimer == null)
{
mTimer = RegisterTimer((_) => Fetch(), null, TimeSpan.FromMilliseconds(0), TimeSpan.FromMilliseconds(mUpdateRateinMilliSeconds));
}
return(Task.FromResult <FeedbackMessage>(new FeedbackMessage(FeedbackMessage.Responces.None)));
}
public PresetsPage(StartWindow startWindow, MinecraftVersion version)
{
ReferenceMain = startWindow;
Version = version;
InitializeComponent();
this.Text = $"{Version.Name} : Presets";
VersionNameLabel.Text = Version.Name;
}
public MCSharpServer(IPAddress Address, int Port)
{
minimumAcceptedVersion = MinimumSupportedVersion;
maximumAcceptedVersion = MaximumSupportedVersion;
tcpServer = new TcpListener(Address, Port);
ServerDescription = new Chat();
ServerDescription.Components.Add(new ChatComponent("A Minecraft Server built with "));
ServerDescription.Components.Add(new ChatComponent("MCSharp.", ChatSyle.Bold, ChatColor.Purple));
}
public Preset_Edit(PresetsPage presetsPage, MinecraftVersion version, Preset preset)
{
ReferencePresets = presetsPage;
Version = version;
PresetToEdit = preset;
//ModsToEdit = new List<Mod>();
ModsToEdit = new List <string>();
InitializeComponent();
}
public void EditVersionInTable(MinecraftVersion version)
{
foreach (DataRow row in versionsTable.Rows)
{
if (row["Id"].ToString() == version.Id.ToString())
{
row["Name"] = version.Name;
}
}
}
public void Create(Profile profile, MinecraftVersion minecraftVersion)
{
_beforeLibraries.Append($"{profile.JvmArgs} ");
_beforeLibraries.Append(
$"-Djava.library.path=\"{profile.GameDirectory}\\versions\\{profile.CurrentVersion}\\natives\" -cp \"");
_afterLibraries.Append(
$"{profile.GameDirectory}\\versions\\{profile.CurrentVersion}\\{profile.CurrentVersion}.jar\" ");
_afterLibraries.Append($"{minecraftVersion.MainClass} ");
_afterLibraries.Append(_getMinecraftArguments(profile, minecraftVersion));
}
private void ParseVersions()
{
VersionCollection.Clear();
_selectedVersion = null;
Manager.GetSingleton.VersionManager.Init();
foreach (var result in Manager.GetSingleton.VersionManager.MinecraftVersions)
{
VersionCollection.Add(result);
}
}
public override void ParseFromStream(Stream Stream, int Length, MinecraftVersion Version)
{
int protocolVersion = Stream.ReadVarInt();
this.Version = new MinecraftVersion(protocolVersion);
ServerAddress = Stream.ReadString();
ServerPort = Stream.ReadUshort();
NextState = (ConnectionState)Stream.ReadVarInt();
if (NextState != ConnectionState.Login && NextState != ConnectionState.Status)
{
throw new FormatException();
}
}
public async Task <GenericResponse> RegisterObserver(ActorId playerAgentID, ActorId[] fromActors)
{
var players = await this.StateManager.GetStateAsync <Dictionary <ActorId, MinecraftVersion> >("observers");
var version = MinecraftVersion.GetNext();
//Is player already here?
if (players.ContainsKey(playerAgentID) == true)
{
return(new GenericResponse(true, "Already Exist"));
}
//this player want to listen to all associated blocks
var initPlayers = await this.StateManager.GetStateAsync <Dictionary <ActorId, MinecraftVersion> >("initializeObservers");
initPlayers.Add(playerAgentID, version);
await this.StateManager.SetStateAsync("initializeObservers", initPlayers);
//map to hash for faster lookup
var map = new HashSet <ActorId>();
foreach (var actor in fromActors)
{
map.Add(actor);
}
var associations = await this.StateManager.GetStateAsync <Dictionary <ActorId, AssociateChunkMetaData> >("associations");
//each associated grain needs to update this one
foreach (var pair in associations)
{
var actorID = pair.Key;
if (map.Contains(actorID) == false)
{
var assocations = pair.Value;
assocations.needInitObservers.Add(actorID);
}
}
await this.StateManager.SetStateAsync("associations", associations);
//if no updates are occuring, now we have a player to update
if (_updateTimer == null)
{
int updateRate = await this.StateManager.GetStateAsync <int>("updateRateMS");
_updateTimer = RegisterTimer((_) => Fetch(), null, TimeSpan.FromMilliseconds(0), TimeSpan.FromMilliseconds(updateRate));
}
return(new GenericResponse());
}
private async void BtnClick_MinecraftDownload(object sender, RoutedEventArgs e)
{
Btn_MinecraftDownload.IsEnabled = false;
using (HttpClient client = new HttpClient())
{
try
{
MinecraftVersion ver = VersionsList.SelectedItem as MinecraftVersion;
if (ver == null)
{
return;
}
string json = await client.GetStringAsync(ver.url);
string t = ver.GetJsonPath();
StorageFile file = await CoreManager.WorkDir.CreateFileAsync(ver.GetJsonPath(), CreationCollisionOption.ReplaceExisting);
await FileIO.WriteTextAsync(file, json);
ValueSet valueSet = new ValueSet();
valueSet["type"] = "version-url";
valueSet["version"] = ver.id;
AppServiceResponse response = await AppServiceManager.appServiceConnection.SendMessageAsync(valueSet);
string url = response.Message["client"]?.ToString();
if (!string.IsNullOrWhiteSpace(url))
{
DownloadItem item = new DownloadItem("Minecraft" + ver.id, ver.GetJarPath(), url);
DownloadManager.DownloadQuene.Add(item);
DownloadManager.StartDownload();
ViewModel.isPaneOpen = true;
}
}
catch (HttpRequestException exp)
{
await dialog.Show(CoreManager.GetStringFromResource("/DownloadPage/DownloadFailed"), exp.Message + exp.StackTrace);
}
catch (IOException exp)
{
await dialog.Show(CoreManager.GetStringFromResource("/DownloadPage/DownloadFailed"), exp.Message + exp.StackTrace);
}
finally
{
Btn_MinecraftDownload.IsEnabled = true;
}
}
}
public static bool[][] GetAvailability(MinecraftVersion ver)
{
bool turtle = MinecraftVersion.VerAtLeast(ver, 5);
bool crossbow = MinecraftVersion.VerAtLeast(ver, 6);
bool netherite = MinecraftVersion.VerAtLeast(ver, 8);
return(new bool[][] {
new bool[] { netherite, netherite, netherite, netherite, netherite, netherite, netherite, netherite, netherite },
new bool[] { true, true, true, true, true, true, true, true, true },
new bool[] { true, true, true, true, true, true, true, true, true },
new bool[] { true, true, true, true, true, true, true, true, true },
new bool[] { true, true, true, true, true, true, true, true, true },
new bool[] { turtle, false, false, false, true, true, true, true, true },
new bool[] { false, false, false, false, turtle, true, true, true, crossbow }
});
}
public async Task Validate_MinecraftVersion()
{
MinecraftVersion v1 = MinecraftVersion.GetNext();
Thread.Sleep(TimeSpan.FromMilliseconds(1));
MinecraftVersion v2 = MinecraftVersion.GetNext();
bool bGreaterThan = (v1 < v2);
bool bLessThan = (v2 > v1);
bool bGreaterEqualThan = (v1 <= v2);
bool bLessEqualThan = (v2 >= v1);
Assert.Equal(true, bGreaterEqualThan);
Assert.Equal(true, bLessEqualThan);
Assert.Equal(true, bLessThan);
Assert.Equal(true, bGreaterThan);
}
public async Task <InformOfChunkChangeResponse> InformOfChange(ActorId[] observer, AssociateChunkMetaData associate, TrackingChunkMetaData tracking)
{
var maxVersion = MinecraftVersion.GetNext();
//Get the data associated with request
var blockPerChunkActor = ActorProxy.Create <BlocksPerChunkActor>(associate.blocksPerChunkActorId, this.ServiceUri);
var playerPerChunkActor = ActorProxy.Create <PlayersPerChunkActor>(associate.playersPerChunkActorId, this.ServiceUri);
var taskPlayerData = playerPerChunkActor.GetAsync();
var taskBlockData = blockPerChunkActor.GetAsync();
await Task.WhenAll(taskPlayerData, taskBlockData);
var blockData = taskBlockData.Result;
var playerData = taskPlayerData.Result;
//gather new changes from the last delta of changes with the max requested being filled out
GatherChangesAndUpdateObservers(observer, tracking.blockVersion, maxVersion, tracking.maxBlocks,
tracking.playerVersion, maxVersion, tracking.maxPlayers,
out int nBlocksLeft, out int nPlayersLeft, out MinecraftVersion lastBlockUsedVersion, out MinecraftVersion lastPlayerUsedVersion,
blockData, playerData);
//information needed to calculate the ask for next request
var response = new InformOfChunkChangeResponse()
{
actorID = this.Id,
availableBlocks = nBlocksLeft,
availablePlayers = nPlayersLeft,
lastPlayersVersion = lastPlayerUsedVersion,
lastBlockVersion = lastBlockUsedVersion
};
//bring all new observers up to the same place as everyone else, but this might not be everything
if (associate.needInitObservers.Count > 0)
{
GatherChangesAndUpdateObservers(associate.needInitObservers.ToArray(), MinecraftVersion.minValue, response.lastBlockVersion, int.MaxValue,
MinecraftVersion.minValue, response.lastPlayersVersion, int.MaxValue,
out nBlocksLeft, out nPlayersLeft, out lastBlockUsedVersion, out lastPlayerUsedVersion,
blockData, playerData);
}
return(response);
}
private void GetRangeInfo(IEnumrateRange enumerate, MinecraftVersion minVersion, MinecraftVersion maxVersion, int suggestedMax,
out int firstIndex, out int nItems, out int nItemsLeft, out MinecraftVersion lastUsedVersion)
{
int count = 0;
int lastIndex = -2;
firstIndex = -1;
lastUsedVersion = maxVersion;
MinecraftVersion prevLastVersion = new MinecraftVersion();
int nEmurates = enumerate.GetCount();
if (suggestedMax > 0)
{
for (int idx = 0; idx < nEmurates; idx++)
{
MinecraftVersion versionItem = enumerate.GetVerison(idx);
if ((firstIndex == -1) && (versionItem >= minVersion))
{
count = 1;
firstIndex = idx;
lastIndex = idx;
prevLastVersion = versionItem;
}
else if ((firstIndex >= 0) && (versionItem < maxVersion))
{
count++;
lastIndex = idx;
//all version must be collected at the same time, even if that over goes the suggested max
if ((count > suggestedMax) && (prevLastVersion != versionItem))
{
lastUsedVersion = versionItem.GetNextTick();
lastIndex--;
count--;
break;
}
}
}
}
nItems = (lastIndex - firstIndex) + 1;
nItemsLeft = nEmurates - (lastIndex + 1);
}
public async Task <GenericResponse> Update(long playerAgentID, BlockMetaData blockData)
{
var blocks = await this.StateManager.GetStateAsync <Dictionary <Position, BlockMetaData> >("blocks");
blockData.version = MinecraftVersion.GetNext();
if (blocks.ContainsKey(blockData.position))
{
blocks[blockData.position] = blockData;
}
else
{
blocks.Add(blockData.position, blockData);
}
await this.StateManager.SetStateAsync("blocks", blocks);
return(new GenericResponse());
}
public async Task <GenericResponse> Update(ActorId playerAgentID, PlayerMetaData playerData)
{
var player = await this.StateManager.GetStateAsync <Dictionary <ActorId, PlayerMetaData> >(_playerTag);
playerData.version = MinecraftVersion.GetNext();
if (player.ContainsKey(playerAgentID))
{
player[playerAgentID] = playerData;
}
else
{
player.Add(playerAgentID, playerData);
}
await this.StateManager.SetStateAsync(_playerTag, player);
return(new GenericResponse());
}
public void Reset()
{
this.version = MinecraftVersion.Unknown;
this.Mods.Clear();
}
public void Initialize(MinecraftVersion version)
{
this.version = version;
this.Refresh();
}
