public BattleGui()
{
- timeRemaining = new AtomicInteger((int)TurnBasedMinecraftMod.BattleDecisionTime.getSeconds());
+ timeRemaining = new AtomicInteger(TurnBasedMinecraftMod.getBattleDurationSeconds());
lastInstant = System.nanoTime();
elapsedTime = 0;
state = MenuState.MAIN_MENU;
{
TurnBasedMinecraftMod.currentBattle.setState(Battle.State.DECISION);
}
- timeRemaining.set((int)TurnBasedMinecraftMod.BattleDecisionTime.getSeconds());
+ timeRemaining.set(TurnBasedMinecraftMod.getBattleDurationSeconds());
elapsedTime = 0;
lastInstant = System.nanoTime();
setState(MenuState.MAIN_MENU);
try {
sequencer = MidiSystem.getSequencer();
sequencer.open();
- } catch (Exception e)
+ } catch (Throwable t)
{
logger.error("Failed to load midi sequencer");
return;
}
try {
sequencer.setSequence(new BufferedInputStream(new FileInputStream(next)));
- } catch (Exception e)
+ } catch (Throwable t)
{
logger.error("Failed to play battle music (midi)");
return;
try
{
clip.open(AudioSystem.getAudioInputStream(next));
- } catch(Exception e)
+ } catch(Throwable t)
{
logger.error("Failed to load battle music (wav)");
return;
for(Entity e : sideA)
{
EntityInfo entityInfo = TurnBasedMinecraftMod.config.getMatchingEntityInfo(e);
- if(entityInfo == null && !(e instanceof EntityPlayer) && TurnBasedMinecraftMod.battleManager != null)
+ if(entityInfo == null && !(e instanceof EntityPlayer) && TurnBasedMinecraftMod.commonProxy.isServerRunning())
{
continue;
}
for(Entity e : sideB)
{
EntityInfo entityInfo = TurnBasedMinecraftMod.config.getMatchingEntityInfo(e);
- if(entityInfo == null && !(e instanceof EntityPlayer) && TurnBasedMinecraftMod.battleManager != null)
+ if(entityInfo == null && !(e instanceof EntityPlayer) && TurnBasedMinecraftMod.commonProxy.isServerRunning())
{
continue;
}
lastInstant = System.nanoTime();
state = State.DECISION;
undecidedCount.set(playerCount.get());
- timer = TurnBasedMinecraftMod.BattleDecisionTime.getSeconds() * 1000000000;
+ timer = TurnBasedMinecraftMod.getBattleDurationNanos();
battleEnded = false;
notifyPlayersBattleInfo();
public void addCombatantToSideA(Entity e)
{
EntityInfo entityInfo = TurnBasedMinecraftMod.config.getMatchingEntityInfo(e);
- if(entityInfo == null && !(e instanceof EntityPlayer) && TurnBasedMinecraftMod.battleManager != null)
+ if(entityInfo == null && !(e instanceof EntityPlayer) && TurnBasedMinecraftMod.commonProxy.isServerRunning())
{
return;
}
public void addCombatantToSideB(Entity e)
{
EntityInfo entityInfo = TurnBasedMinecraftMod.config.getMatchingEntityInfo(e);
- if(entityInfo == null && !(e instanceof EntityPlayer) && TurnBasedMinecraftMod.battleManager != null)
+ if(entityInfo == null && !(e instanceof EntityPlayer) && TurnBasedMinecraftMod.commonProxy.isServerRunning())
{
return;
}
}
}
state = State.ACTION;
- timer = TurnBasedMinecraftMod.BattleDecisionTime.getSeconds() * 1000000000;
+ timer = TurnBasedMinecraftMod.getBattleDurationNanos();
sendMessageToAllPlayers(PacketBattleMessage.MessageType.TURN_BEGIN, 0, 0, 0);
turnOrderQueue.clear();
for(Combatant c : sideA.values())
{
manager.battleMap.remove(ended);
}
- try { Thread.sleep(250); } catch (Exception e) { /* ignored */ }
+ try { Thread.sleep(250); } catch (Throwable t) { /* ignored */ }
}
}
{
return FMLCommonHandler.instance().getMinecraftServerInstance().getEntityWorld().getEntityByID(id);
}
+
+ public boolean isServerRunning()
+ {
+ return TurnBasedMinecraftMod.battleManager != null;
+ }
}
{
logger.error("Internal resource is null");
}
- internalVersion = getConfigFileVersion(is);
- } catch (Exception e) {}
+ else
+ {
+ internalVersion = getConfigFileVersion(is);
+ }
+ } catch (Throwable t) {}
if(internalVersion == 0)
{
writeConfig();
}
}
- catch (Exception e)
+ catch (Throwable t)
{
logger.error("Failed to check/create-new config file");
}
try
{
writeConfig();
- } catch (Exception e)
+ } catch (Throwable t)
{
logger.error("Failed to write config file!");
}
try
{
parseConfig(configFile);
- } catch (Exception e)
+ } catch (Throwable t)
{
logger.error("Failed to parse config file!");
}
minimumHitPercentage = 1;
}
}
+ else if(xmlReader.getLocalName().equals("BattleTurnTimeSeconds"))
+ {
+ int seconds = TurnBasedMinecraftMod.getBattleDurationSeconds();
+ try
+ {
+ seconds = Integer.parseInt(xmlReader.getElementText());
+ TurnBasedMinecraftMod.setBattleDurationSeconds(seconds);
+ } catch (Throwable t)
+ {
+ logger.warn("Unable to get value for \"BattleTurnTimeSeconds\" from config, using default");
+ TurnBasedMinecraftMod.setBattleDurationSeconds(TurnBasedMinecraftMod.BATTLE_DECISION_DURATION_NANO_DEFAULT / 1000000000L);
+ }
+ }
else if(xmlReader.getLocalName().equals("EntityEntry"))
{
EntityInfo eInfo = new EntityInfo();
}
}
xmlReader.close();
- } catch (Exception e)
+ } catch (Throwable t)
{
return 0;
}
package com.seodisparate.TurnBasedMinecraft.common;
-import java.time.Duration;
import java.util.HashSet;
import java.util.Set;
public static final String MODID = "com.seodisparate.turnbasedminecraft";
public static final String NAME = "Turn Based Minecraft Mod";
public static final String VERSION = "0.3";
- public static final Duration BattleDecisionTime = Duration.ofSeconds(15);
public static final String CONFIG_FILENAME = "TBM_Config.xml";
public static final String CONFIG_DIRECTORY = "config/TurnBasedMinecraft/";
public static final String CONFIG_FILE_PATH = CONFIG_DIRECTORY + CONFIG_FILENAME;
protected static int attackingDamage = 0;
protected static Set<AttackerViaBow> attackerViaBow;
protected static Config config;
+ public static final long BATTLE_DECISION_DURATION_NANO_MIN = 5000000000L;
+ public static final long BATTLE_DECISION_DURATION_NANO_MAX = 60000000000L;
+ public static final long BATTLE_DECISION_DURATION_NANO_DEFAULT = 15000000000L;
+ private static long BATTLE_DECISION_DURATION_NANOSECONDS = BATTLE_DECISION_DURATION_NANO_DEFAULT;
public static Battle currentBattle = null;
{
return CONFIG_FILE_VERSION;
}
+
+ public static long getBattleDurationNanos()
+ {
+ return BATTLE_DECISION_DURATION_NANOSECONDS;
+ }
+
+ public static int getBattleDurationSeconds()
+ {
+ return (int)(BATTLE_DECISION_DURATION_NANOSECONDS / 1000000000L);
+ }
+
+ protected static void setBattleDurationSeconds(long seconds)
+ {
+ BATTLE_DECISION_DURATION_NANOSECONDS = seconds * 1000000000L;
+ if(BATTLE_DECISION_DURATION_NANOSECONDS < BATTLE_DECISION_DURATION_NANO_MIN)
+ {
+ BATTLE_DECISION_DURATION_NANOSECONDS = BATTLE_DECISION_DURATION_NANO_MIN;
+ }
+ else if(BATTLE_DECISION_DURATION_NANOSECONDS > BATTLE_DECISION_DURATION_NANO_MAX)
+ {
+ BATTLE_DECISION_DURATION_NANOSECONDS = BATTLE_DECISION_DURATION_NANO_MAX;
+ }
+ }
}
{
sideA = new ArrayList<Integer>();
sideB = new ArrayList<Integer>();
- decisionNanos = TurnBasedMinecraftMod.BattleDecisionTime.getSeconds() * 1000000000;
+ decisionNanos = TurnBasedMinecraftMod.getBattleDurationNanos();
}
public PacketBattleInfo(Collection<Integer> sideA, Collection<Integer> sideB, long decisionNanos)
{
TurnBasedMinecraftMod.currentBattle.addCombatantToSideB(Minecraft.getMinecraft().world.getEntityByID(id));
}
- TurnBasedMinecraftMod.commonProxy.setBattleGuiTime((int)(message.decisionNanos / 1000000000));
+ TurnBasedMinecraftMod.commonProxy.setBattleGuiTime((int)(message.decisionNanos / 1000000000L));
TurnBasedMinecraftMod.commonProxy.setBattleGuiBattleChanged();
return null;
}
<FleeBadProbability>40</FleeBadProbability>
<!-- Minimum hit percentage for every entity. If less than 1, it will be stored as 1 anyways. -->
<MinimumHitPercentage>4</MinimumHitPercentage>
+ <!-- Number of seconds to wait in battle for all players to make a decision. Minimum of 5 and maximum of 60. -->
+ <BattleTurnTimeSeconds>15</BattleTurnTimeSeconds>
<!-- Battle stats for entities should be specified here. If an entity is not listed it cannot enter battle. -->
<!-- Name: The full class name of an entity. -->