600 lines
24 KiB
Java
600 lines
24 KiB
Java
package com.mojang.realmsclient.util;
|
|
|
|
import com.mojang.realmsclient.dto.WorldDownload;
|
|
import com.mojang.realmsclient.gui.screens.RealmsDownloadLatestWorldScreen;
|
|
import com.mojang.realmsclient.dto.Backup;
|
|
import java.io.UnsupportedEncodingException;
|
|
import net.minecraft.realms.RealmsConnect;
|
|
import com.mojang.realmsclient.dto.RealmsServerAddress;
|
|
import com.mojang.realmsclient.gui.screens.RealmsLongRunningMcoTaskScreen;
|
|
import com.mojang.realmsclient.gui.screens.RealmsLongConfirmationScreen;
|
|
import com.mojang.realmsclient.gui.screens.RealmsResourcePackScreen;
|
|
import com.mojang.realmsclient.gui.screens.RealmsGenericErrorScreen;
|
|
import com.mojang.realmsclient.gui.screens.RealmsBrokenWorldScreen;
|
|
import com.mojang.realmsclient.gui.screens.RealmsTermsScreen;
|
|
import java.io.IOException;
|
|
import com.mojang.realmsclient.exception.RealmsServiceException;
|
|
import java.util.concurrent.locks.ReentrantLock;
|
|
import com.mojang.realmsclient.dto.WorldTemplate;
|
|
import net.minecraft.realms.RealmsConfirmResultListener;
|
|
import com.mojang.realmsclient.exception.RetryCallException;
|
|
import net.minecraft.realms.Realms;
|
|
import com.mojang.realmsclient.RealmsMainScreen;
|
|
import com.mojang.realmsclient.gui.screens.RealmsConfigureWorldScreen;
|
|
import com.mojang.realmsclient.client.RealmsClient;
|
|
import net.minecraft.realms.RealmsScreen;
|
|
import com.mojang.realmsclient.dto.RealmsServer;
|
|
import com.mojang.realmsclient.gui.LongRunningTask;
|
|
import org.apache.logging.log4j.LogManager;
|
|
import org.apache.logging.log4j.Logger;
|
|
|
|
public class RealmsTasks {
|
|
private static final Logger LOGGER;
|
|
|
|
private static void pause(final int integer) {
|
|
try {
|
|
Thread.sleep(integer * 1000);
|
|
}
|
|
catch (InterruptedException interruptedException2) {
|
|
RealmsTasks.LOGGER.error("", (Throwable)interruptedException2);
|
|
}
|
|
}
|
|
|
|
static {
|
|
LOGGER = LogManager.getLogger();
|
|
}
|
|
|
|
public static class OpenServerTask extends LongRunningTask {
|
|
private final RealmsServer serverData;
|
|
private final RealmsScreen returnScreen;
|
|
private final boolean join;
|
|
private final RealmsScreen mainScreen;
|
|
|
|
public OpenServerTask(final RealmsServer realmsServer, final RealmsScreen realmsScreen2, final RealmsScreen realmsScreen3, final boolean boolean4) {
|
|
this.serverData = realmsServer;
|
|
this.returnScreen = realmsScreen2;
|
|
this.join = boolean4;
|
|
this.mainScreen = realmsScreen3;
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
this.setTitle(RealmsScreen.getLocalizedString("mco.configure.world.opening"));
|
|
final RealmsClient cyy2 = RealmsClient.createRealmsClient();
|
|
for (int integer3 = 0; integer3 < 25; ++integer3) {
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
try {
|
|
final boolean boolean4 = cyy2.open(this.serverData.id);
|
|
if (boolean4) {
|
|
if (this.returnScreen instanceof RealmsConfigureWorldScreen) {
|
|
((RealmsConfigureWorldScreen)this.returnScreen).stateChanged();
|
|
}
|
|
this.serverData.state = RealmsServer.State.OPEN;
|
|
if (this.join) {
|
|
((RealmsMainScreen)this.mainScreen).play(this.serverData, this.returnScreen);
|
|
break;
|
|
}
|
|
Realms.setScreen(this.returnScreen);
|
|
break;
|
|
}
|
|
}
|
|
catch (RetryCallException czh4) {
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
pause(czh4.delaySeconds);
|
|
}
|
|
catch (Exception exception4) {
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
RealmsTasks.LOGGER.error("Failed to open server", (Throwable)exception4);
|
|
this.error("Failed to open the server");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static class CloseServerTask extends LongRunningTask {
|
|
private final RealmsServer serverData;
|
|
private final RealmsConfigureWorldScreen configureScreen;
|
|
|
|
public CloseServerTask(final RealmsServer realmsServer, final RealmsConfigureWorldScreen czs) {
|
|
this.serverData = realmsServer;
|
|
this.configureScreen = czs;
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
this.setTitle(RealmsScreen.getLocalizedString("mco.configure.world.closing"));
|
|
final RealmsClient cyy2 = RealmsClient.createRealmsClient();
|
|
for (int integer3 = 0; integer3 < 25; ++integer3) {
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
try {
|
|
final boolean boolean4 = cyy2.close(this.serverData.id);
|
|
if (boolean4) {
|
|
this.configureScreen.stateChanged();
|
|
this.serverData.state = RealmsServer.State.CLOSED;
|
|
Realms.setScreen(this.configureScreen);
|
|
break;
|
|
}
|
|
}
|
|
catch (RetryCallException czh4) {
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
pause(czh4.delaySeconds);
|
|
}
|
|
catch (Exception exception4) {
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
RealmsTasks.LOGGER.error("Failed to close server", (Throwable)exception4);
|
|
this.error("Failed to close the server");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static class SwitchSlotTask extends LongRunningTask {
|
|
private final long worldId;
|
|
private final int slot;
|
|
private final RealmsConfirmResultListener listener;
|
|
private final int confirmId;
|
|
|
|
public SwitchSlotTask(final long long1, final int integer2, final RealmsConfirmResultListener realmsConfirmResultListener, final int integer4) {
|
|
this.worldId = long1;
|
|
this.slot = integer2;
|
|
this.listener = realmsConfirmResultListener;
|
|
this.confirmId = integer4;
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
final RealmsClient cyy2 = RealmsClient.createRealmsClient();
|
|
final String string3 = RealmsScreen.getLocalizedString("mco.minigame.world.slot.screen.title");
|
|
this.setTitle(string3);
|
|
for (int integer4 = 0; integer4 < 25; ++integer4) {
|
|
try {
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
if (cyy2.switchSlot(this.worldId, this.slot)) {
|
|
this.listener.confirmResult(true, this.confirmId);
|
|
break;
|
|
}
|
|
}
|
|
catch (RetryCallException czh5) {
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
pause(czh5.delaySeconds);
|
|
}
|
|
catch (Exception exception5) {
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
RealmsTasks.LOGGER.error("Couldn't switch world!");
|
|
this.error(exception5.toString());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static class SwitchMinigameTask extends LongRunningTask {
|
|
private final long worldId;
|
|
private final WorldTemplate worldTemplate;
|
|
private final RealmsConfigureWorldScreen lastScreen;
|
|
|
|
public SwitchMinigameTask(final long long1, final WorldTemplate worldTemplate, final RealmsConfigureWorldScreen czs) {
|
|
this.worldId = long1;
|
|
this.worldTemplate = worldTemplate;
|
|
this.lastScreen = czs;
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
final RealmsClient cyy2 = RealmsClient.createRealmsClient();
|
|
final String string3 = RealmsScreen.getLocalizedString("mco.minigame.world.starting.screen.title");
|
|
this.setTitle(string3);
|
|
for (int integer4 = 0; integer4 < 25; ++integer4) {
|
|
try {
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
if (cyy2.putIntoMinigameMode(this.worldId, this.worldTemplate.id)) {
|
|
Realms.setScreen(this.lastScreen);
|
|
break;
|
|
}
|
|
}
|
|
catch (RetryCallException czh5) {
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
pause(czh5.delaySeconds);
|
|
}
|
|
catch (Exception exception5) {
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
RealmsTasks.LOGGER.error("Couldn't start mini game!");
|
|
this.error(exception5.toString());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static class ResettingWorldTask extends LongRunningTask {
|
|
private final String seed;
|
|
private final WorldTemplate worldTemplate;
|
|
private final int levelType;
|
|
private final boolean generateStructures;
|
|
private final long serverId;
|
|
private final RealmsScreen lastScreen;
|
|
private int confirmationId;
|
|
private String title;
|
|
|
|
public ResettingWorldTask(final long long1, final RealmsScreen realmsScreen, final WorldTemplate worldTemplate) {
|
|
this.confirmationId = -1;
|
|
this.title = RealmsScreen.getLocalizedString("mco.reset.world.resetting.screen.title");
|
|
this.seed = null;
|
|
this.worldTemplate = worldTemplate;
|
|
this.levelType = -1;
|
|
this.generateStructures = true;
|
|
this.serverId = long1;
|
|
this.lastScreen = realmsScreen;
|
|
}
|
|
|
|
public ResettingWorldTask(final long long1, final RealmsScreen realmsScreen, final String string, final int integer, final boolean boolean5) {
|
|
this.confirmationId = -1;
|
|
this.title = RealmsScreen.getLocalizedString("mco.reset.world.resetting.screen.title");
|
|
this.seed = string;
|
|
this.worldTemplate = null;
|
|
this.levelType = integer;
|
|
this.generateStructures = boolean5;
|
|
this.serverId = long1;
|
|
this.lastScreen = realmsScreen;
|
|
}
|
|
|
|
public void setConfirmationId(final int integer) {
|
|
this.confirmationId = integer;
|
|
}
|
|
|
|
public void setResetTitle(final String string) {
|
|
this.title = string;
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
final RealmsClient cyy2 = RealmsClient.createRealmsClient();
|
|
this.setTitle(this.title);
|
|
for (int integer3 = 0; integer3 < 25; ++integer3) {
|
|
try {
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
if (this.worldTemplate != null) {
|
|
cyy2.resetWorldWithTemplate(this.serverId, this.worldTemplate.id);
|
|
}
|
|
else {
|
|
cyy2.resetWorldWithSeed(this.serverId, this.seed, this.levelType, this.generateStructures);
|
|
}
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
if (this.confirmationId == -1) {
|
|
Realms.setScreen(this.lastScreen);
|
|
}
|
|
else {
|
|
this.lastScreen.confirmResult(true, this.confirmationId);
|
|
}
|
|
return;
|
|
}
|
|
catch (RetryCallException czh4) {
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
pause(czh4.delaySeconds);
|
|
}
|
|
catch (Exception exception4) {
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
RealmsTasks.LOGGER.error("Couldn't reset world");
|
|
this.error(exception4.toString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static class RealmsGetServerDetailsTask extends LongRunningTask {
|
|
private final RealmsServer server;
|
|
private final RealmsScreen lastScreen;
|
|
private final RealmsMainScreen mainScreen;
|
|
private final ReentrantLock connectLock;
|
|
|
|
public RealmsGetServerDetailsTask(final RealmsMainScreen cyu, final RealmsScreen realmsScreen, final RealmsServer realmsServer, final ReentrantLock reentrantLock) {
|
|
this.lastScreen = realmsScreen;
|
|
this.mainScreen = cyu;
|
|
this.server = realmsServer;
|
|
this.connectLock = reentrantLock;
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
this.setTitle(RealmsScreen.getLocalizedString("mco.connect.connecting"));
|
|
final RealmsClient cyy2 = RealmsClient.createRealmsClient();
|
|
boolean boolean3 = false;
|
|
boolean boolean4 = false;
|
|
int integer5 = 5;
|
|
RealmsServerAddress realmsServerAddress6 = null;
|
|
boolean boolean5 = false;
|
|
boolean boolean6 = false;
|
|
for (int integer6 = 0; integer6 < 40; ++integer6) {
|
|
if (this.aborted()) {
|
|
break;
|
|
}
|
|
try {
|
|
realmsServerAddress6 = cyy2.join(this.server.id);
|
|
boolean3 = true;
|
|
}
|
|
catch (RetryCallException czh10) {
|
|
integer5 = czh10.delaySeconds;
|
|
}
|
|
catch (RealmsServiceException czg10) {
|
|
if (czg10.errorCode == 6002) {
|
|
boolean5 = true;
|
|
break;
|
|
}
|
|
if (czg10.errorCode == 6006) {
|
|
boolean6 = true;
|
|
break;
|
|
}
|
|
boolean4 = true;
|
|
this.error(czg10.toString());
|
|
RealmsTasks.LOGGER.error("Couldn't connect to world", (Throwable)czg10);
|
|
break;
|
|
}
|
|
catch (IOException iOException10) {
|
|
RealmsTasks.LOGGER.error("Couldn't parse response connecting to world", (Throwable)iOException10);
|
|
}
|
|
catch (Exception exception10) {
|
|
boolean4 = true;
|
|
RealmsTasks.LOGGER.error("Couldn't connect to world", (Throwable)exception10);
|
|
this.error(exception10.getLocalizedMessage());
|
|
break;
|
|
}
|
|
if (boolean3) {
|
|
break;
|
|
}
|
|
this.sleep(integer5);
|
|
}
|
|
if (boolean5) {
|
|
Realms.setScreen(new RealmsTermsScreen(this.lastScreen, this.mainScreen, this.server));
|
|
}
|
|
else if (boolean6) {
|
|
if (this.server.ownerUUID.equals(Realms.getUUID())) {
|
|
final RealmsBrokenWorldScreen czq9 = new RealmsBrokenWorldScreen(this.lastScreen, this.mainScreen, this.server.id);
|
|
if (this.server.worldType.equals(RealmsServer.WorldType.MINIGAME)) {
|
|
czq9.setTitle(RealmsScreen.getLocalizedString("mco.brokenworld.minigame.title"));
|
|
}
|
|
Realms.setScreen(czq9);
|
|
}
|
|
else {
|
|
Realms.setScreen(new RealmsGenericErrorScreen(RealmsScreen.getLocalizedString("mco.brokenworld.nonowner.title"), RealmsScreen.getLocalizedString("mco.brokenworld.nonowner.error"), this.lastScreen));
|
|
}
|
|
}
|
|
else if (!this.aborted() && !boolean4) {
|
|
if (boolean3) {
|
|
if (realmsServerAddress6.resourcePackUrl != null && realmsServerAddress6.resourcePackHash != null) {
|
|
final String string9 = RealmsScreen.getLocalizedString("mco.configure.world.resourcepack.question.line1");
|
|
final String string10 = RealmsScreen.getLocalizedString("mco.configure.world.resourcepack.question.line2");
|
|
Realms.setScreen(new RealmsLongConfirmationScreen(new RealmsResourcePackScreen(this.lastScreen, realmsServerAddress6, this.connectLock), RealmsLongConfirmationScreen.Type.Info, string9, string10, true, 100));
|
|
}
|
|
else {
|
|
final RealmsLongRunningMcoTaskScreen czz9 = new RealmsLongRunningMcoTaskScreen(this.lastScreen, new RealmsConnectTask(this.lastScreen, realmsServerAddress6));
|
|
czz9.start();
|
|
Realms.setScreen(czz9);
|
|
}
|
|
}
|
|
else {
|
|
this.error(RealmsScreen.getLocalizedString("mco.errorMessage.connectionFailure"));
|
|
}
|
|
}
|
|
}
|
|
|
|
private void sleep(final int integer) {
|
|
try {
|
|
Thread.sleep(integer * 1000);
|
|
}
|
|
catch (InterruptedException interruptedException3) {
|
|
RealmsTasks.LOGGER.warn(interruptedException3.getLocalizedMessage());
|
|
}
|
|
}
|
|
}
|
|
|
|
public static class RealmsConnectTask extends LongRunningTask {
|
|
private final RealmsConnect realmsConnect;
|
|
private final RealmsServerAddress a;
|
|
|
|
public RealmsConnectTask(final RealmsScreen realmsScreen, final RealmsServerAddress realmsServerAddress) {
|
|
this.a = realmsServerAddress;
|
|
this.realmsConnect = new RealmsConnect(realmsScreen);
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
this.setTitle(RealmsScreen.getLocalizedString("mco.connect.connecting"));
|
|
final net.minecraft.realms.RealmsServerAddress realmsServerAddress2 = net.minecraft.realms.RealmsServerAddress.parseString(this.a.address);
|
|
this.realmsConnect.connect(realmsServerAddress2.getHost(), realmsServerAddress2.getPort());
|
|
}
|
|
|
|
@Override
|
|
public void abortTask() {
|
|
this.realmsConnect.abort();
|
|
Realms.clearResourcePack();
|
|
}
|
|
|
|
@Override
|
|
public void tick() {
|
|
this.realmsConnect.tick();
|
|
}
|
|
}
|
|
|
|
public static class WorldCreationTask extends LongRunningTask {
|
|
private final String name;
|
|
private final String motd;
|
|
private final long worldId;
|
|
private final RealmsScreen lastScreen;
|
|
|
|
public WorldCreationTask(final long long1, final String string2, final String string3, final RealmsScreen realmsScreen) {
|
|
this.worldId = long1;
|
|
this.name = string2;
|
|
this.motd = string3;
|
|
this.lastScreen = realmsScreen;
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
final String string2 = RealmsScreen.getLocalizedString("mco.create.world.wait");
|
|
this.setTitle(string2);
|
|
final RealmsClient cyy3 = RealmsClient.createRealmsClient();
|
|
try {
|
|
cyy3.initializeWorld(this.worldId, this.name, this.motd);
|
|
Realms.setScreen(this.lastScreen);
|
|
}
|
|
catch (RealmsServiceException czg4) {
|
|
RealmsTasks.LOGGER.error("Couldn't create world");
|
|
this.error(czg4.toString());
|
|
}
|
|
catch (UnsupportedEncodingException unsupportedEncodingException4) {
|
|
RealmsTasks.LOGGER.error("Couldn't create world");
|
|
this.error(unsupportedEncodingException4.getLocalizedMessage());
|
|
}
|
|
catch (IOException iOException4) {
|
|
RealmsTasks.LOGGER.error("Could not parse response creating world");
|
|
this.error(iOException4.getLocalizedMessage());
|
|
}
|
|
catch (Exception exception4) {
|
|
RealmsTasks.LOGGER.error("Could not create world");
|
|
this.error(exception4.getLocalizedMessage());
|
|
}
|
|
}
|
|
}
|
|
|
|
public static class RestoreTask extends LongRunningTask {
|
|
private final Backup backup;
|
|
private final long worldId;
|
|
private final RealmsConfigureWorldScreen lastScreen;
|
|
|
|
public RestoreTask(final Backup backup, final long long2, final RealmsConfigureWorldScreen czs) {
|
|
this.backup = backup;
|
|
this.worldId = long2;
|
|
this.lastScreen = czs;
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
this.setTitle(RealmsScreen.getLocalizedString("mco.backup.restoring"));
|
|
final RealmsClient cyy2 = RealmsClient.createRealmsClient();
|
|
for (int integer3 = 0; integer3 < 25; ++integer3) {
|
|
try {
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
cyy2.restoreWorld(this.worldId, this.backup.backupId);
|
|
pause(1);
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
Realms.setScreen(this.lastScreen.getNewScreen());
|
|
return;
|
|
}
|
|
catch (RetryCallException czh4) {
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
pause(czh4.delaySeconds);
|
|
}
|
|
catch (RealmsServiceException czg4) {
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
RealmsTasks.LOGGER.error("Couldn't restore backup", (Throwable)czg4);
|
|
Realms.setScreen(new RealmsGenericErrorScreen(czg4, this.lastScreen));
|
|
return;
|
|
}
|
|
catch (Exception exception4) {
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
RealmsTasks.LOGGER.error("Couldn't restore backup", (Throwable)exception4);
|
|
this.error(exception4.getLocalizedMessage());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static class DownloadTask extends LongRunningTask {
|
|
private final long worldId;
|
|
private final int slot;
|
|
private final RealmsScreen lastScreen;
|
|
private final String downloadName;
|
|
|
|
public DownloadTask(final long long1, final int integer, final String string, final RealmsScreen realmsScreen) {
|
|
this.worldId = long1;
|
|
this.slot = integer;
|
|
this.lastScreen = realmsScreen;
|
|
this.downloadName = string;
|
|
}
|
|
|
|
@Override
|
|
public void run() {
|
|
this.setTitle(RealmsScreen.getLocalizedString("mco.download.preparing"));
|
|
final RealmsClient cyy2 = RealmsClient.createRealmsClient();
|
|
for (int integer3 = 0; integer3 < 25; ++integer3) {
|
|
try {
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
final WorldDownload worldDownload4 = cyy2.download(this.worldId, this.slot);
|
|
pause(1);
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
Realms.setScreen(new RealmsDownloadLatestWorldScreen(this.lastScreen, worldDownload4, this.downloadName));
|
|
return;
|
|
}
|
|
catch (RetryCallException czh4) {
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
pause(czh4.delaySeconds);
|
|
}
|
|
catch (RealmsServiceException czg4) {
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
RealmsTasks.LOGGER.error("Couldn't download world data");
|
|
Realms.setScreen(new RealmsGenericErrorScreen(czg4, this.lastScreen));
|
|
return;
|
|
}
|
|
catch (Exception exception4) {
|
|
if (this.aborted()) {
|
|
return;
|
|
}
|
|
RealmsTasks.LOGGER.error("Couldn't download world data", (Throwable)exception4);
|
|
this.error(exception4.getLocalizedMessage());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|