https://pastein.ru/t/x1W
Загрузка данных
package zombie.iso;
import fmod.fmod.FMODSoundEmitter;
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;
import java.util.logging.Level;
import java.util.logging.Logger;
import se.krka.kahlua.vm.KahluaTable;
import zombie.CollisionManager;
import zombie.FliesSound;
import zombie.GameProfiler;
import zombie.GameTime;
import zombie.GameWindow;
import zombie.IndieGL;
import zombie.MapCollisionData;
import zombie.MovingObjectUpdateScheduler;
import zombie.PersistentOutfits;
import zombie.ReanimatedPlayers;
import zombie.SandboxOptions;
import zombie.SharedDescriptors;
import zombie.SoundManager;
import zombie.SystemDisabler;
import zombie.UsedFromLua;
import zombie.VirtualZombieManager;
import zombie.WorldSoundManager;
import zombie.ZomboidFileSystem;
import zombie.ZomboidGlobals;
import zombie.Lua.LuaEventManager;
import zombie.Lua.LuaManager;
import zombie.Lua.LuaManager.GlobalObject;
import zombie.ai.ZombieGroupManager;
import zombie.ai.states.FakeDeadZombieState;
import zombie.audio.BaseSoundEmitter;
import zombie.audio.DummySoundEmitter;
import zombie.audio.ObjectAmbientEmitters;
import zombie.audio.parameters.ParameterInside;
import zombie.basements.Basements;
import zombie.buildingRooms.BuildingRoomsEditor;
import zombie.characters.AnimalVocalsManager;
import zombie.characters.HaloTextHelper;
import zombie.characters.IsoGameCharacter;
import zombie.characters.IsoPlayer;
import zombie.characters.IsoSurvivor;
import zombie.characters.IsoZombie;
import zombie.characters.SurvivorDesc;
import zombie.characters.ZombieVocalsManager;
import zombie.characters.animals.AnimalDefinitions;
import zombie.characters.animals.AnimalPopulationManager;
import zombie.characters.animals.AnimalTracksDefinitions;
import zombie.characters.animals.AnimalZones;
import zombie.characters.animals.IsoAnimal;
import zombie.characters.professions.CharacterProfessionDefinition;
import zombie.characters.traits.CharacterTraitDefinition;
import zombie.core.Core;
import zombie.core.ImportantAreaManager;
import zombie.core.PZForkJoinPool;
import zombie.core.PerformanceSettings;
import zombie.core.SceneShaderStore;
import zombie.core.SpriteRenderer;
import zombie.core.TilePropertyAliasMap;
import zombie.core.Translator;
import zombie.core.logger.ExceptionLogger;
import zombie.core.math.PZMath;
import zombie.core.physics.WorldSimulation;
import zombie.core.profiling.AbstractPerformanceProfileProbe;
import zombie.core.profiling.PerformanceProfileProbe;
import zombie.core.properties.FasciaEdge;
import zombie.core.properties.IsoPropertyType;
import zombie.core.properties.PropertyContainer;
import zombie.core.random.Rand;
import zombie.core.skinnedmodel.DeadBodyAtlas;
import zombie.core.skinnedmodel.animation.debug.AnimationPlayerRecorder;
import zombie.core.skinnedmodel.model.WorldItemAtlas;
import zombie.core.stash.StashSystem;
import zombie.core.textures.Texture;
import zombie.core.utils.OnceEvery;
import zombie.debug.DebugOptions;
import zombie.debug.DebugType;
import zombie.debug.LineDrawer;
import zombie.debug.LogSeverity;
import zombie.entity.GameEntityManager;
import zombie.entity.components.spriteconfig.SpriteConfigManager;
import zombie.entity.util.TimSort;
import zombie.erosion.ErosionGlobals;
import zombie.gameStates.GameLoadingState;
import zombie.gizmo.Gizmos;
import zombie.globalObjects.GlobalObjectLookup;
import zombie.input.Mouse;
import zombie.inventory.ItemConfigurator;
import zombie.inventory.ItemPickerJava;
import zombie.inventory.types.MapItem;
import zombie.iso.SpriteDetails.IsoFlagType;
import zombie.iso.SpriteDetails.IsoObjectType;
import zombie.iso.areas.DesignationZone;
import zombie.iso.areas.IsoBuilding;
import zombie.iso.areas.SafeHouse;
import zombie.iso.areas.isoregion.IsoRegions;
import zombie.iso.fboRenderChunk.FBORenderAreaHighlights;
import zombie.iso.objects.IsoFireManager;
import zombie.iso.objects.ObjectRenderEffects;
import zombie.iso.objects.RainManager;
import zombie.iso.sprite.IsoSprite;
import zombie.iso.sprite.IsoSpriteGrid;
import zombie.iso.sprite.IsoSpriteManager;
import zombie.iso.sprite.SkyBox;
import zombie.iso.sprite.SpriteGridParseData;
import zombie.iso.weather.ClimateManager;
import zombie.iso.weather.WorldFlares;
import zombie.iso.weather.fog.ImprovedFog;
import zombie.iso.weather.fx.IsoWeatherFX;
import zombie.iso.weather.fx.WeatherFxMask;
import zombie.iso.worldgen.WorldGenChunk;
import zombie.iso.worldgen.WorldGenParams;
import zombie.iso.worldgen.WorldGenParams.Result;
import zombie.iso.worldgen.attachments.AttachmentsHandler;
import zombie.iso.worldgen.blending.Blending;
import zombie.iso.worldgen.maps.BiomeMap;
import zombie.iso.worldgen.rules.Rules;
import zombie.iso.worldgen.zones.ZoneGenerator;
import zombie.iso.zones.Zone;
import zombie.network.BodyDamageSync;
import zombie.network.ClientServerMap;
import zombie.network.GameClient;
import zombie.network.GameServer;
import zombie.network.NetChecksum;
import zombie.network.PassengerMap;
import zombie.network.ServerMap;
import zombie.network.ServerOptions;
import zombie.network.id.ObjectIDManager;
import zombie.pathfind.PolygonalMap2;
import zombie.pathfind.extra.BorderFinderRenderer;
import zombie.pathfind.nativeCode.PathfindNative;
import zombie.pathfind.nativeCode.PathfindNativeRenderer;
import zombie.popman.ZombiePopulationManager;
import zombie.popman.animal.HutchManager;
import zombie.radio.ZomboidRadio;
import zombie.randomizedWorld.RandomizedWorldBase;
import zombie.randomizedWorld.randomizedBuilding.RBBar;
import zombie.randomizedWorld.randomizedBuilding.RBBarn;
import zombie.randomizedWorld.randomizedBuilding.RBBasic;
import zombie.randomizedWorld.randomizedBuilding.RBBurnt;
import zombie.randomizedWorld.randomizedBuilding.RBBurntCorpse;
import zombie.randomizedWorld.randomizedBuilding.RBBurntFireman;
import zombie.randomizedWorld.randomizedBuilding.RBCafe;
import zombie.randomizedWorld.randomizedBuilding.RBClinic;
import zombie.randomizedWorld.randomizedBuilding.RBDorm;
import zombie.randomizedWorld.randomizedBuilding.RBGunstoreSiege;
import zombie.randomizedWorld.randomizedBuilding.RBHairSalon;
import zombie.randomizedWorld.randomizedBuilding.RBHeatBreakAfternoon;
import zombie.randomizedWorld.randomizedBuilding.RBJackieJaye;
import zombie.randomizedWorld.randomizedBuilding.RBJoanHartford;
import zombie.randomizedWorld.randomizedBuilding.RBKateAndBaldspot;
import zombie.randomizedWorld.randomizedBuilding.RBLooted;
import zombie.randomizedWorld.randomizedBuilding.RBMayorWestPoint;
import zombie.randomizedWorld.randomizedBuilding.RBNolans;
import zombie.randomizedWorld.randomizedBuilding.RBOffice;
import zombie.randomizedWorld.randomizedBuilding.RBOther;
import zombie.randomizedWorld.randomizedBuilding.RBPileOCrepe;
import zombie.randomizedWorld.randomizedBuilding.RBPizzaWhirled;
import zombie.randomizedWorld.randomizedBuilding.RBPoliceSiege;
import zombie.randomizedWorld.randomizedBuilding.RBSWATStation;
import zombie.randomizedWorld.randomizedBuilding.RBSafehouse;
import zombie.randomizedWorld.randomizedBuilding.RBSchool;
import zombie.randomizedWorld.randomizedBuilding.RBShopLooted;
import zombie.randomizedWorld.randomizedBuilding.RBSpiffo;
import zombie.randomizedWorld.randomizedBuilding.RBStripclub;
import zombie.randomizedWorld.randomizedBuilding.RBTrashed;
import zombie.randomizedWorld.randomizedBuilding.RBTwiggy;
import zombie.randomizedWorld.randomizedBuilding.RBWoodcraft;
import zombie.randomizedWorld.randomizedBuilding.RandomizedBuildingBase;
import zombie.randomizedWorld.randomizedVehicleStory.RVSAmbulanceCrash;
import zombie.randomizedWorld.randomizedVehicleStory.RVSAnimalOnRoad;
import zombie.randomizedWorld.randomizedVehicleStory.RVSAnimalTrailerOnRoad;
import zombie.randomizedWorld.randomizedVehicleStory.RVSBanditRoad;
import zombie.randomizedWorld.randomizedVehicleStory.RVSBurntCar;
import zombie.randomizedWorld.randomizedVehicleStory.RVSCarCrash;
import zombie.randomizedWorld.randomizedVehicleStory.RVSCarCrashCorpse;
import zombie.randomizedWorld.randomizedVehicleStory.RVSCarCrashDeer;
import zombie.randomizedWorld.randomizedVehicleStory.RVSChangingTire;
import zombie.randomizedWorld.randomizedVehicleStory.RVSConstructionSite;
import zombie.randomizedWorld.randomizedVehicleStory.RVSCrashHorde;
import zombie.randomizedWorld.randomizedVehicleStory.RVSDeadEnd;
import zombie.randomizedWorld.randomizedVehicleStory.RVSFlippedCrash;
import zombie.randomizedWorld.randomizedVehicleStory.RVSHerdOnRoad;
import zombie.randomizedWorld.randomizedVehicleStory.RVSPlonkies;
import zombie.randomizedWorld.randomizedVehicleStory.RVSPoliceBlockade;
import zombie.randomizedWorld.randomizedVehicleStory.RVSPoliceBlockadeShooting;
import zombie.randomizedWorld.randomizedVehicleStory.RVSRegionalProfessionVehicle;
import zombie.randomizedWorld.randomizedVehicleStory.RVSRichJerk;
import zombie.randomizedWorld.randomizedVehicleStory.RVSRoadKill;
import zombie.randomizedWorld.randomizedVehicleStory.RVSRoadKillSmall;
import zombie.randomizedWorld.randomizedVehicleStory.RVSTrailerCrash;
import zombie.randomizedWorld.randomizedVehicleStory.RVSUtilityVehicle;
import zombie.randomizedWorld.randomizedVehicleStory.RandomizedVehicleStoryBase;
import zombie.randomizedWorld.randomizedZoneStory.RZJackieJaye;
import zombie.randomizedWorld.randomizedZoneStory.RZSAttachedAnimal;
import zombie.randomizedWorld.randomizedZoneStory.RZSBBQParty;
import zombie.randomizedWorld.randomizedZoneStory.RZSBaseball;
import zombie.randomizedWorld.randomizedZoneStory.RZSBeachParty;
import zombie.randomizedWorld.randomizedZoneStory.RZSBurntWreck;
import zombie.randomizedWorld.randomizedZoneStory.RZSBuryingCamp;
import zombie.randomizedWorld.randomizedZoneStory.RZSCampsite;
import zombie.randomizedWorld.randomizedZoneStory.RZSCharcoalBurner;
import zombie.randomizedWorld.randomizedZoneStory.RZSDean;
import zombie.randomizedWorld.randomizedZoneStory.RZSDuke;
import zombie.randomizedWorld.randomizedZoneStory.RZSEscapedAnimal;
import zombie.randomizedWorld.randomizedZoneStory.RZSEscapedHerd;
import zombie.randomizedWorld.randomizedZoneStory.RZSFishingTrip;
import zombie.randomizedWorld.randomizedZoneStory.RZSForestCamp;
import zombie.randomizedWorld.randomizedZoneStory.RZSForestCampEaten;
import zombie.randomizedWorld.randomizedZoneStory.RZSFrankHemingway;
import zombie.randomizedWorld.randomizedZoneStory.RZSHermitCamp;
import zombie.randomizedWorld.randomizedZoneStory.RZSHillbillyHoedown;
import zombie.randomizedWorld.randomizedZoneStory.RZSHogWild;
import zombie.randomizedWorld.randomizedZoneStory.RZSHunterCamp;
import zombie.randomizedWorld.randomizedZoneStory.RZSKirstyKormick;
import zombie.randomizedWorld.randomizedZoneStory.RZSMurderScene;
import zombie.randomizedWorld.randomizedZoneStory.RZSMusicFest;
import zombie.randomizedWorld.randomizedZoneStory.RZSMusicFestStage;
import zombie.randomizedWorld.randomizedZoneStory.RZSNastyMattress;
import zombie.randomizedWorld.randomizedZoneStory.RZSOccultActivity;
import zombie.randomizedWorld.randomizedZoneStory.RZSOldFirepit;
import zombie.randomizedWorld.randomizedZoneStory.RZSOldShelter;
import zombie.randomizedWorld.randomizedZoneStory.RZSOrphanedFawn;
import zombie.randomizedWorld.randomizedZoneStory.RZSRangerSmith;
import zombie.randomizedWorld.randomizedZoneStory.RZSRockerParty;
import zombie.randomizedWorld.randomizedZoneStory.RZSSadCamp;
import zombie.randomizedWorld.randomizedZoneStory.RZSSexyTime;
import zombie.randomizedWorld.randomizedZoneStory.RZSSirTwiggy;
import zombie.randomizedWorld.randomizedZoneStory.RZSSurvivalistCamp;
import zombie.randomizedWorld.randomizedZoneStory.RZSTragicPicnic;
import zombie.randomizedWorld.randomizedZoneStory.RZSTrapperCamp;
import zombie.randomizedWorld.randomizedZoneStory.RZSVanCamp;
import zombie.randomizedWorld.randomizedZoneStory.RZSWasteDump;
import zombie.randomizedWorld.randomizedZoneStory.RZSWaterPump;
import zombie.randomizedWorld.randomizedZoneStory.RandomizedZoneStoryBase;
import zombie.savefile.ClientPlayerDB;
import zombie.savefile.PlayerDB;
import zombie.savefile.PlayerDBHelper;
import zombie.savefile.ServerPlayerDB;
import zombie.scripting.ScriptManager;
import zombie.scripting.objects.CharacterTrait;
import zombie.spriteModel.SpriteModelManager;
import zombie.statistics.StatisticsManager;
import zombie.text.templating.TemplateText;
import zombie.tileDepth.TileDepthTextureManager;
import zombie.tileDepth.TileGeometryManager;
import zombie.ui.TutorialManager;
import zombie.util.AddCoopPlayer;
import zombie.util.SharedStrings;
import zombie.util.StringUtils;
import zombie.util.list.PZArrayList;
import zombie.vehicles.BaseVehicle;
import zombie.vehicles.VehicleIDMap;
import zombie.vehicles.VehicleManager;
import zombie.vehicles.VehiclesDB2;
import zombie.viewCone.ViewConeTextureFBO;
import zombie.world.WorldDictionary;
import zombie.world.WorldDictionaryException;
import zombie.world.moddata.GlobalModData;
import zombie.worldMap.network.HiddenAuthors;
import zombie.worldMap.network.WorldMapClient;
@UsedFromLua
public final class IsoWorld {
private static final int TILESETS_PER_FILE_1 = 1024;
private static final int TILES_PER_TILESET_1 = 1024;
private static final int TILES_PER_FILE_1 = 1048576;
private static final int TILESETS_PER_FILE_OTHER = 512;
private static final int TILES_PER_TILESET_OTHER = 512;
private static final int TILES_PER_FILE_OTHER = 262144;
private static final int NUM_TDEF_FILES_GT_1 = 8188;
public static final int MIN_TDEF_FILE_NUMBER_FOR_MODS = 100;
public static final int MAX_TDEF_FILE_NUMBER_FOR_MODS = 8189;
private static final int TDEF_VERSION1 = 1;
private static final int TDEF_VERSION_LATEST = 1;
private static final byte[] TDEF_FILE_MAGIC = new byte[]{116, 100, 101, 102};
public static final long LUA_CHECKSUM_TIMEOUT_MS;
private String weather = "sunny";
public final IsoMetaGrid metaGrid = new IsoMetaGrid();
private final ArrayList randomizedBuildingList = new ArrayList();
private final ArrayList randomizedZoneList = new ArrayList();
private final ArrayList randomizedVehicleStoryList = new ArrayList();
private final RandomizedBuildingBase rbBasic = new RBBasic();
private final RandomizedWorldBase randomizedWorldBase = new RandomizedWorldBase();
private final HashMap spawnedZombieZone = new HashMap();
private final HashMap allTiles = new HashMap();
private final ArrayList tileImages = new ArrayList();
private float flashIsoCursorA = 1.0F;
private boolean flashIsoCursorInc;
public SkyBox sky;
private int timeSinceLastSurvivorInHorde = 4000;
private int frameNo;
public final Helicopter helicopter = new Helicopter();
private boolean hydroPowerOn;
public final ArrayList characters = new ArrayList();
private final ArrayDeque freeEmitters = new ArrayDeque();
private final ArrayList currentEmitters = new ArrayList();
private final HashMap emitterOwners = new HashMap();
public int x = 50;
public int y = 50;
public IsoCell currentCell;
public static IsoWorld instance;
public int totalSurvivorsDead;
public int totalSurvivorNights;
public int survivorSurvivalRecord;
public HashMap survivorDescriptors = new HashMap();
public ArrayList addCoopPlayers = new ArrayList();
private static final CompScoreToPlayer compScoreToPlayer;
public static String mapPath;
public static boolean mapUseJar;
private final boolean loaded = false;
public static final HashMap PropertyValueMap;
private static final int JUMBO_TRUNK_VARIANT_COUNT = 114;
private static final int FAKE_JUMBO_TREE_TILESET_INDEX = 12;
private static int worldX;
private static int worldY;
private SurvivorDesc luaDesc;
private final List luatraits = new ArrayList();
private int luaPosX = -1;
private int luaPosY = -1;
private int luaPosZ = -1;
private String spawnRegionName = "";
public static final int WorldVersion = 249;
public static final int WorldVersion_PreviouslyMoved = 196;
public static final int WorldVersion_DesignationZone = 197;
public static final int WorldVersion_PlayerExtraInfoFlags = 198;
public static final int WorldVersion_ObjectID = 199;
public static final int WorldVersion_CraftUpdateFoundations = 200;
public static final int WorldVersion_AlarmDecay = 201;
public static final int WorldVersion_FishingCheat = 202;
public static final int WorldVersion_CharacterVoiceType = 203;
public static final int WorldVersion_AnimalHutch = 204;
public static final int WorldVersion_AlarmClock = 205;
public static final int WorldVersion_VariableHeight = 206;
public static final int WorldVersion_EnableWorldgen = 207;
public static final int WorldVersion_CharacterVoiceOptions = 208;
public static final int WorldVersion_ChunksWorldGeneratedBoolean = 209;
public static final int WorldVersion_ChunksWorldModifiedBoolean = 210;
public static final int WorldVersion_CharacterDiscomfort = 211;
public static final int WorldVersion_HutchAndVehicleAnimalFormat = 212;
public static final int WorldVersion_IsoCompostHealthValues = 213;
public static final int WorldVersion_ChunksAttachmentsState = 214;
public static final int WorldVersion_ZoneIDisUUID = 215;
public static final int WorldVersion_SafeHouseHitPoints = 216;
public static final int WorldVersion_FastMoveCheat = 217;
public static final int WorldVersion_SquareSeen = 218;
public static final int WorldVersion_TrapExplosionDuration = 219;
public static final int WorldVersion_InventoryItemUsesInteger = 220;
public static final int WorldVersion_ChunksAttachmentsPartial = 221;
public static final int WorldVersion_PrintMediaRottingCorpsesBodyDamage = 222;
public static final int WorldVersion_SafeHouseCreatedTimeAndLocation = 223;
public static final int WorldVersion_Stats_Idleness = 224;
public static final int WorldVersion_AnimalRottingTexture = 225;
public static final int WorldVersion_LearnedRecipes = 226;
public static final int WorldVersion_BodyDamageSavePoulticeValues = 227;
public static final int WorldVersion_PlayerSaveCraftingHistory = 228;
public static final int WorldVersion_VehicleAlarm = 229;
public static final int WorldVersion_RecipesAndAmmoCheats = 230;
public static final int WorldVersion_SavePlayerCheats = 231;
public static final int WorldVersion_ItemWorldRotationFloats = 232;
public static final int WorldVersion_MetaEntityOutsideAware = 233;
public static final int WorldVersion_VisitedFileVersion = 234;
public static final int WorldVersion_VariableCraftInputCounts = 235;
public static final int WorldVersion_AnimalPetTime = 236;
public static final int WorldVersion_RootLocale = 237;
public static final int WorldVersion_CraftLogicParallelCrafting = 238;
public static final int WorldVersion_PlayerAutoDrink = 239;
public static final int WorldVersion_42_13 = 240;
public static final int WorldVersion_PlayerInsulation = 241;
public static final int WorldVersion_SaveFireTimer = 242;
public static final int WorldVersion_BodyDamageStatusesSync = 243;
public static final int WorldVersion_RemoveDifficulty = 244;
public static final int WorldVersion_AnimalWild = 245;
public static final int WorldVersion_DeadBodyAnimalGenetics = 246;
public static final int WorldVersion_AnimalOnlineId = 247;
public static final int WorldVersion_BuildMaterials = 248;
public static final int WorldVersion_ThermalDuration = 249;
public static int savedWorldVersion;
private boolean drawWorld = true;
private final PZArrayList zombieWithModel = new PZArrayList(IsoZombie.class, 128);
private final PZArrayList zombieWithoutModel = new PZArrayList(IsoZombie.class, 128);
private final TimSort timSort = new TimSort();
private final ArrayList animalWithModel = new ArrayList();
private final ArrayList animalWithoutModel = new ArrayList();
private final Vector2 coneTempo1 = new Vector2();
private final Vector2 coneTempo2 = new Vector2();
private final Vector2 coneTempo3 = new Vector2();
public static boolean noZombies;
public static int totalWorldVersion;
public static int saveoffsetx;
public static int saveoffsety;
public boolean doChunkMapUpdate = true;
private long emitterUpdateMs;
public boolean emitterUpdate;
private int updateSafehousePlayers = 200;
public static CompletableFuture animationThread;
private Rules rules;
private WorldGenChunk wgChunk;
private Blending blending;
private AttachmentsHandler attachmentsHandler;
private ZoneGenerator zoneGenerator;
private BiomeMap biomeMap;
private List zombieVoronois;
public IsoMetaGrid getMetaGrid() {
return this.metaGrid;
}
public Zone registerZone(String name, String type, int x, int y, int z, int width, int height) {
return this.metaGrid.registerZone(name, type, x, y, z, width, height);
}
/** @deprecated */
@Deprecated
public Zone registerZoneNoOverlap(String name, String type, int x, int y, int z, int width, int height) {
return this.registerZone(name, type, x, y, z, width, height);
}
public void removeZonesForLotDirectory(String lotDir) {
this.metaGrid.removeZonesForLotDirectory(lotDir);
}
public BaseSoundEmitter getFreeEmitter() {
Object e;
if (this.freeEmitters.isEmpty()) {
e = Core.soundDisabled ? new DummySoundEmitter() : new FMODSoundEmitter();
} else {
e = (BaseSoundEmitter)this.freeEmitters.pop();
}
((BaseSoundEmitter)e).setPlayRemoteEvents(false);
this.currentEmitters.add(e);
return (BaseSoundEmitter)e;
}
public BaseSoundEmitter getFreeEmitter(float x, float y, float z) {
BaseSoundEmitter e = this.getFreeEmitter();
e.setPos(x, y, z);
return e;
}
public void takeOwnershipOfEmitter(BaseSoundEmitter emitter) {
this.currentEmitters.remove(emitter);
}
public void setEmitterOwner(BaseSoundEmitter emitter, IsoObject object) {
if (emitter != null && object != null) {
if (!this.emitterOwners.containsKey(emitter)) {
this.emitterOwners.put(emitter, object);
}
}
}
public void returnOwnershipOfEmitter(BaseSoundEmitter emitter) {
if (emitter != null) {
if (!this.currentEmitters.contains(emitter) && !this.freeEmitters.contains(emitter)) {
if (emitter.isEmpty()) {
if (emitter instanceof FMODSoundEmitter) {
FMODSoundEmitter fmodSoundEmitter = (FMODSoundEmitter)emitter;
fmodSoundEmitter.clearParameters();
}
this.freeEmitters.add(emitter);
} else {
this.currentEmitters.add(emitter);
}
}
}
}
public Zone registerVehiclesZone(String name, String type, int x, int y, int z, int width, int height, KahluaTable properties) {
return this.metaGrid.registerVehiclesZone(name, type, x, y, z, width, height, properties);
}
public Zone registerMannequinZone(String name, String type, int x, int y, int z, int width, int height, KahluaTable properties) {
return this.metaGrid.registerMannequinZone(name, type, x, y, z, width, height, properties);
}
public void registerRoomTone(String name, String type, int x, int y, int z, int width, int height, KahluaTable properties) {
this.metaGrid.registerRoomTone(name, type, x, y, z, width, height, properties);
}
public void registerSpawnOrigin(int x, int y, int width, int height, KahluaTable properties) {
ZombiePopulationManager.instance.registerSpawnOrigin(x, y, width, height, properties);
}
public void registerWaterFlow(float x, float y, float flow, float speed) {
IsoWaterFlow.addFlow(x, y, flow, speed);
}
public void registerWaterZone(float x1, float y1, float x2, float y2, float shore, float waterGround) {
IsoWaterFlow.addZone(x1, y1, x2, y2, shore, waterGround);
}
public void checkVehiclesZones() {
this.metaGrid.checkVehiclesZones();
}
public void setGameMode(String mode) {
Core.getInstance().setGameMode(mode);
Core.lastStand = "LastStand".equals(mode);
Core.getInstance().setChallenge(false);
Core.challengeId = null;
}
public String getGameMode() {
return Core.gameMode;
}
public void setPreset(String mode) {
Core.preset = mode;
}
public String getPreset() {
return Core.preset;
}
public void setWorld(String world) {
Core.gameSaveWorld = world.trim();
}
public void setMap(String world) {
Core.gameMap = world;
}
public String getMap() {
return Core.gameMap;
}
public void renderTerrain() {
}
public int getFrameNo() {
return this.frameNo;
}
public IsoSurvivor CreateRandomSurvivor(SurvivorDesc desc, IsoGridSquare sq, IsoPlayer player) {
return null;
}
public void CreateSwarm(int num, int x1, int y1, int x2, int y2) {
}
public void ForceKillAllZombies() {
GameTime.getInstance().RemoveZombiesIndiscriminate(1000);
}
public static int readInt(RandomAccessFile in) throws EOFException, IOException {
int ch1 = in.read();
int ch2 = in.read();
int ch3 = in.read();
int ch4 = in.read();
if ((ch1 | ch2 | ch3 | ch4) < 0) {
throw new EOFException();
} else {
return (ch1 << 0) + (ch2 << 8) + (ch3 << 16) + (ch4 << 24);
}
}
public static String readString(RandomAccessFile in) throws EOFException, IOException {
return in.readLine();
}
public static int readInt(InputStream in) throws EOFException, IOException {
int ch1 = in.read();
int ch2 = in.read();
int ch3 = in.read();
int ch4 = in.read();
if ((ch1 | ch2 | ch3 | ch4) < 0) {
throw new EOFException();
} else {
return (ch1 << 0) + (ch2 << 8) + (ch3 << 16) + (ch4 << 24);
}
}
public static String readString(InputStream in, StringBuilder input) throws IOException {
input.setLength(0);
int c = -1;
boolean eol = false;
while(!eol) {
switch (c = in.read()) {
case -1:
case 10:
eol = true;
break;
case 13:
throw new IllegalStateException("\r\n unsupported");
default:
input.append((char)c);
}
}
if (c == -1 && input.isEmpty()) {
return null;
} else {
return input.toString();
}
}
private int getSpriteID(int fileNumber, int tilesetNumber, int tileIndex) {
return fileNumber == 1 ? (tilesetNumber - 1) * 1024 + tileIndex : 1048576 + (fileNumber - 2) * 262144 + (tilesetNumber - 1) * 512 + tileIndex;
}
public void LoadTileDefinitions(IsoSpriteManager sprMan, String filename, int fileNumber) {
DebugType.DetailedInfo.trace("tiledef: loading " + filename);
boolean bPatch = filename.endsWith(".patch.tiles");
int maxTilesetsPerFile = fileNumber == 1 ? 1024 : 512;
int maxTilesPerTileset = fileNumber == 1 ? 1024 : 512;
try {
FileInputStream fis = new FileInputStream(filename);
try {
BufferedInputStream in = new BufferedInputStream(fis);
try {
label889: {
byte[] magic = new byte[TDEF_FILE_MAGIC.length];
int nBytes = in.read(magic);
if (nBytes == TDEF_FILE_MAGIC.length && Arrays.equals(magic, TDEF_FILE_MAGIC)) {
int version = readInt((InputStream)in);
if (version >= 1 && version <= 1) {
int numTilesheets = readInt((InputStream)in);
if (numTilesheets >= 0 && numTilesheets <= maxTilesetsPerFile) {
SharedStrings sharedStrings = new SharedStrings();
StringBuilder stringBuilder = new StringBuilder();
boolean saveMovableStatsToFile = false;
boolean dumpCustomNameToStdout = false;
boolean dumpUntranslatedCustomNameToStdout = Core.debug && Translator.getLanguage() == Translator.getDefaultLanguage();
ArrayList buffer = new ArrayList();
Map groupMap = new HashMap();
Map faceMap = new HashMap();
String[] faceNames = new String[]{"N", "E", "S", "W"};
for(int i = 0; i < faceNames.length; ++i) {
faceMap.put(faceNames[i], new ArrayList());
}
SpriteGridParseData spriteGridParseData = new SpriteGridParseData();
Map uniqueMovables = new HashMap();
int movableSpriteCount = 0;
int movableOneSpriteCount = 0;
int movablesSingleCount = 0;
int movablesMultiCount = 0;
HashSet customNames = new HashSet();
int n = 0;
String name;
label765:
while(n < numTilesheets) {
String str = readString(in, stringBuilder);
name = str.trim();
readString(in, stringBuilder);
int wTiles = readInt((InputStream)in);
int hTiles = readInt((InputStream)in);
int tilesetNumber = readInt((InputStream)in);
if (tilesetNumber >= 1 && tilesetNumber <= maxTilesetsPerFile) {
int nTiles = readInt((InputStream)in);
if (nTiles >= 0 && nTiles <= maxTilesPerTileset) {
int i;
ArrayList members;
label756:
for(int m = 0; m < nTiles; ++m) {
String tileName = name + "_" + m;
IsoSprite spr;
int nProps;
int l;
if (bPatch) {
spr = (IsoSprite)sprMan.namedMap.get(tileName);
if (spr == null) {
nProps = readInt((InputStream)in);
l = 0;
while(true) {
if (l >= nProps) {
continue label756;
}
readString(in, stringBuilder);
readString(in, stringBuilder);
++l;
}
}
} else {
spr = sprMan.AddSprite(tileName, this.getSpriteID(fileNumber, tilesetNumber, m));
}
if (Core.debug) {
if (this.allTiles.containsKey(name)) {
if (!bPatch) {
((ArrayList)this.allTiles.get(name)).add(tileName);
}
} else {
members = new ArrayList();
members.add(tileName);
this.allTiles.put(name, members);
}
}
buffer.add(spr);
if (!bPatch) {
spr.setName(tileName);
spr.tilesetName = name;
spr.tileSheetIndex = m;
}
if (spr.name.contains("damaged") || spr.name.contains("trash_")) {
spr.attachedFloor = true;
spr.getProperties().set("attachedFloor", "true");
}
if (spr.name.startsWith("f_bushes") && m <= 31) {
spr.isBush = true;
spr.attachedFloor = true;
}
nProps = readInt((InputStream)in);
for(l = 0; l < nProps; ++l) {
str = readString(in, stringBuilder);
String prop = str.trim();
str = readString(in, stringBuilder);
String val = str.trim();
IsoObjectType type = IsoObjectType.FromString(prop);
if (type == IsoObjectType.MAX) {
prop = sharedStrings.get(prop);
if (prop.equals("firerequirement")) {
spr.firerequirement = Integer.parseInt(val);
} else if (prop.equals("fireRequirement")) {
spr.firerequirement = Integer.parseInt(val);
} else if (prop.equals("BurntTile")) {
spr.burntTile = val;
} else if (prop.equals("ForceAmbient")) {
spr.forceAmbient = true;
spr.getProperties().set(prop, val);
} else if (prop.equals("solidfloor")) {
spr.solidfloor = true;
spr.getProperties().set(prop, val);
} else if (prop.equals("canBeRemoved")) {
spr.canBeRemoved = true;
spr.getProperties().set(prop, val);
} else if (prop.equals("attachedFloor")) {
spr.attachedFloor = true;
spr.getProperties().set(prop, val);
} else if (prop.equals("cutW")) {
spr.cutW = true;
spr.getProperties().set(prop, val);
} else if (prop.equals("cutN")) {
spr.cutN = true;
spr.getProperties().set(prop, val);
} else if (prop.equals("solid")) {
spr.solid = true;
spr.getProperties().set(prop, val);
} else if (prop.equals("solidtrans")) {
spr.solidTrans = true;
spr.getProperties().set(prop, val);
} else if (prop.equals("invisible")) {
spr.invisible = true;
spr.getProperties().set(prop, val);
} else if (prop.equals("alwaysDraw")) {
spr.alwaysDraw = true;
spr.getProperties().set(prop, val);
} else if (prop.equals("FasciaEdge")) {
spr.setFasciaEdge((FasciaEdge)StringUtils.tryParseEnum(FasciaEdge.class, val, (Enum)null));
spr.getProperties().set(prop, val);
} else if (prop.equals("forceRender")) {
spr.forceRender = true;
spr.getProperties().set(prop, val);
} else if ("FloorHeight".equals(prop)) {
if ("OneThird".equals(val)) {
spr.getProperties().set(IsoFlagType.FloorHeightOneThird);
} else if ("TwoThirds".equals(val)) {
spr.getProperties().set(IsoFlagType.FloorHeightTwoThirds);
}
} else if (prop.equals("MoveWithWind")) {
spr.moveWithWind = true;
spr.getProperties().set(prop, val);
} else if (prop.equals("WindType")) {
spr.windType = Integer.parseInt(val);
spr.getProperties().set(prop, val);
} else if (prop.equals("RenderLayer")) {
spr.getProperties().set(prop, val);
if ("Default".equals(val)) {
spr.renderLayer = 0;
} else if ("Floor".equals(val)) {
spr.renderLayer = 1;
}
} else if (prop.equals("TreatAsWallOrder")) {
spr.treatAsWallOrder = true;
spr.getProperties().set(prop, val);
} else {
spr.getProperties().set(prop, val);
if ("WindowN".equals(prop) || "WindowW".equals(prop)) {
spr.getProperties().set(prop, val, false);
}
}
} else {
if (spr.getTileType() != IsoObjectType.doorW && spr.getTileType() != IsoObjectType.doorN || type != IsoObjectType.wall) {
spr.setTileType(type);
}
if (type == IsoObjectType.doorW) {
spr.getProperties().set(IsoFlagType.doorW);
} else if (type == IsoObjectType.doorN) {
spr.getProperties().set(IsoFlagType.doorN);
}
}
if (type == IsoObjectType.tree) {
if (spr.name.equals("e_riverbirch_1_1")) {
val = "1";
}
spr.getProperties().set("tree", val);
spr.getProperties().set(IsoFlagType.blocksight);
i = Integer.parseInt(val);
if (name.startsWith("vegetation_trees")) {
i = 4;
}
if (i < 1) {
i = 1;
}
if (i > 4) {
i = 4;
}
if (i == 1 || i == 2) {
spr.getProperties().unset(IsoFlagType.blocksight);
}
spr.getProperties().set("MaterialType", "Wood_Solid");
}
if (prop.equals("interior") && val.equals("false")) {
spr.getProperties().set(IsoFlagType.exterior);
}
if (prop.equals("HoppableN")) {
spr.getProperties().set(IsoFlagType.collideN);
spr.getProperties().set(IsoFlagType.canPathN);
spr.getProperties().set(IsoFlagType.transparentN);
}
if (prop.equals("HoppableW")) {
spr.getProperties().set(IsoFlagType.collideW);
spr.getProperties().set(IsoFlagType.canPathW);
spr.getProperties().set(IsoFlagType.transparentW);
}
if (prop.equals("WallN")) {
spr.getProperties().set(IsoFlagType.collideN);
spr.getProperties().set(IsoFlagType.cutN);
spr.setTileType(IsoObjectType.wall);
spr.cutN = true;
spr.getProperties().set("WallN", "", false);
}
if (prop.equals("CantClimb")) {
spr.getProperties().set(IsoFlagType.CantClimb);
} else if (IsoPropertyType.CONTAINER.isProperty(prop)) {
spr.getProperties().set(prop, val, false);
} else if (prop.equals("WallNTrans")) {
spr.getProperties().set(IsoFlagType.collideN);
spr.getProperties().set(IsoFlagType.cutN);
spr.getProperties().set(IsoFlagType.transparentN);
spr.setTileType(IsoObjectType.wall);
spr.cutN = true;
spr.getProperties().set("WallNTrans", "", false);
} else if (prop.equals("WallW")) {
spr.getProperties().set(IsoFlagType.collideW);
spr.getProperties().set(IsoFlagType.cutW);
spr.setTileType(IsoObjectType.wall);
spr.cutW = true;
spr.getProperties().set("WallW", "", false);
} else if (prop.equals("windowN")) {
spr.getProperties().set("WindowN", "WindowN");
spr.getProperties().set(IsoFlagType.transparentN);
spr.getProperties().set("WindowN", "WindowN", false);
} else if (prop.equals("windowW")) {
spr.getProperties().set("WindowW", "WindowW");
spr.getProperties().set(IsoFlagType.transparentW);
spr.getProperties().set("WindowW", "WindowW", false);
} else if (prop.equals("cutW")) {
spr.getProperties().set(IsoFlagType.cutW);
spr.cutW = true;
} else if (prop.equals("cutN")) {
spr.getProperties().set(IsoFlagType.cutN);
spr.cutN = true;
} else if (prop.equals("WallWTrans")) {
spr.getProperties().set(IsoFlagType.collideW);
spr.getProperties().set(IsoFlagType.transparentW);
spr.getProperties().set(IsoFlagType.cutW);
spr.setTileType(IsoObjectType.wall);
spr.cutW = true;
spr.getProperties().set("WallWTrans", "", false);
} else if (prop.equals("DoorWallN")) {
spr.getProperties().set(IsoFlagType.cutN);
spr.cutN = true;
spr.getProperties().set("DoorWallN", "", false);
} else if (prop.equals("DoorWallNTrans")) {
spr.getProperties().set(IsoFlagType.cutN);
spr.getProperties().set(IsoFlagType.transparentN);
spr.cutN = true;
spr.getProperties().set("DoorWallNTrans", "", false);
} else if (prop.equals("DoorWallW")) {
spr.getProperties().set(IsoFlagType.cutW);
spr.cutW = true;
spr.getProperties().set("DoorWallW", "", false);
} else if (prop.equals("DoorWallWTrans")) {
spr.getProperties().set(IsoFlagType.cutW);
spr.getProperties().set(IsoFlagType.transparentW);
spr.cutW = true;
spr.getProperties().set("DoorWallWTrans", "", false);
} else if (prop.equals("WallNW")) {
spr.getProperties().set(IsoFlagType.collideN);
spr.getProperties().set(IsoFlagType.cutN);
spr.getProperties().set(IsoFlagType.collideW);
spr.getProperties().set(IsoFlagType.cutW);
spr.setTileType(IsoObjectType.wall);
spr.cutW = true;
spr.cutN = true;
spr.getProperties().set("WallNW", "", false);
} else if (prop.equals("WallNWTrans")) {
spr.getProperties().set(IsoFlagType.collideN);
spr.getProperties().set(IsoFlagType.cutN);
spr.getProperties().set(IsoFlagType.collideW);
spr.getProperties().set(IsoFlagType.transparentN);
spr.getProperties().set(IsoFlagType.transparentW);
spr.getProperties().set(IsoFlagType.cutW);
spr.setTileType(IsoObjectType.wall);
spr.cutW = true;
spr.cutN = true;
spr.getProperties().set("WallNWTrans", "", false);
} else if (prop.equals("WallSE")) {
spr.getProperties().set(IsoFlagType.cutW);
spr.getProperties().set(IsoFlagType.WallSE);
spr.getProperties().set("WallSE", "WallSE");
spr.cutW = true;
} else if (prop.equals("WindowW")) {
spr.getProperties().set(IsoFlagType.canPathW);
spr.getProperties().set(IsoFlagType.collideW);
spr.getProperties().set(IsoFlagType.cutW);
spr.getProperties().set(IsoFlagType.transparentW);
spr.setTileType(IsoObjectType.windowFW);
if (spr.getProperties().has(IsoFlagType.HoppableW)) {
DebugType.Moveable.error("ERROR: WindowW sprite shouldn't have HoppableW (%s)", new Object[]{spr.getName()});
spr.getProperties().unset(IsoFlagType.HoppableW);
}
spr.cutW = true;
} else if (prop.equals("WindowN")) {
spr.getProperties().set(IsoFlagType.canPathN);
spr.getProperties().set(IsoFlagType.collideN);
spr.getProperties().set(IsoFlagType.cutN);
spr.getProperties().set(IsoFlagType.transparentN);
spr.setTileType(IsoObjectType.windowFN);
if (spr.getProperties().has(IsoFlagType.HoppableN)) {
DebugType.Moveable.error("ERROR: WindowN sprite shouldn't have HoppableN (%s)", new Object[]{spr.getName()});
spr.getProperties().unset(IsoFlagType.HoppableN);
}
spr.cutN = true;
} else if (prop.equals("UnbreakableWindowW")) {
spr.getProperties().set(IsoFlagType.canPathW);
spr.getProperties().set(IsoFlagType.collideW);
spr.getProperties().set(IsoFlagType.cutW);
spr.getProperties().set(IsoFlagType.transparentW);
spr.getProperties().set(IsoFlagType.collideW);
spr.setTileType(IsoObjectType.wall);
spr.cutW = true;
} else if (prop.equals("UnbreakableWindowN")) {
spr.getProperties().set(IsoFlagType.canPathN);
spr.getProperties().set(IsoFlagType.collideN);
spr.getProperties().set(IsoFlagType.cutN);
spr.getProperties().set(IsoFlagType.transparentN);
spr.getProperties().set(IsoFlagType.collideN);
spr.setTileType(IsoObjectType.wall);
spr.cutN = true;
} else if (prop.equals("UnbreakableWindowNW")) {
spr.getProperties().set(IsoFlagType.cutN);
spr.getProperties().set(IsoFlagType.transparentN);
spr.getProperties().set(IsoFlagType.collideN);
spr.getProperties().set(IsoFlagType.cutN);
spr.getProperties().set(IsoFlagType.collideW);
spr.getProperties().set(IsoFlagType.cutW);
spr.setTileType(IsoObjectType.wall);
spr.cutW = true;
spr.cutN = true;
} else if ("NoWallLighting".equals(prop)) {
spr.getProperties().set(IsoFlagType.NoWallLighting);
} else if ("ForceAmbient".equals(prop)) {
spr.getProperties().set(IsoFlagType.ForceAmbient);
}
if (prop.equals("name")) {
spr.setParentObjectName(val);
}
}
if (spr.getProperties().has(IsoPropertyType.RED_LIGHT) || spr.getProperties().has(IsoPropertyType.GREEN_LIGHT) || spr.getProperties().has(IsoPropertyType.BLUE_LIGHT)) {
if (!spr.getProperties().has(IsoPropertyType.RED_LIGHT)) {
spr.getProperties().set(IsoPropertyType.RED_LIGHT, "0");
}
if (!spr.getProperties().has(IsoPropertyType.GREEN_LIGHT)) {
spr.getProperties().set(IsoPropertyType.GREEN_LIGHT, "0");
}
if (!spr.getProperties().has(IsoPropertyType.BLUE_LIGHT)) {
spr.getProperties().set(IsoPropertyType.BLUE_LIGHT, "0");
}
}
spr.getProperties().CreateKeySet();
if (Core.debug && spr.getProperties().has(IsoPropertyType.SMASHED_TILE_OFFSET) && !spr.getProperties().has(IsoPropertyType.GLASS_REMOVED_OFFSET)) {
DebugType.Sprite.error("Window sprite has SmashedTileOffset but no GlassRemovedOffset (" + spr.getName() + ")");
}
}
this.setOpenDoorProperties(name, buffer);
groupMap.clear();
Iterator var65 = buffer.iterator();
String fullgroup;
while(var65.hasNext()) {
IsoSprite spr = (IsoSprite)var65.next();
if (spr.getProperties().has("StopCar") && spr.getTileType() != IsoObjectType.tree) {
spr.setTileType(IsoObjectType.isMoveAbleObject);
}
String var10000;
if (spr.getProperties().has("IsMoveAble")) {
if (spr.getProperties().has(IsoPropertyType.CUSTOM_NAME) && !spr.getProperties().get(IsoPropertyType.CUSTOM_NAME).equals("")) {
++movableSpriteCount;
if (spr.getProperties().has(IsoPropertyType.GROUP_NAME)) {
var10000 = spr.getProperties().get(IsoPropertyType.GROUP_NAME);
fullgroup = var10000 + " " + spr.getProperties().get(IsoPropertyType.CUSTOM_NAME);
if (!groupMap.containsKey(fullgroup)) {
groupMap.put(fullgroup, new ArrayList());
}
((ArrayList)groupMap.get(fullgroup)).add(spr);
customNames.add(fullgroup);
} else {
if (!uniqueMovables.containsKey(name)) {
uniqueMovables.put(name, new ArrayList());
}
if (!((ArrayList)uniqueMovables.get(name)).contains(spr.getProperties().get(IsoPropertyType.CUSTOM_NAME))) {
((ArrayList)uniqueMovables.get(name)).add(spr.getProperties().get(IsoPropertyType.CUSTOM_NAME));
}
++movableOneSpriteCount;
customNames.add(spr.getProperties().get(IsoPropertyType.CUSTOM_NAME));
}
} else {
DebugType.Moveable.println("[IMPORTANT] MOVABLES: Object has no custom name defined: sheet = " + name);
}
} else if (spr.getProperties().has("SpriteGridPos")) {
if (StringUtils.isNullOrWhitespace(spr.getProperties().get(IsoPropertyType.CUSTOM_NAME))) {
DebugType.Moveable.println("[IMPORTANT] MOVABLES: Object has no custom name defined: sheet = " + name);
} else if (spr.getProperties().has(IsoPropertyType.GROUP_NAME)) {
var10000 = spr.getProperties().get(IsoPropertyType.GROUP_NAME);
fullgroup = var10000 + " " + spr.getProperties().get(IsoPropertyType.CUSTOM_NAME);
if (!groupMap.containsKey(fullgroup)) {
groupMap.put(fullgroup, new ArrayList());
}
((ArrayList)groupMap.get(fullgroup)).add(spr);
}
}
}
var65 = groupMap.entrySet().iterator();
while(true) {
while(true) {
while(true) {
String faceName;
int var47;
boolean isSpriteGrid;
boolean isValid;
IsoSprite current;
int sprCount;
Iterator var79;
do {
if (!var65.hasNext()) {
buffer.clear();
++n;
continue label765;
}
Map.Entry entry = (Map.Entry)var65.next();
fullgroup = (String)entry.getKey();
if (!uniqueMovables.containsKey(name)) {
uniqueMovables.put(name, new ArrayList());
}
if (!((ArrayList)uniqueMovables.get(name)).contains(fullgroup)) {
((ArrayList)uniqueMovables.get(name)).add(fullgroup);
}
members = (ArrayList)entry.getValue();
if (members.size() == 1) {
DebugType.Moveable.debugln("MOVABLES: Object has only one face defined for group: (" + fullgroup + ") sheet = " + name);
}
if (members.size() == 3) {
DebugType.Moveable.debugln("MOVABLES: Object only has 3 sprites, _might_ have a error in settings, group: (" + fullgroup + ") sheet = " + name);
}
String[] var70 = faceNames;
int var72 = faceNames.length;
for(sprCount = 0; sprCount < var72; ++sprCount) {
String faceName = var70[sprCount];
((ArrayList)faceMap.get(faceName)).clear();
}
isSpriteGrid = ((IsoSprite)members.get(0)).getProperties().has("SpriteGridPos") && !((IsoSprite)members.get(0)).getProperties().get("SpriteGridPos").equals("None");
isValid = true;
var79 = members.iterator();
while(var79.hasNext()) {
current = (IsoSprite)var79.next();
boolean testIsSpriteGrid = current.getProperties().has("SpriteGridPos") && !current.getProperties().get("SpriteGridPos").equals("None");
if (isSpriteGrid != testIsSpriteGrid) {
isValid = false;
DebugType.Moveable.debugln("MOVABLES: Difference in SpriteGrid settings for members of group: (" + fullgroup + ") sheet = " + name);
break;
}
if (!current.getProperties().has(IsoPropertyType.FACING)) {
isValid = false;
} else {
switch (current.getProperties().get(IsoPropertyType.FACING)) {
case "N":
((ArrayList)faceMap.get("N")).add(current);
break;
case "E":
((ArrayList)faceMap.get("E")).add(current);
break;
case "S":
((ArrayList)faceMap.get("S")).add(current);
break;
case "W":
((ArrayList)faceMap.get("W")).add(current);
break;
default:
DebugType.Moveable.debugln("MOVABLES: Invalid face (" + current.getProperties().get(IsoPropertyType.FACING) + ") for group: (" + fullgroup + ") sheet = " + name);
isValid = false;
}
}
if (!isValid) {
DebugType.Moveable.debugln("MOVABLES: Not all members have a valid face defined for group: (" + fullgroup + ") sheet = " + name);
break;
}
}
} while(!isValid);
if (!isSpriteGrid) {
if (members.size() > 4) {
DebugType.Moveable.debugln("MOVABLES: Object has too many faces defined for group: (" + fullgroup + ") sheet = " + name);
} else {
String[] var83 = faceNames;
int var78 = faceNames.length;
for(i = 0; i < var78; ++i) {
faceName = var83[i];
if (((ArrayList)faceMap.get(faceName)).size() > 1) {
DebugType.Moveable.debugln("MOVABLES: " + faceName + " face defined more than once for group: (" + fullgroup + ") sheet = " + name);
isValid = false;
}
}
if (isValid) {
++movablesSingleCount;
var79 = members.iterator();
while(var79.hasNext()) {
current = (IsoSprite)var79.next();
String[] var90 = faceNames;
int var84 = faceNames.length;
for(var47 = 0; var47 < var84; ++var47) {
String faceName = var90[var47];
ArrayList direction = (ArrayList)faceMap.get(faceName);
if (!direction.isEmpty() && direction.get(0) != current) {
current.getProperties().set(faceName + "offset", Integer.toString(buffer.indexOf(direction.get(0)) - buffer.indexOf(current)));
}
}
}
}
}
} else {
sprCount = 0;
IsoSpriteGrid[] grids = new IsoSpriteGrid[faceNames.length];
int j;
IsoSprite anchorSprite;
for(i = 0; i < faceNames.length; ++i) {
ArrayList direction = (ArrayList)faceMap.get(faceNames[i]);
if (!direction.isEmpty()) {
if (sprCount == 0) {
sprCount = direction.size();
}
if (sprCount != direction.size()) {
DebugType.Moveable.debugln("MOVABLES: Sprite count mismatch for multi sprite movable, group: (" + fullgroup + ") sheet = " + name);
isValid = false;
break;
}
spriteGridParseData.clear();
SpriteGridParseData.Level levelData;
Iterator var87;
for(var87 = direction.iterator(); var87.hasNext(); spriteGridParseData.height = PZMath.max(spriteGridParseData.height, levelData.height)) {
IsoSprite mem = (IsoSprite)var87.next();
String pos = mem.getProperties().get("SpriteGridPos");
String[] parts = pos.split(",");
if (parts.length < 2 || parts.length > 3) {
DebugType.Moveable.debugln("MOVABLES: SpriteGrid position error for multi sprite movable, group: (" + fullgroup + ") sheet = " + name);
isValid = false;
break;
}
j = Integer.parseInt(parts[0]);
int y = Integer.parseInt(parts[1]);
int spriteGridZ = 0;
if (parts.length == 3) {
spriteGridZ = Integer.parseInt(parts[2]);
}
if (mem.getProperties().has("SpriteGridLevel")) {
spriteGridZ = Integer.parseInt(mem.getProperties().get("SpriteGridLevel"));
if (spriteGridZ < 0) {
DebugType.Moveable.debugln("MOVABLES: invalid SpriteGirdLevel for multi sprite movable, group: (" + fullgroup + ") sheet = " + name);
isValid = false;
break;
}
}
levelData = spriteGridParseData.getOrCreateLevel(spriteGridZ);
if (levelData.xyToSprite.containsKey(pos)) {
DebugType.Moveable.debugln("MOVABLES: double SpriteGrid position (" + pos + ") for multi sprite movable, group: (" + fullgroup + ") sheet = " + name);
isValid = false;
break;
}
levelData.xyToSprite.put(pos, mem);
levelData.width = PZMath.max(levelData.width, j + 1);
levelData.height = PZMath.max(levelData.height, y + 1);
spriteGridParseData.width = PZMath.max(spriteGridParseData.width, levelData.width);
}
if (!isValid) {
break;
}
if (!spriteGridParseData.isValid()) {
DebugType.Moveable.debugln("MOVABLES: SpriteGrid dimensions error for multi sprite movable, group: (" + fullgroup + ") sheet = " + name);
isValid = false;
break;
}
grids[i] = new IsoSpriteGrid(spriteGridParseData.width, spriteGridParseData.height, spriteGridParseData.levels.size());
var87 = spriteGridParseData.levels.iterator();
while(var87.hasNext()) {
SpriteGridParseData.Level levelData = (SpriteGridParseData.Level)var87.next();
Iterator var89 = levelData.xyToSprite.entrySet().iterator();
while(var89.hasNext()) {
Map.Entry entry1 = (Map.Entry)var89.next();
String pos = (String)entry1.getKey();
anchorSprite = (IsoSprite)entry1.getValue();
String[] parts = pos.split(",");
int x = Integer.parseInt(parts[0]);
int y = Integer.parseInt(parts[1]);
grids[i].setSprite(x, y, levelData.z, anchorSprite);
}
}
if (!grids[i].validate()) {
DebugType.Moveable.debugln("MOVABLES: SpriteGrid didn't validate for multi sprite movable, group: (" + fullgroup + ") sheet = " + name);
isValid = false;
break;
}
}
}
if (isValid && sprCount != 0) {
++movablesMultiCount;
for(i = 0; i < faceNames.length; ++i) {
IsoSpriteGrid grid = grids[i];
if (grid != null) {
IsoSprite[] var91 = grid.getSprites();
int var86 = var91.length;
for(int var92 = 0; var92 < var86; ++var92) {
IsoSprite member = var91[var92];
if (member != null) {
member.setSpriteGrid(grid);
for(j = 0; j < faceNames.length; ++j) {
if (j != i && grids[j] != null) {
anchorSprite = grids[j].getAnchorSprite();
member.getProperties().set(faceNames[j] + "offset", Integer.toString(anchorSprite.tileSheetIndex - member.tileSheetIndex));
}
}
}
}
}
}
} else {
DebugType.Moveable.debugln("MOVABLES: Error in multi sprite movable, group: (" + fullgroup + ") sheet = " + name);
}
}
}
}
}
}
throw new IOException("%s: invalid number of tiles %d, must be from 0 to %d in %s".formatted(filename, nTiles, maxTilesPerTileset, name));
}
throw new IOException("%s: invalid tileset number %d, must be from 1 to %d in %s".formatted(filename, tilesetNumber, maxTilesetsPerFile, name));
}
if (dumpUntranslatedCustomNameToStdout) {
ArrayList customNamesSorted = new ArrayList(customNames);
Collections.sort(customNamesSorted);
StringBuilder sb = new StringBuilder();
Iterator var64 = customNamesSorted.iterator();
while(var64.hasNext()) {
String customName = (String)var64.next();
if (Translator.getMoveableDisplayNameOrNull(customName) == null) {
String var10001 = customName.replaceAll(" ", "_").replaceAll("-", "_").replaceAll("'", "").replaceAll("\\.", "");
sb.append(var10001 + " = \"" + customName + "\",\n");
}
}
name = sb.toString();
if (!name.isEmpty() && Core.debug) {
DebugType.Translation.debugln("Missing translations in Moveables_EN.txt:\n" + name);
}
}
break label889;
}
throw new IOException("%s: invalid number of tilesets %d, must be from 0 to %d".formatted(filename, numTilesheets, maxTilesetsPerFile));
}
throw new IOException("%s: invalid version %d, must be from %d to %d".formatted(filename, version, 1, 1));
}
throw new IOException("not magic");
}
} catch (Throwable var58) {
try {
in.close();
} catch (Throwable var57) {
var58.addSuppressed(var57);
}
throw var58;
}
in.close();
} catch (Throwable var59) {
try {
fis.close();
} catch (Throwable var56) {
var59.addSuppressed(var56);
}
throw var59;
}
fis.close();
} catch (Exception var60) {
ExceptionLogger.logException(var60);
}
}
private void GenerateTilePropertyLookupTables() {
TilePropertyAliasMap.instance.Generate(PropertyValueMap);
PropertyValueMap.clear();
}
public void LoadTileDefinitionsPropertyStrings(IsoSpriteManager sprMan, String filename, int fileNumber) {
DebugType.DetailedInfo.trace("tiledef: loading " + filename);
if (!GameServer.server) {
Thread.yield();
Core.getInstance().DoFrameReady();
}
int maxTilesetsPerFile = fileNumber == 1 ? 1024 : 512;
int maxTilesPerTileset = fileNumber == 1 ? 1024 : 512;
try {
FileInputStream fis = new FileInputStream(filename);
try {
BufferedInputStream in = new BufferedInputStream(fis);
try {
label144: {
byte[] magic = new byte[TDEF_FILE_MAGIC.length];
int nBytes = in.read(magic);
if (nBytes == TDEF_FILE_MAGIC.length && Arrays.equals(magic, TDEF_FILE_MAGIC)) {
int version = readInt((InputStream)in);
if (version >= 1 && version <= 1) {
int numTilesheets = readInt((InputStream)in);
if (numTilesheets < 0 || numTilesheets > maxTilesetsPerFile) {
throw new IOException("%s: invalid number of tilesets %d, must be from 0 to %d".formatted(filename, numTilesheets, maxTilesetsPerFile));
}
SharedStrings sharedStrings = new SharedStrings();
StringBuilder stringBuilder = new StringBuilder();
int n = 0;
while(n < numTilesheets) {
String str = readString(in, stringBuilder);
String name = str.trim();
String imageName = readString(in, stringBuilder);
this.tileImages.add(imageName);
int wTiles = readInt((InputStream)in);
int hTiles = readInt((InputStream)in);
int tilesetNumber = readInt((InputStream)in);
if (tilesetNumber >= 1 && tilesetNumber <= maxTilesetsPerFile) {
int nTiles = readInt((InputStream)in);
if (nTiles >= 0 && nTiles <= maxTilesPerTileset) {
for(int m = 0; m < nTiles; ++m) {
int nProps = readInt((InputStream)in);
for(int l = 0; l < nProps; ++l) {
str = readString(in, stringBuilder);
String prop = str.trim();
str = readString(in, stringBuilder);
String val = str.trim();
prop = sharedStrings.get(prop);
ArrayList values;
if (PropertyValueMap.containsKey(prop)) {
values = (ArrayList)PropertyValueMap.get(prop);
} else {
values = new ArrayList();
PropertyValueMap.put(prop, values);
}
if (!values.contains(val)) {
values.add(val);
}
}
}
++n;
continue;
}
throw new IOException("%s: invalid number of tiles %d, must be from 0 to %d in %s".formatted(filename, nTiles, maxTilesPerTileset, name));
}
throw new IOException("%s: invalid tileset number %d, must be from 1 to %d in %s".formatted(filename, tilesetNumber, maxTilesetsPerFile, name));
}
break label144;
}
throw new IOException("%s: invalid version %d, must be from %d to %d".formatted(filename, version, 1, 1));
}
throw new IOException("not magic");
}
} catch (Throwable var30) {
try {
in.close();
} catch (Throwable var29) {
var30.addSuppressed(var29);
}
throw var30;
}
in.close();
} catch (Throwable var31) {
try {
fis.close();
} catch (Throwable var28) {
var31.addSuppressed(var28);
}
throw var31;
}
fis.close();
} catch (Exception var32) {
Logger.getLogger(GameWindow.class.getName()).log(Level.SEVERE, (String)null, var32);
}
}
private void SetCustomPropertyValues() {
((ArrayList)PropertyValueMap.get("WindowN")).add("WindowN");
((ArrayList)PropertyValueMap.get("WindowW")).add("WindowW");
((ArrayList)PropertyValueMap.get("DoorWallN")).add("DoorWallN");
((ArrayList)PropertyValueMap.get("DoorWallW")).add("DoorWallW");
((ArrayList)PropertyValueMap.get("WallSE")).add("WallSE");
ArrayList offsets = new ArrayList();
int i;
String value;
for(i = -96; i <= 96; ++i) {
value = Integer.toString(i);
offsets.add(value);
}
PropertyValueMap.put("Noffset", offsets);
PropertyValueMap.put("Soffset", offsets);
PropertyValueMap.put("Woffset", offsets);
PropertyValueMap.put("Eoffset", offsets);
((ArrayList)PropertyValueMap.get("tree")).add("5");
((ArrayList)PropertyValueMap.get("tree")).add("6");
((ArrayList)PropertyValueMap.get("tree")).add("7");
((ArrayList)PropertyValueMap.get("tree")).add("8");
((ArrayList)PropertyValueMap.get(IsoPropertyType.RED_LIGHT.getName())).add("0");
((ArrayList)PropertyValueMap.get(IsoPropertyType.GREEN_LIGHT.getName())).add("0");
((ArrayList)PropertyValueMap.get(IsoPropertyType.BLUE_LIGHT.getName())).add("0");
for(i = 0; i <= 96; ++i) {
value = String.valueOf(i);
ArrayList values = (ArrayList)PropertyValueMap.get("ItemHeight");
if (!values.contains(value)) {
values.add(value);
}
values = (ArrayList)PropertyValueMap.get("Surface");
if (!values.contains(value)) {
values.add(value);
}
}
}
private void setOpenDoorProperties(String tilesheetName, ArrayList sprites) {
for(int i = 0; i < sprites.size(); ++i) {
IsoSprite spr = (IsoSprite)sprites.get(i);
if ((spr.getTileType() == IsoObjectType.doorN || spr.getTileType() == IsoObjectType.doorW) && !spr.getProperties().has(IsoFlagType.open)) {
String doubleDoor = spr.getProperties().get(IsoPropertyType.DOUBLE_DOOR);
if (doubleDoor != null) {
int index = PZMath.tryParseInt(doubleDoor, -1);
if (index >= 5) {
spr.getProperties().set(IsoFlagType.open);
}
} else {
String garageDoor = spr.getProperties().get(IsoPropertyType.GARAGE_DOOR);
if (garageDoor != null) {
int index = PZMath.tryParseInt(garageDoor, -1);
if (index >= 4) {
spr.getProperties().set(IsoFlagType.open);
}
} else {
IsoSprite openSprite = (IsoSprite)IsoSpriteManager.instance.namedMap.get(tilesheetName + "_" + (spr.tileSheetIndex + 2));
if (openSprite != null) {
openSprite.setTileType(spr.getTileType());
openSprite.getProperties().set(spr.getTileType() == IsoObjectType.doorN ? IsoFlagType.doorN : IsoFlagType.doorW);
openSprite.getProperties().set(IsoFlagType.open);
}
}
}
}
}
}
private void saveMovableStats(Map names, int num, int onesprites, int singles, int multies, int totalsprites) throws FileNotFoundException, IOException {
File path = new File(ZomboidFileSystem.instance.getCacheDir());
if (path.exists() && path.isDirectory()) {
String var10002 = ZomboidFileSystem.instance.getCacheDir();
File f = new File(var10002 + File.separator + "movables_stats_" + num + ".txt");
try {
FileWriter w = new FileWriter(f, false);
try {
w.write("### Movable objects ###" + System.lineSeparator());
w.write("Single Face: " + onesprites + System.lineSeparator());
w.write("Multi Face: " + singles + System.lineSeparator());
w.write("Multi Face & Multi Sprite: " + multies + System.lineSeparator());
w.write("Total objects : " + (onesprites + singles + multies) + System.lineSeparator());
w.write(" " + System.lineSeparator());
w.write("Total sprites : " + totalsprites + System.lineSeparator());
w.write(" " + System.lineSeparator());
Iterator var10 = names.entrySet().iterator();
while(var10.hasNext()) {
Map.Entry entry = (Map.Entry)var10.next();
String var10001 = (String)entry.getKey();
w.write(var10001 + System.lineSeparator());
Iterator var12 = ((ArrayList)entry.getValue()).iterator();
while(var12.hasNext()) {
String name = (String)var12.next();
w.write("\t" + name + System.lineSeparator());
}
}
} catch (Throwable var15) {
try {
w.close();
} catch (Throwable var14) {
var15.addSuppressed(var14);
}
throw var15;
}
w.close();
} catch (Exception var16) {
ExceptionLogger.logException(var16);
}
}
}
private void addJumboTreeTileset(IsoSpriteManager sprMan, int fileNumber, String type, String name, int tilesetNumber, int rows, int columns, int windType) {
for(int row = 0; row < rows; ++row) {
for(int col = 0; col < columns; ++col) {
String tilesetName = "e_" + name + type + "_1";
int tileNum = row * columns + col;
IsoSprite spr = sprMan.AddSprite(tilesetName + "_" + tileNum, this.getSpriteID(fileNumber, tilesetNumber, tileNum));
assert GameServer.server || !spr.hasNoTextures();
spr.setName(tilesetName + "_" + tileNum);
spr.setTileType(IsoObjectType.tree);
if (type.contains("JUMBOXXL")) {
spr.getProperties().set("tree", "8");
} else if (type.contains("JUMBOXL")) {
spr.getProperties().set("tree", "7");
} else if (type.contains("JUMBO") && col == 1) {
spr.getProperties().set("tree", "6");
} else if (type.contains("JUMBO") && col == 0) {
spr.getProperties().set("tree", "5");
} else {
spr.getProperties().set("tree", "5");
}
spr.getProperties().unset(IsoFlagType.solid);
spr.getProperties().set(IsoFlagType.blocksight);
spr.getProperties().set("MaterialType", "Wood_Solid");
spr.getProperties().CreateKeySet();
spr.moveWithWind = true;
spr.windType = windType;
}
}
}
private void addJumboTrunkTileset(IsoSpriteManager sprMan, int fileNumber, String type, int tilesetNumber) {
for(int i = 0; i <= 114; ++i) {
String tilesetName = "e_trunks_" + type + "_" + i;
IsoSprite spr = sprMan.AddSprite(tilesetName, fileNumber * 512 * 512 + tilesetNumber * 512 + i);
assert GameServer.server || !spr.hasNoTextures();
spr.setName(tilesetName);
spr.setTileType(IsoObjectType.tree);
if (type.contains("JUMBOXXL")) {
spr.getProperties().set("tree", "8");
} else if (type.contains("JUMBOXL")) {
spr.getProperties().set("tree", "7");
} else {
spr.getProperties().set("tree", "5");
}
spr.getProperties().unset(IsoFlagType.solid);
spr.getProperties().set(IsoFlagType.blocksight);
spr.getProperties().set("MaterialType", "Wood_Solid");
spr.getProperties().CreateKeySet();
}
}
private void registerFakeJumboTree(IsoSpriteManager sprMan, int fileNumber) {
int tileNum = false;
IsoSprite spr = sprMan.AddSprite("jumbo_tree_01_0", fileNumber * 512 * 512 + 6144 + 0);
spr.setName("jumbo_tree_01_0");
spr.setTileType(IsoObjectType.tree);
spr.getProperties().set("tree", "4");
spr.getProperties().unset(IsoFlagType.solid);
spr.getProperties().set(IsoFlagType.blocksight);
}
private void loadedTileDefinitions() {
CellLoader.glassRemovedWindowSpriteMap.clear();
CellLoader.smashedWindowSpriteMap.clear();
Iterator var1 = IsoSpriteManager.instance.namedMap.values().iterator();
while(true) {
while(var1.hasNext()) {
IsoSprite sprite = (IsoSprite)var1.next();
PropertyContainer props = sprite.getProperties();
if (props.has(IsoFlagType.windowW) || props.has(IsoFlagType.windowN)) {
String val = props.get(IsoPropertyType.GLASS_REMOVED_OFFSET);
int offset;
IsoSprite sprite2;
if (val != null) {
offset = PZMath.tryParseInt(val, 0);
if (offset != 0) {
sprite2 = IsoSprite.getSprite(IsoSpriteManager.instance, sprite, offset);
if (sprite2 != null) {
CellLoader.glassRemovedWindowSpriteMap.put(sprite2, sprite);
}
}
}
val = props.get(IsoPropertyType.SMASHED_TILE_OFFSET);
if (val != null) {
offset = PZMath.tryParseInt(val, 0);
if (offset != 0) {
sprite2 = IsoSprite.getSprite(IsoSpriteManager.instance, sprite, offset);
if (sprite2 != null) {
CellLoader.smashedWindowSpriteMap.put(sprite2, sprite);
}
}
}
}
if (sprite.name != null && sprite.name.startsWith("fixtures_railings_01")) {
sprite.getProperties().set(IsoFlagType.NeverCutaway);
}
IsoSprite sprite1 = (IsoSprite)IsoSpriteManager.instance.namedMap.get(sprite.tilesetName + "_on_" + sprite.tileSheetIndex);
if (sprite1 != null && !sprite1.hasNoTextures()) {
sprite.getProperties().set(IsoFlagType.HasLightOnSprite);
} else {
sprite.getProperties().unset(IsoFlagType.HasLightOnSprite);
}
}
SpriteModelManager.getInstance().loadedTileDefinitions();
TileDepthTextureManager.getInstance().loadedTileDefinitions();
TileGeometryManager.getInstance().loadedTileDefinitions();
this.getAttachmentsHandler().loadAttachments();
return;
}
}
public boolean LoadPlayerForInfo() throws FileNotFoundException, IOException {
if (GameClient.client) {
return ClientPlayerDB.getInstance().loadNetworkPlayerInfo(1);
} else {
File inFile = ZomboidFileSystem.instance.getFileInCurrentSave("map_p.bin");
if (!inFile.exists()) {
PlayerDB.getInstance().importPlayersFromVehiclesDB();
return PlayerDB.getInstance().loadLocalPlayerInfo(1);
} else {
FileInputStream inStream = new FileInputStream(inFile);
BufferedInputStream input = new BufferedInputStream(inStream);
synchronized(SliceY.SliceBufferLock) {
SliceY.SliceBuffer.clear();
int numBytes = input.read(SliceY.SliceBuffer.array());
SliceY.SliceBuffer.limit(numBytes);
input.close();
byte b1 = SliceY.SliceBuffer.get();
byte b2 = SliceY.SliceBuffer.get();
byte b3 = SliceY.SliceBuffer.get();
byte b4 = SliceY.SliceBuffer.get();
if (b1 == 80 && b2 == 76 && b3 == 89 && b4 == 82) {
int var10 = SliceY.SliceBuffer.getInt();
} else {
SliceY.SliceBuffer.rewind();
}
String serverPlayerID = GameWindow.ReadString(SliceY.SliceBuffer);
if (GameClient.client && !IsoPlayer.isServerPlayerIDValid(serverPlayerID)) {
GameLoadingState.gameLoadingString = Translator.getText("IGUI_MP_ServerPlayerIDMismatch", new Object[0]);
GameLoadingState.playerWrongIP = true;
return false;
} else {
worldX = SliceY.SliceBuffer.getInt();
worldY = SliceY.SliceBuffer.getInt();
IsoChunkMap.worldXa = SliceY.SliceBuffer.getInt();
IsoChunkMap.worldYa = SliceY.SliceBuffer.getInt();
IsoChunkMap.worldZa = SliceY.SliceBuffer.getInt();
IsoChunkMap.worldXa += 256 * saveoffsetx;
IsoChunkMap.worldYa += 256 * saveoffsety;
IsoChunkMap.SWorldX[0] = worldX;
IsoChunkMap.SWorldY[0] = worldY;
int[] var10000 = IsoChunkMap.SWorldX;
var10000[0] += 32 * saveoffsetx;
var10000 = IsoChunkMap.SWorldY;
var10000[0] += 32 * saveoffsety;
return true;
}
}
}
}
}
public void init() throws FileNotFoundException, IOException, WorldDictionaryException {
if (!Core.tutorial) {
this.randomizedBuildingList.add(new RBSafehouse());
this.randomizedBuildingList.add(new RBBurnt());
this.randomizedBuildingList.add(new RBOther());
this.randomizedBuildingList.add(new RBLooted());
this.randomizedBuildingList.add(new RBBurntFireman());
this.randomizedBuildingList.add(new RBBurntCorpse());
this.randomizedBuildingList.add(new RBShopLooted());
this.randomizedBuildingList.add(new RBKateAndBaldspot());
this.randomizedBuildingList.add(new RBStripclub());
this.randomizedBuildingList.add(new RBSchool());
this.randomizedBuildingList.add(new RBSpiffo());
this.randomizedBuildingList.add(new RBPizzaWhirled());
this.randomizedBuildingList.add(new RBPileOCrepe());
this.randomizedBuildingList.add(new RBCafe());
this.randomizedBuildingList.add(new RBBar());
this.randomizedBuildingList.add(new RBOffice());
this.randomizedBuildingList.add(new RBHairSalon());
this.randomizedBuildingList.add(new RBClinic());
this.randomizedBuildingList.add(new RBGunstoreSiege());
this.randomizedBuildingList.add(new RBPoliceSiege());
this.randomizedBuildingList.add(new RBSWATStation());
this.randomizedBuildingList.add(new RBHeatBreakAfternoon());
this.randomizedBuildingList.add(new RBTrashed());
this.randomizedBuildingList.add(new RBBarn());
this.randomizedBuildingList.add(new RBDorm());
this.randomizedBuildingList.add(new RBNolans());
this.randomizedBuildingList.add(new RBJackieJaye());
this.randomizedBuildingList.add(new RBJoanHartford());
this.randomizedBuildingList.add(new RBMayorWestPoint());
this.randomizedBuildingList.add(new RBTwiggy());
this.randomizedBuildingList.add(new RBWoodcraft());
this.randomizedVehicleStoryList.add(new RVSUtilityVehicle());
this.randomizedVehicleStoryList.add(new RVSConstructionSite());
this.randomizedVehicleStoryList.add(new RVSBurntCar());
this.randomizedVehicleStoryList.add(new RVSPoliceBlockadeShooting());
this.randomizedVehicleStoryList.add(new RVSPoliceBlockade());
this.randomizedVehicleStoryList.add(new RVSCarCrash());
this.randomizedVehicleStoryList.add(new RVSAmbulanceCrash());
this.randomizedVehicleStoryList.add(new RVSCarCrashCorpse());
this.randomizedVehicleStoryList.add(new RVSChangingTire());
this.randomizedVehicleStoryList.add(new RVSFlippedCrash());
this.randomizedVehicleStoryList.add(new RVSBanditRoad());
this.randomizedVehicleStoryList.add(new RVSTrailerCrash());
this.randomizedVehicleStoryList.add(new RVSCrashHorde());
this.randomizedVehicleStoryList.add(new RVSCarCrashDeer());
this.randomizedVehicleStoryList.add(new RVSDeadEnd());
this.randomizedVehicleStoryList.add(new RVSRegionalProfessionVehicle());
this.randomizedVehicleStoryList.add(new RVSRoadKill());
this.randomizedVehicleStoryList.add(new RVSRoadKillSmall());
this.randomizedVehicleStoryList.add(new RVSAnimalOnRoad());
this.randomizedVehicleStoryList.add(new RVSHerdOnRoad());
this.randomizedVehicleStoryList.add(new RVSAnimalTrailerOnRoad());
this.randomizedVehicleStoryList.add(new RVSRichJerk());
this.randomizedVehicleStoryList.add(new RVSPlonkies());
this.randomizedZoneList.add(new RZSAttachedAnimal());
this.randomizedZoneList.add(new RZSBBQParty());
this.randomizedZoneList.add(new RZSBaseball());
this.randomizedZoneList.add(new RZSBeachParty());
this.randomizedZoneList.add(new RZSBurntWreck());
this.randomizedZoneList.add(new RZSBuryingCamp());
this.randomizedZoneList.add(new RZSCampsite());
this.randomizedZoneList.add(new RZSCharcoalBurner());
this.randomizedZoneList.add(new RZSDean());
this.randomizedZoneList.add(new RZSDuke());
this.randomizedZoneList.add(new RZSEscapedAnimal());
this.randomizedZoneList.add(new RZSEscapedHerd());
this.randomizedZoneList.add(new RZSFishingTrip());
this.randomizedZoneList.add(new RZSForestCamp());
this.randomizedZoneList.add(new RZSForestCampEaten());
this.randomizedZoneList.add(new RZSFrankHemingway());
this.randomizedZoneList.add(new RZSHermitCamp());
this.randomizedZoneList.add(new RZSHillbillyHoedown());
this.randomizedZoneList.add(new RZSHogWild());
this.randomizedZoneList.add(new RZSHunterCamp());
this.randomizedZoneList.add(new RZJackieJaye());
this.randomizedZoneList.add(new RZSKirstyKormick());
this.randomizedZoneList.add(new RZSMurderScene());
this.randomizedZoneList.add(new RZSMusicFest());
this.randomizedZoneList.add(new RZSMusicFestStage());
this.randomizedZoneList.add(new RZSNastyMattress());
this.randomizedZoneList.add(new RZSOccultActivity());
this.randomizedZoneList.add(new RZSOldFirepit());
this.randomizedZoneList.add(new RZSOldShelter());
this.randomizedZoneList.add(new RZSOrphanedFawn());
this.randomizedZoneList.add(new RZSRangerSmith());
this.randomizedZoneList.add(new RZSRockerParty());
this.randomizedZoneList.add(new RZSSadCamp());
this.randomizedZoneList.add(new RZSSexyTime());
this.randomizedZoneList.add(new RZSSirTwiggy());
this.randomizedZoneList.add(new RZSSurvivalistCamp());
this.randomizedZoneList.add(new RZSTragicPicnic());
this.randomizedZoneList.add(new RZSTrapperCamp());
this.randomizedZoneList.add(new RZSVanCamp());
this.randomizedZoneList.add(new RZSWasteDump());
this.randomizedZoneList.add(new RZSWaterPump());
}
RBBasic.getUniqueRDSSpawned().clear();
if (!GameClient.client && !GameServer.server) {
BodyDamageSync.instance = null;
} else {
BodyDamageSync.instance = new BodyDamageSync();
}
if (GameServer.server) {
Core.gameSaveWorld = GameServer.serverName;
String saveFolder = ZomboidFileSystem.instance.getCurrentSaveDir();
File file = new File(saveFolder);
if (!file.exists()) {
GameServer.resetId = Rand.Next(10000000);
ServerOptions.instance.putSaveOption("ResetID", String.valueOf(GameServer.resetId));
}
GlobalObject.createWorld(Core.gameSaveWorld);
}
savedWorldVersion = this.readWorldVersion();
DataInputStream input;
int x;
File inFile;
FileInputStream fis;
if (!GameServer.server) {
inFile = ZomboidFileSystem.instance.getFileInCurrentSave("map_ver.bin");
try {
fis = new FileInputStream(inFile);
try {
input = new DataInputStream(fis);
try {
x = input.readInt();
String mapDir = GameWindow.ReadString(input);
if (!GameClient.client) {
Core.gameMap = mapDir;
}
} catch (Throwable var36) {
try {
input.close();
} catch (Throwable var32) {
var36.addSuppressed(var32);
}
throw var36;
}
input.close();
} catch (Throwable var37) {
try {
fis.close();
} catch (Throwable var31) {
var37.addSuppressed(var31);
}
throw var37;
}
fis.close();
} catch (FileNotFoundException var38) {
}
}
if (!GameClient.client) {
inFile = ZomboidFileSystem.instance.getFileInCurrentSave("id_manager_data.bin");
try {
fis = new FileInputStream(inFile);
try {
input = new DataInputStream(fis);
try {
x = input.readInt();
ObjectIDManager.getInstance().load(input, x);
} catch (Throwable var28) {
try {
input.close();
} catch (Throwable var27) {
var28.addSuppressed(var27);
}
throw var28;
}
input.close();
} catch (Throwable var29) {
try {
fis.close();
} catch (Throwable var26) {
var29.addSuppressed(var26);
}
throw var29;
}
fis.close();
} catch (FileNotFoundException var30) {
}
}
int z;
int y;
if (!GameClient.client) {
inFile = ZomboidFileSystem.instance.getFileInCurrentSave("important_area_data.bin");
try {
fis = new FileInputStream(inFile);
try {
BufferedInputStream input = new BufferedInputStream(fis);
try {
synchronized(SliceY.SliceBufferLock) {
SliceY.SliceBuffer.clear();
y = input.read(SliceY.SliceBuffer.array());
SliceY.SliceBuffer.limit(y);
input.close();
z = SliceY.SliceBuffer.getInt();
ImportantAreaManager.getInstance().load(SliceY.SliceBuffer, z);
}
} catch (Throwable var23) {
try {
input.close();
} catch (Throwable var21) {
var23.addSuppressed(var21);
}
throw var23;
}
input.close();
} catch (Throwable var24) {
try {
fis.close();
} catch (Throwable var20) {
var24.addSuppressed(var20);
}
throw var24;
}
fis.close();
} catch (FileNotFoundException var25) {
}
}
WorldGenParams.Result wgLoadResult = WorldGenParams.INSTANCE.load();
if (wgLoadResult == Result.CLIENT || wgLoadResult == Result.NOT_PRESENT && GameServer.server) {
String newSeed = ServerOptions.instance.seed.getValue();
if (GameServer.server && newSeed.isEmpty()) {
newSeed = GameServer.seed;
ServerOptions.instance.changeOption("Seed", newSeed);
}
WorldGenParams.INSTANCE.setSeedString(newSeed);
WorldGenParams.INSTANCE.setMinXCell(-250);
WorldGenParams.INSTANCE.setMaxXCell(250);
WorldGenParams.INSTANCE.setMinYCell(-250);
WorldGenParams.INSTANCE.setMaxYCell(250);
}
if (!GameServer.server || !GameServer.softReset) {
this.metaGrid.CreateStep1();
}
LuaEventManager.triggerEvent("OnPreDistributionMerge");
LuaEventManager.triggerEvent("OnDistributionMerge");
LuaEventManager.triggerEvent("OnPostDistributionMerge");
DebugType.General.println("VehiclesDB2.init() start");
VehiclesDB2.instance.init();
DebugType.General.println("VehiclesDB2.init() end");
DebugType.General.println("triggerEvent OnInitWorld");
LuaEventManager.triggerEvent("OnInitWorld");
if (!GameClient.client) {
DebugType.General.println("SandboxOptions.load() start");
SandboxOptions.instance.load();
DebugType.General.println("SandboxOptions.load() end");
}
DebugType.General.println("ItemPickerJava.Parse() start");
ItemPickerJava.Parse();
DebugType.General.println("ItemPickerJava.Parse() end");
this.hydroPowerOn = SandboxOptions.getInstance().doesPowerGridExist();
ZomboidGlobals.toLua();
ItemPickerJava.InitSandboxLootSettings();
this.survivorDescriptors.clear();
IsoSpriteManager.instance.Dispose();
if (GameClient.client && ServerOptions.instance.doLuaChecksum.getValue()) {
DebugType.General.println("client: DoLuaChecksum start");
try {
NetChecksum.comparer.beginCompare();
GameLoadingState.gameLoadingString = Translator.getText("IGUI_MP_Checksum", new Object[0]);
long start = System.currentTimeMillis();
long prevSecond = start;
while(!GameClient.checksumValid) {
if (GameWindow.serverDisconnected) {
return;
}
if (System.currentTimeMillis() > start + LUA_CHECKSUM_TIMEOUT_MS) {
DebugType.General.println("checksum: timed out waiting for the server to respond");
GameClient.connection.forceDisconnect("world-timeout-response");
GameWindow.serverDisconnected = true;
GameWindow.kickReason = Translator.getText("UI_GameLoad_TimedOut", new Object[0]);
return;
}
if (System.currentTimeMillis() > prevSecond + 1000L) {
DebugType.Moveable.println("checksum: waited one second");
prevSecond += 1000L;
}
NetChecksum.comparer.update();
if (GameClient.checksumValid) {
break;
}
Thread.sleep(100L);
}
} catch (Exception var35) {
ExceptionLogger.logException(var35);
}
DebugType.General.println("client: DoLuaChecksum end");
}
GameLoadingState.gameLoadingString = Translator.getText("IGUI_MP_LoadTileDef", new Object[0]);
IsoSpriteManager spriteManager = IsoSpriteManager.instance;
this.tileImages.clear();
DebugType.General.println("LoadTileDefinitions start");
ZomboidFileSystem zfs = ZomboidFileSystem.instance;
this.LoadTileDefinitionsPropertyStrings(spriteManager, zfs.getMediaPath("newtiledefinitions.tiles"), 1);
this.LoadTileDefinitionsPropertyStrings(spriteManager, zfs.getMediaPath("tiledefinitions_erosion.tiles"), 2);
this.LoadTileDefinitionsPropertyStrings(spriteManager, zfs.getMediaPath("tiledefinitions_overlays.tiles"), 4);
this.LoadTileDefinitionsPropertyStrings(spriteManager, zfs.getMediaPath("tiledefinitions_b42chunkcaching.tiles"), 5);
this.LoadTileDefinitionsPropertyStrings(spriteManager, zfs.getMediaPath("tiledefinitions_noiseworks.patch.tiles"), -1);
this.LoadTileDefinitionsPropertyStrings(spriteManager, zfs.getMediaPath("jumbo_trees_big.tiles"), 6);
this.LoadTileDefinitionsPropertyStrings(spriteManager, zfs.getMediaPath("jumbo_trees.tiles"), 8);
ZomboidFileSystem.instance.loadModTileDefPropertyStrings();
this.SetCustomPropertyValues();
this.GenerateTilePropertyLookupTables();
this.LoadTileDefinitions(spriteManager, zfs.getMediaPath("newtiledefinitions.tiles"), 1);
this.LoadTileDefinitions(spriteManager, zfs.getMediaPath("tiledefinitions_erosion.tiles"), 2);
this.LoadTileDefinitions(spriteManager, zfs.getMediaPath("tiledefinitions_overlays.tiles"), 4);
this.LoadTileDefinitions(spriteManager, zfs.getMediaPath("tiledefinitions_b42chunkcaching.tiles"), 5);
this.LoadTileDefinitions(spriteManager, zfs.getMediaPath("tiledefinitions_noiseworks.patch.tiles"), -1);
this.LoadTileDefinitions(spriteManager, zfs.getMediaPath("jumbo_trees_big.tiles"), 6);
this.LoadTileDefinitions(spriteManager, zfs.getMediaPath("jumbo_trees.tiles"), 8);
this.registerFakeJumboTree(spriteManager, 7);
ZomboidFileSystem.instance.loadModTileDefs();
GameLoadingState.gameLoadingString = "";
DebugType.General.println("LoadTileDefinitions end");
spriteManager.AddSprite("media/ui/missing-tile.png");
ScriptManager.instance.PostTileDefinitions();
DebugType.General.println("triggerEvent OnLoadedTileDefinitions");
LuaEventManager.triggerEvent("OnLoadedTileDefinitions", spriteManager);
this.loadedTileDefinitions();
AnimalDefinitions.getAnimalDefs();
if (GameServer.server && GameServer.softReset) {
IsoRegions.init();
BentFences.init();
WorldConverter.instance.softreset();
}
try {
WeatherFxMask.init();
} catch (Exception var19) {
ExceptionLogger.logException(var19);
}
TemplateText.Initialize();
IsoRegions.init();
BentFences.init();
ObjectRenderEffects.init();
WorldConverter.instance.convert(Core.gameSaveWorld, spriteManager);
if (!GameLoadingState.worldVersionError) {
SandboxOptions.instance.handleOldZombiesFile2();
DebugType.General.println("GameTime.init() and load() start");
GameTime.getInstance().init();
GameTime.getInstance().load();
DebugType.General.println("GameTime.init() and load() end");
ImprovedFog.init();
DebugType.General.println("ZomboidRadio.Init() start");
ZomboidRadio.getInstance().Init(savedWorldVersion);
DebugType.General.println("ZomboidRadio.Init() end");
DebugType.General.println("GlobalModData.init() start");
GlobalModData.instance.init();
DebugType.General.println("GlobalModData.init() end");
DebugType.General.println("InstanceTracker.load() start");
InstanceTracker.load();
DebugType.General.println("InstanceTracker.load() end");
if (GameServer.server && Core.getInstance().getPoisonousBerry() == null) {
Core.getInstance().initPoisonousBerry();
}
if (GameServer.server && Core.getInstance().getPoisonousMushroom() == null) {
Core.getInstance().initPoisonousMushroom();
}
DebugType.General.println("ErosionGlobals.Boot() start");
ErosionGlobals.Boot(spriteManager);
DebugType.General.println("ErosionGlobals.Boot() end");
DebugType.General.println("WorldDictionary.init() start");
WorldDictionary.init();
ScriptManager.instance.PostWorldDictionaryInit();
DebugType.General.println("WorldDictionary.init() end");
FishSchoolManager.getInstance().init();
WorldMarkers.instance.init();
DebugType.General.println("GameEntityManager.Init() start");
GameEntityManager.Init(savedWorldVersion);
DebugType.General.println("GameEntityManager.Init() end");
if (GameServer.server) {
SharedDescriptors.initSharedDescriptors();
}
DebugType.General.println("PersistentOutfits.init() start");
PersistentOutfits.instance.init();
DebugType.General.println("PersistentOutfits.init() end");
VehicleIDMap.instance.Reset();
VehicleManager.instance = new VehicleManager();
GameLoadingState.gameLoadingString = Translator.getText("IGUI_MP_InitMap", new Object[0]);
this.metaGrid.CreateStep2();
ClimateManager.getInstance().init(this.metaGrid);
SafeHouse.init();
VirtualZombieManager.instance.init();
if (!GameClient.client) {
StashSystem.init();
}
Basements.getInstance().beforeOnLoadMapZones();
LuaEventManager.triggerEvent("OnLoadMapZones");
if (!GameClient.client) {
Basements.getInstance().beforeLoadMetaGrid();
BuildingRoomsEditor.getInstance().load();
this.metaGrid.load();
Basements.getInstance().afterLoadMetaGrid();
IsoMetaGrid var10000 = this.metaGrid;
IsoMetaGrid var10002 = this.metaGrid;
Objects.requireNonNull(var10002);
var10000.load("map_zone.bin", var10002::loadZone);
this.metaGrid.loadCells("metagrid", "metacell_(-?[0-9]+)_(-?[0-9]+)\\.bin", IsoMetaCell::load);
var10000 = this.metaGrid;
var10002 = this.metaGrid;
Objects.requireNonNull(var10002);
var10000.load("map_animals.bin", var10002::loadAnimalZones);
this.metaGrid.processZones();
} else {
Basements.getInstance().beforeLoadMetaGrid();
}
DebugType.General.println("triggerEvent OnLoadedMapZones");
LuaEventManager.triggerEvent("OnLoadedMapZones");
if (GameServer.server) {
ServerMap.instance.init(this.metaGrid);
}
DebugType.General.println("ItemConfigurator.Preprocess() start");
ItemConfigurator.Preprocess();
DebugType.General.println("ItemConfigurator.Preprocess() end");
boolean isPlayerAlive = false;
if (GameClient.client) {
if (ClientPlayerDB.getInstance().clientLoadNetworkPlayer() && ClientPlayerDB.getInstance().isAliveMainNetworkPlayer()) {
isPlayerAlive = true;
}
} else {
isPlayerAlive = PlayerDBHelper.isPlayerAlive(ZomboidFileSystem.instance.getCurrentSaveDir(), 1);
}
if (GameServer.server) {
ServerPlayerDB.setAllow(true);
}
if (!GameClient.client && !GameServer.server) {
PlayerDB.setAllow(true);
}
boolean bLoadCharacter;
if (isPlayerAlive) {
bLoadCharacter = true;
if (!this.LoadPlayerForInfo()) {
return;
}
worldX = IsoChunkMap.SWorldX[IsoPlayer.getPlayerIndex()];
worldY = IsoChunkMap.SWorldY[IsoPlayer.getPlayerIndex()];
} else {
bLoadCharacter = false;
if (GameClient.client && !ServerOptions.instance.spawnPoint.getValue().isEmpty()) {
String[] spawnPoint = ServerOptions.instance.spawnPoint.getValue().split(",");
if (spawnPoint.length == 3) {
try {
IsoChunkMap.mpWorldXa = Integer.parseInt(spawnPoint[0].trim());
IsoChunkMap.mpWorldYa = Integer.parseInt(spawnPoint[1].trim());
IsoChunkMap.mpWorldZa = Integer.parseInt(spawnPoint[2].trim());
} catch (NumberFormatException var18) {
DebugType.Moveable.println("ERROR: SpawnPoint must be x,y,z, got \"" + ServerOptions.instance.spawnPoint.getValue() + "\"");
IsoChunkMap.mpWorldXa = 0;
IsoChunkMap.mpWorldYa = 0;
IsoChunkMap.mpWorldZa = 0;
}
} else {
DebugType.Moveable.println("ERROR: SpawnPoint must be x,y,z, got \"" + ServerOptions.instance.spawnPoint.getValue() + "\"");
}
}
if (!GameClient.client || IsoChunkMap.mpWorldXa == 0 && IsoChunkMap.mpWorldYa == 0) {
IsoChunkMap.worldXa = this.getLuaPosX();
IsoChunkMap.worldYa = this.getLuaPosY();
IsoChunkMap.worldZa = this.getLuaPosZ();
if (GameClient.client && ServerOptions.instance.safehouseAllowRespawn.getValue()) {
for(z = 0; z < SafeHouse.getSafehouseList().size(); ++z) {
SafeHouse safe = (SafeHouse)SafeHouse.getSafehouseList().get(z);
if (safe.getPlayers().contains(GameClient.username) && safe.isRespawnInSafehouse(GameClient.username)) {
IsoChunkMap.worldXa = safe.getX() + safe.getH() / 2;
IsoChunkMap.worldYa = safe.getY() + safe.getW() / 2;
IsoChunkMap.worldZa = 0;
}
}
}
worldX = PZMath.fastfloor((float)IsoChunkMap.worldXa / 8.0F);
worldY = PZMath.fastfloor((float)IsoChunkMap.worldYa / 8.0F);
} else {
IsoChunkMap.worldXa = IsoChunkMap.mpWorldXa;
IsoChunkMap.worldYa = IsoChunkMap.mpWorldYa;
IsoChunkMap.worldZa = IsoChunkMap.mpWorldZa;
worldX = PZMath.fastfloor((float)IsoChunkMap.worldXa / 8.0F);
worldY = PZMath.fastfloor((float)IsoChunkMap.worldYa / 8.0F);
}
}
KahluaTable selectedDebugScenario = (KahluaTable)LuaManager.env.rawget("selectedDebugScenario");
int xa;
int ya;
int za;
if (selectedDebugScenario != null) {
KahluaTable loc = (KahluaTable)selectedDebugScenario.rawget("startLoc");
xa = ((Double)loc.rawget("x")).intValue();
ya = ((Double)loc.rawget("y")).intValue();
za = ((Double)loc.rawget("z")).intValue();
IsoChunkMap.worldXa = xa;
IsoChunkMap.worldYa = ya;
IsoChunkMap.worldZa = za;
worldX = PZMath.fastfloor((float)IsoChunkMap.worldXa / 8.0F);
worldY = PZMath.fastfloor((float)IsoChunkMap.worldYa / 8.0F);
}
DebugType.General.println("MapCollisionData.init() start");
MapCollisionData.instance.init(instance.getMetaGrid());
DebugType.General.println("MapCollisionData.init() end");
DebugType.General.println("AnimalPopulationManager.init() start");
AnimalPopulationManager.getInstance().init(this.getMetaGrid());
DebugType.General.println("AnimalPopulationManager.init() end");
DebugType.General.println("ZombiePopulationManager.init() start");
ZombiePopulationManager.instance.init(instance.getMetaGrid());
DebugType.General.println("ZombiePopulationManager.init() end");
DebugType.General.println("Pathfind init() start");
PathfindNative.useNativeCode = DebugOptions.instance.pathfindUseNativeCode.getValue();
if (PathfindNative.useNativeCode) {
PathfindNative.instance.init(instance.getMetaGrid());
} else {
PolygonalMap2.instance.init(instance.getMetaGrid());
}
DebugType.General.println("Pathfind init() end");
GlobalObjectLookup.init(instance.getMetaGrid());
if (!GameServer.server) {
SpawnPoints.instance.initSinglePlayer(this.metaGrid);
}
DebugType.General.println("WorldStreamer.create() start");
WorldStreamer.instance.create();
DebugType.General.println("WorldStreamer.create() end");
DebugType.General.println("CellLoader.LoadCellBinaryChunk start");
this.currentCell = CellLoader.LoadCellBinaryChunk(spriteManager, worldX, worldY);
DebugType.General.println("CellLoader.LoadCellBinaryChunk start");
ClimateManager.getInstance().postCellLoadSetSnow();
GameLoadingState.gameLoadingString = Translator.getText("IGUI_MP_LoadWorld", new Object[0]);
MapCollisionData.instance.start();
if (!GameServer.server) {
DebugType.General.println("MapItem.LoadWorldMap() start");
MapItem.LoadWorldMap();
DebugType.General.println("MapItem.LoadWorldMap() start");
}
if (GameClient.client) {
WorldMapClient.instance.worldMapLoaded();
}
if (GameServer.server) {
HiddenAuthors.read();
}
DebugType.General.println("WorldStreamer.isBusy() loop start");
while(WorldStreamer.instance.isBusy()) {
try {
Thread.sleep(100L);
} catch (InterruptedException var17) {
}
}
DebugType.General.println("WorldStreamer.isBusy() loop end");
ArrayList loaded = new ArrayList(IsoChunk.loadGridSquare);
Iterator var55 = loaded.iterator();
while(var55.hasNext()) {
IsoChunk chunk = (IsoChunk)var55.next();
this.currentCell.chunkMap[0].setChunkDirect(chunk, false);
}
this.currentCell.chunkMap[0].calculateZExtentsForChunkMap();
IsoChunk.doServerRequests = true;
IsoGridSquare sq;
if (bLoadCharacter && SystemDisabler.doPlayerCreation) {
this.currentCell.LoadPlayer(savedWorldVersion);
if (GameClient.client) {
IsoPlayer.getInstance().setUsername(GameClient.username);
}
ZomboidRadio.getInstance().getRecordedMedia().handleLegacyListenedLines(IsoPlayer.getInstance());
} else {
IsoGridSquare sq;
if (GameClient.client) {
ZomboidRadio.getInstance().getRecordedMedia().handleLegacyListenedLines((IsoPlayer)null);
LuaManager.thread.debugOwnerThread = GameWindow.gameThread;
LuaManager.debugthread.debugOwnerThread = GameWindow.gameThread;
GameClient.sendCreatePlayer((byte)0);
DebugType.General.println("Waiting for the server to send player data");
long currentTime = System.currentTimeMillis();
boolean playerLoaded = false;
label482:
while(true) {
while(true) {
try {
if (IsoPlayer.players[0] != null) {
playerLoaded = true;
}
if (System.currentTimeMillis() - currentTime > 30000L || playerLoaded) {
break label482;
}
Thread.sleep(100L);
} catch (InterruptedException var33) {
}
}
}
LuaManager.thread.debugOwnerThread = GameLoadingState.loader;
LuaManager.debugthread.debugOwnerThread = GameLoadingState.loader;
if (!playerLoaded) {
throw new RuntimeException("Timed out waiting for the server to send player data");
}
DebugType.General.println("Player data received from the server");
IsoPlayer playerObj = IsoPlayer.players[0];
IsoChunkMap.worldXa = playerObj.getXi();
IsoChunkMap.worldYa = playerObj.getYi();
IsoChunkMap.worldZa = playerObj.getZi();
sq = this.currentCell.getGridSquare(IsoChunkMap.worldXa, IsoChunkMap.worldYa, IsoChunkMap.worldZa);
if (sq != null && sq.getRoom() != null) {
if (SandboxOptions.instance.lore.playerSpawnZombieRemoval.getValue() < 4) {
sq.getRoom().def.setExplored(true);
} else if (SandboxOptions.instance.lore.playerSpawnZombieRemoval.getValue() < 3) {
sq.getRoom().building.setAllExplored(true, sq.getRoom());
this.setBasementAllExplored(sq.getRoom().building);
}
if (!GameServer.server && !GameClient.client) {
ZombiePopulationManager.instance.playerSpawnedAt(sq.getX(), sq.getY(), sq.getZ());
}
}
if (!GameClient.client) {
Core.getInstance().initPoisonousBerry();
Core.getInstance().initPoisonousMushroom();
}
LuaEventManager.triggerEvent("OnNewGame", playerObj, sq);
} else {
ZomboidRadio.getInstance().getRecordedMedia().handleLegacyListenedLines((IsoPlayer)null);
if (IsoPlayer.numPlayers == 0) {
IsoPlayer.numPlayers = 1;
}
xa = IsoChunkMap.worldXa;
ya = IsoChunkMap.worldYa;
za = IsoChunkMap.worldZa;
if (GameClient.client && !ServerOptions.instance.spawnPoint.getValue().isEmpty()) {
String[] spawnPoint = ServerOptions.instance.spawnPoint.getValue().split(",");
if (spawnPoint.length != 3) {
DebugType.Moveable.println("ERROR: SpawnPoint must be x,y,z, got \"" + ServerOptions.instance.spawnPoint.getValue() + "\"");
} else {
try {
int yAb = Integer.parseInt(spawnPoint[1].trim());
int xAb = Integer.parseInt(spawnPoint[0].trim());
int zAb = Integer.parseInt(spawnPoint[2].trim());
if (GameClient.client && ServerOptions.instance.safehouseAllowRespawn.getValue()) {
for(int i = 0; i < SafeHouse.getSafehouseList().size(); ++i) {
SafeHouse safe = (SafeHouse)SafeHouse.getSafehouseList().get(i);
if (safe.getPlayers().contains(GameClient.username) && safe.isRespawnInSafehouse(GameClient.username)) {
xAb = safe.getX() + safe.getH() / 2;
yAb = safe.getY() + safe.getW() / 2;
zAb = 0;
}
}
}
if (this.currentCell.getGridSquare(xAb, yAb, zAb) != null) {
xa = xAb;
ya = yAb;
za = zAb;
}
} catch (NumberFormatException var34) {
DebugType.Moveable.println("ERROR: SpawnPoint must be x,y,z, got \"" + ServerOptions.instance.spawnPoint.getValue() + "\"");
}
}
}
sq = this.currentCell.getGridSquare(xa, ya, za);
if (SystemDisabler.doPlayerCreation && !GameServer.server) {
if (sq != null && sq.isFree(false) && sq.getRoom() != null) {
sq = sq;
sq = sq.getRoom().getFreeTile();
if (sq == null) {
sq = sq;
}
}
IsoPlayer player = null;
if (this.getLuaPlayerDesc() != null) {
if (GameClient.client && ServerOptions.instance.safehouseAllowRespawn.getValue()) {
sq = this.currentCell.getGridSquare(IsoChunkMap.worldXa, IsoChunkMap.worldYa, IsoChunkMap.worldZa);
if (sq != null && sq.isFree(false) && sq.getRoom() != null) {
IsoGridSquare last = sq;
sq = sq.getRoom().getFreeTile();
if (sq == null) {
sq = last;
}
}
}
if (sq == null) {
throw new RuntimeException("can't create player at x,y,z=" + xa + "," + ya + "," + za + " because the square is null");
}
WorldSimulation.instance.create();
player = new IsoPlayer(instance.currentCell, this.getLuaPlayerDesc(), sq.getX(), sq.getY(), sq.getZ());
if (GameClient.client) {
player.setUsername(GameClient.username);
}
player.setDir(IsoDirections.SE);
player.sqlId = 1;
IsoPlayer.players[0] = player;
IsoPlayer.setInstance(player);
IsoCamera.setCameraCharacter(player);
}
IsoPlayer playerObj = IsoPlayer.getInstance();
playerObj.applyTraits(this.getLuaTraits());
CharacterProfessionDefinition characterProfessionDefinition = CharacterProfessionDefinition.getCharacterProfessionDefinition(playerObj.getDescriptor().getCharacterProfession());
if (characterProfessionDefinition.hasGrantedRecipes()) {
playerObj.getKnownRecipes().addAll(characterProfessionDefinition.getGrantedRecipes());
}
Iterator var66 = this.getLuaTraits().iterator();
while(var66.hasNext()) {
CharacterTrait characterTrait = (CharacterTrait)var66.next();
CharacterTraitDefinition characterTraitDefinition = CharacterTraitDefinition.getCharacterTraitDefinition(characterTrait);
if (characterTraitDefinition.hasGrantedRecipes()) {
playerObj.getKnownRecipes().addAll(characterTraitDefinition.getGrantedRecipes());
}
}
if (sq != null && sq.getRoom() != null) {
sq.getRoom().def.setExplored(true);
sq.getRoom().building.setAllExplored(true);
this.setBasementAllExplored(sq.getRoom().getBuilding());
if (!GameServer.server && !GameClient.client) {
ZombiePopulationManager.instance.playerSpawnedAt(sq.getX(), sq.getY(), sq.getZ());
}
}
if (!GameClient.client) {
Core.getInstance().initPoisonousBerry();
Core.getInstance().initPoisonousMushroom();
}
LuaEventManager.triggerEvent("OnNewGame", player, sq);
}
}
}
if (PlayerDB.isAllow()) {
PlayerDB.getInstance().canSavePlayers = true;
}
TutorialManager.instance.activeControlZombies = false;
ReanimatedPlayers.instance.loadReanimatedPlayers();
if (IsoPlayer.getInstance() != null) {
if (GameClient.client) {
x = PZMath.fastfloor(IsoPlayer.getInstance().getX());
y = PZMath.fastfloor(IsoPlayer.getInstance().getY());
z = PZMath.fastfloor(IsoPlayer.getInstance().getZ());
while(z > 0) {
sq = this.currentCell.getGridSquare(x, y, PZMath.fastfloor((float)z));
if (sq != null && sq.TreatAsSolidFloor()) {
break;
}
--z;
IsoPlayer.getInstance().setZ((float)z);
}
}
ScriptManager.instance.checkAutoLearn(IsoPlayer.getInstance());
ScriptManager.instance.checkMetaRecipes(IsoPlayer.getInstance());
ScriptManager.instance.VerifyAllCraftRecipesAreLearnable();
IsoPlayer.getInstance().setCurrentSquareFromPosition();
}
this.PopulateCellWithSurvivors();
if (IsoPlayer.players[0] != null && !this.currentCell.getObjectList().contains(IsoPlayer.players[0])) {
this.currentCell.getObjectList().add(IsoPlayer.players[0]);
}
LightingThread.instance.create();
DebugType.General.println("MetaTracker.load() start");
MetaTracker.load();
DebugType.General.println("MetaTracker.load() end");
StatisticsManager.getInstance().load();
GameLoadingState.gameLoadingString = "";
AnimationPlayerRecorder.initMessaging();
WorldDictionary.onWorldLoaded();
this.currentCell.initWeatherFx();
if (ScriptManager.instance.hasLoadErrors(!Core.debug) || SpriteConfigManager.HasLoadErrors()) {
DebugType var69 = DebugType.Moveable;
boolean var10001 = ScriptManager.instance.hasLoadErrors(!Core.debug);
var69.println("script error = " + var10001 + ", sprite error = " + SpriteConfigManager.HasLoadErrors());
throw new WorldDictionaryException("World loading could not proceed, there are script load errors. (Actual error may be printed earlier in log)");
}
}
}
private void setBasementAllExplored(IsoBuilding spawnBuilding) {
BuildingDef spawnBuildingDef = spawnBuilding.getDef();
ArrayList buildingDefs = new ArrayList();
instance.metaGrid.getBuildingsIntersecting(spawnBuildingDef.getX(), spawnBuildingDef.getY(), spawnBuildingDef.getW(), spawnBuildingDef.getH(), buildingDefs);
for(int i = 0; i < buildingDefs.size(); ++i) {
BuildingDef candidateDef = (BuildingDef)buildingDefs.get(i);
if (candidateDef.getMinLevel() < 0) {
candidateDef.setAllExplored(true);
}
}
}
int readWorldVersion() {
File file;
FileInputStream fis;
DataInputStream dis;
if (GameServer.server) {
file = ZomboidFileSystem.instance.getFileInCurrentSave("map_t.bin");
try {
fis = new FileInputStream(file);
label107: {
int var8;
try {
label118: {
dis = new DataInputStream(fis);
try {
byte b1 = dis.readByte();
byte b2 = dis.readByte();
byte b3 = dis.readByte();
byte b4 = dis.readByte();
if (b1 == 71 && b2 == 77 && b3 == 84 && b4 == 77) {
var8 = dis.readInt();
break label118;
}
} catch (Throwable var17) {
try {
dis.close();
} catch (Throwable var12) {
var17.addSuppressed(var12);
}
throw var17;
}
dis.close();
break label107;
}
dis.close();
} catch (Throwable var18) {
try {
fis.close();
} catch (Throwable var11) {
var18.addSuppressed(var11);
}
throw var18;
}
fis.close();
return var8;
}
fis.close();
} catch (FileNotFoundException var19) {
} catch (IOException var20) {
ExceptionLogger.logException(var20);
}
return -1;
} else {
file = ZomboidFileSystem.instance.getFileInCurrentSave("map_ver.bin");
try {
fis = new FileInputStream(file);
int var4;
try {
dis = new DataInputStream(fis);
try {
var4 = dis.readInt();
} catch (Throwable var13) {
try {
dis.close();
} catch (Throwable var10) {
var13.addSuppressed(var10);
}
throw var13;
}
dis.close();
} catch (Throwable var14) {
try {
fis.close();
} catch (Throwable var9) {
var14.addSuppressed(var9);
}
throw var14;
}
fis.close();
return var4;
} catch (FileNotFoundException var15) {
} catch (IOException var16) {
ExceptionLogger.logException(var16);
}
return -1;
}
}
public List getLuaTraits() {
return this.luatraits;
}
public void addLuaTrait(CharacterTrait trait) {
this.getLuaTraits().add(trait);
}
public SurvivorDesc getLuaPlayerDesc() {
return this.luaDesc;
}
public void setLuaPlayerDesc(SurvivorDesc desc) {
this.luaDesc = desc;
}
public void KillCell() {
this.helicopter.deactivate();
CollisionManager.instance.contactMap.clear();
ObjectIDManager.getInstance().clear();
FliesSound.instance.reset();
CorpseCount.instance.reset();
IsoObjectPicker.Instance.Init();
IsoChunkMap.SharedChunks.clear();
SoundManager.instance.StopMusic();
WorldSoundManager.instance.KillCell();
ZombieGroupManager.instance.Reset();
this.currentCell.Dispose();
IsoSpriteManager.instance.Dispose();
this.currentCell = null;
IsoLot.Dispose();
IsoGameCharacter.getSurvivorMap().clear();
IsoPlayer.getInstance().setCurrent((IsoGridSquare)null);
IsoPlayer.getInstance().setLast((IsoGridSquare)null);
IsoPlayer.getInstance().square = null;
RainManager.reset();
IsoFireManager.Reset();
ObjectAmbientEmitters.Reset();
AnimalVocalsManager.Reset();
ZombieVocalsManager.Reset();
IsoWaterFlow.Reset();
BuildingRoomsEditor.Reset();
this.metaGrid.Dispose();
this.biomeMap.Dispose();
IsoBuilding.idCount = 0;
instance = new IsoWorld();
}
public void setDrawWorld(boolean b) {
this.drawWorld = b;
}
public void sceneCullZombies() {
this.zombieWithModel.clear();
this.zombieWithoutModel.clear();
int c;
for(c = 0; c < this.currentCell.getZombieList().size(); ++c) {
IsoZombie z = (IsoZombie)this.currentCell.getZombieList().get(c);
boolean withModel = false;
for(int pn = 0; pn < IsoPlayer.numPlayers; ++pn) {
IsoPlayer player = IsoPlayer.players[pn];
if (player != null && z.current != null) {
float screenX = (float)z.getScreenProperX(pn);
float screenY = (float)z.getScreenProperY(pn);
if (!(screenX < -100.0F) && !(screenY < -100.0F) && !(screenX > (float)(Core.getInstance().getOffscreenWidth(pn) + 100)) && !(screenY > (float)(Core.getInstance().getOffscreenHeight(pn) + 100)) && (z.getAlpha(pn) != 0.0F && z.legsSprite.def.alpha != 0.0F || z.current.isCouldSee(pn) || z.couldSeeHeadSquare(player))) {
withModel = true;
break;
}
}
}
if (withModel && z.isCurrentState(FakeDeadZombieState.instance())) {
withModel = false;
}
if (withModel) {
this.zombieWithModel.add(z);
} else {
this.zombieWithoutModel.add(z);
}
}
this.timSort.doSort(this.zombieWithModel.getElements(), compScoreToPlayer, 0, this.zombieWithModel.size());
c = 0;
int count = 0;
int tcount = 0;
int tcountMax = true;
PerformanceSettings.animationSkip = 0;
int n;
IsoZombie z;
for(n = 0; n < this.zombieWithModel.size(); ++n) {
z = (IsoZombie)this.zombieWithModel.get(n);
if (tcount < 510) {
if (!z.ghost) {
++count;
++tcount;
z.setSceneCulled(false);
if (z.legsSprite != null && z.legsSprite.modelSlot != null) {
if (count > PerformanceSettings.zombieAnimationSpeedFalloffCount) {
++c;
count = 0;
}
if (tcount < PerformanceSettings.zombieBonusFullspeedFalloff) {
z.legsSprite.modelSlot.model.setInstanceSkip(count / PerformanceSettings.zombieBonusFullspeedFalloff);
count = 0;
} else {
z.legsSprite.modelSlot.model.setInstanceSkip(c + PerformanceSettings.animationSkip);
}
if (z.legsSprite.modelSlot.model.animPlayer != null) {
if (tcount >= PerformanceSettings.numberZombiesBlended) {
z.legsSprite.modelSlot.model.animPlayer.doBlending = false;
} else {
z.legsSprite.modelSlot.model.animPlayer.doBlending = !z.isAlphaAndTargetZero(0) || !z.isAlphaAndTargetZero(1) || !z.isAlphaAndTargetZero(2) || !z.isAlphaAndTargetZero(3);
}
}
}
}
} else {
z.setSceneCulled(true);
if (z.hasAnimationPlayer()) {
z.getAnimationPlayer().doBlending = false;
}
}
}
for(n = 0; n < this.zombieWithoutModel.size(); ++n) {
z = (IsoZombie)this.zombieWithoutModel.get(n);
if (z.hasActiveModel()) {
z.setSceneCulled(true);
}
if (z.hasAnimationPlayer()) {
z.getAnimationPlayer().doBlending = false;
}
}
}
public void sceneCullAnimals() {
this.animalWithModel.clear();
this.animalWithoutModel.clear();
Iterator var1 = this.currentCell.getObjectList().iterator();
while(true) {
IsoMovingObject mo;
do {
if (!var1.hasNext()) {
var1 = this.animalWithModel.iterator();
IsoAnimal animal;
while(var1.hasNext()) {
animal = (IsoAnimal)var1.next();
animal.setSceneCulled(false);
if (animal.hasAnimationPlayer()) {
animal.getAnimationPlayer().doBlending = true;
}
}
var1 = this.animalWithoutModel.iterator();
while(var1.hasNext()) {
animal = (IsoAnimal)var1.next();
if (animal.hasActiveModel()) {
animal.setSceneCulled(true);
}
if (animal.hasAnimationPlayer()) {
animal.getAnimationPlayer().doBlending = false;
}
}
return;
}
mo = (IsoMovingObject)var1.next();
} while(!(mo instanceof IsoAnimal));
IsoAnimal animal = (IsoAnimal)mo;
boolean withModel = false;
for(int pn = 0; pn < IsoPlayer.numPlayers; ++pn) {
IsoPlayer player = IsoPlayer.players[pn];
if (player != null && animal.current != null) {
float screenX = (float)((int)(IsoUtils.XToScreen(animal.getX(), animal.getY(), animal.getZ(), 0) - IsoCamera.cameras[pn].getOffX()));
float screenY = (float)((int)(IsoUtils.YToScreen(animal.getX(), animal.getY(), animal.getZ(), 0) - IsoCamera.cameras[pn].getOffY()));
if (!(screenX < -100.0F) && !(screenY < -100.0F) && !(screenX > (float)(Core.getInstance().getOffscreenWidth(pn) + 100)) && !(screenY > (float)(Core.getInstance().getOffscreenHeight(pn) + 100)) && (animal.getAlpha(pn) != 0.0F && animal.legsSprite.def.alpha != 0.0F || animal.current.isCouldSee(pn))) {
withModel = true;
break;
}
}
}
if (withModel && animal.isCurrentState(FakeDeadZombieState.instance())) {
withModel = false;
}
if (withModel) {
this.animalWithModel.add(animal);
} else {
this.animalWithoutModel.add(animal);
}
}
}
public void render() {
AbstractPerformanceProfileProbe var1 = IsoWorld.s_performance.isoWorldRender.profile();
try {
this.renderInternal();
} catch (Throwable var5) {
if (var1 != null) {
try {
var1.close();
} catch (Throwable var4) {
var5.addSuppressed(var4);
}
}
throw var5;
}
if (var1 != null) {
var1.close();
}
}
private void renderInternal() {
if (this.drawWorld) {
IsoGameCharacter isoGameCharacter = IsoCamera.getCameraCharacter();
if (isoGameCharacter != null) {
SpriteRenderer.instance.doCoreIntParam(0, isoGameCharacter.getX());
SpriteRenderer.instance.doCoreIntParam(1, isoGameCharacter.getY());
SpriteRenderer.instance.doCoreIntParam(2, IsoCamera.frameState.camCharacterZ);
GameProfiler profiler = GameProfiler.getInstance();
GameProfiler.ProfileArea var3;
try {
var3 = profiler.profile("Cull");
try {
this.sceneCullZombies();
this.sceneCullAnimals();
} catch (Throwable var16) {
if (var3 != null) {
try {
var3.close();
} catch (Throwable var10) {
var16.addSuppressed(var10);
}
}
throw var16;
}
if (var3 != null) {
var3.close();
}
} catch (Throwable var17) {
ExceptionLogger.logException(var17);
}
try {
WeatherFxMask.initMask();
DeadBodyAtlas.instance.render();
WorldItemAtlas.instance.render();
this.currentCell.render();
Gizmos.getInstance().render(IsoCamera.frameState.playerIndex);
this.DrawIsoCursorHelper();
DeadBodyAtlas.instance.renderDebug();
var3 = profiler.profile("renderPathfinding");
try {
this.renderPathfinding();
} catch (Throwable var14) {
if (var3 != null) {
try {
var3.close();
} catch (Throwable var9) {
var14.addSuppressed(var9);
}
}
throw var14;
}
if (var3 != null) {
var3.close();
}
WorldSoundManager.instance.render();
WorldFlares.debugRender();
WorldMarkers.instance.debugRender();
ObjectAmbientEmitters.getInstance().render();
var3 = profiler.profile("renderVocals");
try {
this.renderVocals();
} catch (Throwable var13) {
if (var3 != null) {
try {
var3.close();
} catch (Throwable var8) {
var13.addSuppressed(var8);
}
}
throw var13;
}
if (var3 != null) {
var3.close();
}
var3 = profiler.profile("renderWeatherFX");
try {
this.renderWeatherFX();
} catch (Throwable var12) {
if (var3 != null) {
try {
var3.close();
} catch (Throwable var7) {
var12.addSuppressed(var7);
}
}
throw var12;
}
if (var3 != null) {
var3.close();
}
if (PerformanceSettings.fboRenderChunk) {
FBORenderAreaHighlights.getInstance().render();
BuildingRoomsEditor.getInstance().renderMain();
}
ParameterInside.renderDebug();
LineDrawer.render();
if (GameClient.client) {
ClientServerMap.render(IsoCamera.frameState.playerIndex);
PassengerMap.render(IsoCamera.frameState.playerIndex);
}
var3 = profiler.profile("Skybox");
try {
SkyBox.getInstance().render();
} catch (Throwable var11) {
if (var3 != null) {
try {
var3.close();
} catch (Throwable var6) {
var11.addSuppressed(var6);
}
}
throw var11;
}
if (var3 != null) {
var3.close();
}
} catch (Throwable var15) {
ExceptionLogger.logException(var15);
}
}
}
}
private void renderPathfinding() {
if (PathfindNative.useNativeCode) {
PathfindNative.instance.render();
PathfindNativeRenderer.instance.render();
} else {
PolygonalMap2.instance.render();
}
BorderFinderRenderer.instance.render();
}
private void renderVocals() {
AnimalVocalsManager.instance.render();
ZombieVocalsManager.instance.render();
}
private void renderWeatherFX() {
this.getCell().getWeatherFX().getDrawer(IsoWeatherFX.cloudId).startFrame();
this.getCell().getWeatherFX().getDrawer(IsoWeatherFX.fogId).startFrame();
this.getCell().getWeatherFX().getDrawer(IsoWeatherFX.snowId).startFrame();
this.getCell().getWeatherFX().getDrawer(IsoWeatherFX.rainId).startFrame();
WeatherFxMask.renderFxMask(IsoCamera.frameState.playerIndex);
}
public void DrawPlayerCone() {
int playerIndex = IsoCamera.frameState.playerIndex;
SpriteRenderer.instance.pushIsoView(IsoPlayer.getInstance().getX(), IsoPlayer.getInstance().getY(), IsoPlayer.getInstance().getZ(), (float)Math.toRadians(180.0), false);
IsoPlayer player = IsoPlayer.getInstance();
float cone = 1.0F + LightingJNI.calculateVisionCone(player);
Vector2 lookVector = player.getLookVector(this.coneTempo1);
BaseVehicle vehicle = player.getVehicle();
if (vehicle != null && !player.isAiming() && !player.isLookingWhileInVehicle() && vehicle.isDriver(player) && vehicle.getCurrentSpeedKmHour() < -1.0F) {
lookVector.rotate(3.1415927F);
}
if (cone < 0.0F) {
cone = Math.abs(cone) + 1.0F;
}
cone = (float)((double)cone * 1.5707963267948966);
this.coneTempo2.x = lookVector.x;
this.coneTempo2.y = lookVector.y;
this.coneTempo3.x = lookVector.x;
this.coneTempo3.y = lookVector.y;
this.coneTempo2.rotate(-cone);
this.coneTempo3.rotate(cone);
float offscreen1x = this.coneTempo2.x * 1000.0F;
float offscreen1y = this.coneTempo2.y * 1000.0F;
float offscreen2x = offscreen1x + -lookVector.x * 1000.0F;
float offscreen2y = offscreen1y + -lookVector.y * 1000.0F;
float offscreen3x = -lookVector.x * 1000.0F;
float offscreen3y = -lookVector.y * 1000.0F;
IndieGL.disableDepthTest();
IndieGL.disableScissorTest();
SpriteRenderer.instance.glBuffer(8, 0);
if (ViewConeTextureFBO.instance.getTexture() != null) {
SpriteRenderer.instance.glViewport(0, 0, ViewConeTextureFBO.instance.getTexture().getWidth(), ViewConeTextureFBO.instance.getTexture().getHeight());
}
IndieGL.StartShader(0);
SpriteRenderer.instance.renderPoly(0.0F, 0.0F, offscreen1x, offscreen1y, offscreen2x, offscreen2y, offscreen3x, offscreen3y, 0.0F, 0.0F, 0.0F, 0.5F);
IndieGL.EndShader();
offscreen1x = this.coneTempo3.x * 1000.0F;
offscreen1y = this.coneTempo3.y * 1000.0F;
offscreen2x = offscreen1x + -lookVector.x * 1000.0F;
offscreen2y = offscreen1y + -lookVector.y * 1000.0F;
offscreen3x = -lookVector.x * 1000.0F;
offscreen3y = -lookVector.y * 1000.0F;
SpriteRenderer.instance.renderPoly(offscreen3x, offscreen3y, offscreen2x, offscreen2y, offscreen1x, offscreen1y, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.5F);
SpriteRenderer.instance.glBuffer(9, 0);
SpriteRenderer.instance.glViewport(IsoCamera.getScreenLeft(playerIndex), IsoCamera.getScreenTop(playerIndex), IsoCamera.getScreenWidth(playerIndex), IsoCamera.getScreenHeight(playerIndex));
SpriteRenderer.instance.popIsoView();
IndieGL.enableScissorTest();
}
public void DrawPlayerCone2() {
IndieGL.glDepthMask(false);
IndieGL.glBlendFunc(770, 771);
if (SceneShaderStore.blurShader != null) {
SceneShaderStore.blurShader.setTexture(ViewConeTextureFBO.instance.getTexture());
}
if (SceneShaderStore.blurShader != null) {
IndieGL.StartShader(SceneShaderStore.blurShader, IsoPlayer.getPlayerIndex());
}
SpriteRenderer.instance.render(ViewConeTextureFBO.instance.getTexture(), 0.0F, (float)Core.getInstance().getOffscreenHeight(IsoPlayer.getPlayerIndex()), (float)Core.getInstance().getOffscreenWidth(IsoPlayer.getPlayerIndex()), (float)(-Core.getInstance().getOffscreenHeight(IsoPlayer.getPlayerIndex())), 1.0F, 1.0F, 1.0F, 1.0F, (Consumer)null);
if (SceneShaderStore.blurShader != null) {
IndieGL.EndShader();
}
IndieGL.glDepthMask(true);
}
private void DrawIsoCursorHelper() {
if (Core.getInstance().getOffscreenBuffer() == null) {
IsoPlayer player = IsoPlayer.getInstance();
if (player != null && !player.isDead() && player.isAiming() && player.playerIndex == 0 && player.getJoypadBind() == -1) {
if (!GameTime.isGamePaused()) {
float alpha = 0.05F;
switch (Core.getInstance().getIsoCursorVisibility()) {
case 0:
return;
case 1:
alpha = 0.05F;
break;
case 2:
alpha = 0.1F;
break;
case 3:
alpha = 0.15F;
break;
case 4:
alpha = 0.3F;
break;
case 5:
alpha = 0.5F;
break;
case 6:
alpha = 0.75F;
}
if (Core.getInstance().isFlashIsoCursor()) {
if (this.flashIsoCursorInc) {
this.flashIsoCursorA += 0.1F;
if (this.flashIsoCursorA >= 1.0F) {
this.flashIsoCursorInc = false;
}
} else {
this.flashIsoCursorA -= 0.1F;
if (this.flashIsoCursorA <= 0.0F) {
this.flashIsoCursorInc = true;
}
}
alpha = this.flashIsoCursorA;
}
Texture t = Texture.getSharedTexture("media/ui/isocursor.png");
int width = (int)((float)(t.getWidth() * Core.tileScale) / 2.0F);
int height = (int)((float)(t.getHeight() * Core.tileScale) / 2.0F);
SpriteRenderer.instance.setDoAdditive(true);
SpriteRenderer.instance.renderi(t, Mouse.getX() - width / 2, Mouse.getY() - height / 2, width, height, alpha, alpha, alpha, alpha, (Consumer)null);
SpriteRenderer.instance.setDoAdditive(false);
}
}
}
}
private void updateWorld() {
this.currentCell.update();
IsoRegions.update();
HaloTextHelper.update();
CollisionManager.instance.ResolveContacts();
if (DebugOptions.instance.threadAnimation.getValue()) {
MovingObjectUpdateScheduler var10000 = MovingObjectUpdateScheduler.instance;
Objects.requireNonNull(var10000);
animationThread = CompletableFuture.runAsync(var10000::postupdate);
} else {
GameProfiler.ProfileArea var1 = GameProfiler.getInstance().profile("Animation");
try {
MovingObjectUpdateScheduler.instance.postupdate();
} catch (Throwable var5) {
if (var1 != null) {
try {
var1.close();
} catch (Throwable var4) {
var5.addSuppressed(var4);
}
}
throw var5;
}
if (var1 != null) {
var1.close();
}
}
}
public void FinishAnimation() {
if (animationThread != null) {
GameProfiler.ProfileArea var1 = GameProfiler.getInstance().profile("Wait Animation");
try {
animationThread.join();
} catch (Throwable var5) {
if (var1 != null) {
try {
var1.close();
} catch (Throwable var4) {
var5.addSuppressed(var4);
}
}
throw var5;
}
if (var1 != null) {
var1.close();
}
animationThread = null;
}
}
public void update() {
AbstractPerformanceProfileProbe var1 = IsoWorld.s_performance.isoWorldUpdate.profile();
try {
this.updateInternal();
} catch (Throwable var6) {
if (var1 != null) {
try {
var1.close();
} catch (Throwable var4) {
var6.addSuppressed(var4);
}
}
throw var6;
}
if (var1 != null) {
var1.close();
}
GameProfiler.ProfileArea var8 = GameProfiler.getInstance().profile("Update DZ");
try {
DesignationZone.update();
} catch (Throwable var7) {
if (var8 != null) {
try {
var8.close();
} catch (Throwable var5) {
var7.addSuppressed(var5);
}
}
throw var7;
}
if (var8 != null) {
var8.close();
}
}
private void updateInternal() {
++this.frameNo;
if (GameServer.server) {
try {
VehicleManager.instance.serverUpdate();
} catch (Exception var10) {
DebugType.General.printException(var10, LogSeverity.Error);
}
}
WorldSimulation.instance.update();
HutchManager.getInstance().updateAll();
ImprovedFog.update();
this.helicopter.update();
long currentMS = System.currentTimeMillis();
if (currentMS - this.emitterUpdateMs >= 30L) {
this.emitterUpdateMs = currentMS;
this.emitterUpdate = true;
} else {
this.emitterUpdate = false;
}
for(int n = 0; n < this.currentEmitters.size(); ++n) {
BaseSoundEmitter e = (BaseSoundEmitter)this.currentEmitters.get(n);
if (this.emitterUpdate || e.hasSoundsToStart()) {
e.tick();
}
if (e.isEmpty()) {
if (e instanceof FMODSoundEmitter) {
FMODSoundEmitter fmodSoundEmitter = (FMODSoundEmitter)e;
fmodSoundEmitter.clearParameters();
}
this.currentEmitters.remove(n);
this.freeEmitters.push(e);
IsoObject owner = (IsoObject)this.emitterOwners.remove(e);
if (owner != null && owner.emitter == e) {
owner.emitter = null;
}
--n;
}
}
if (!GameClient.client && !GameServer.server) {
IsoMetaCell currentChunk = this.metaGrid.getCurrentCellData();
if (currentChunk != null) {
currentChunk.checkTriggers();
}
}
WorldSoundManager.instance.initFrame();
ZombieGroupManager.instance.preupdate();
OnceEvery.update();
CollisionManager.instance.initUpdate();
CompletableFuture thread = null;
if (DebugOptions.instance.threadWorld.getValue()) {
thread = CompletableFuture.runAsync(this::updateThread, PZForkJoinPool.commonPool());
}
GameProfiler profiler = GameProfiler.getInstance();
GameProfiler.ProfileArea var17 = profiler.profile("Update Climate");
try {
ClimateManager.getInstance().update();
} catch (Throwable var11) {
if (var17 != null) {
try {
var17.close();
} catch (Throwable var8) {
var11.addSuppressed(var8);
}
}
throw var11;
}
if (var17 != null) {
var17.close();
}
this.updateWorld();
if (thread != null) {
var17 = profiler.profile("Wait Thread");
try {
thread.join();
} catch (Throwable var12) {
if (var17 != null) {
try {
var17.close();
} catch (Throwable var9) {
var12.addSuppressed(var9);
}
}
throw var12;
}
if (var17 != null) {
var17.close();
}
} else {
this.updateThread();
}
AnimationPlayerRecorder.onPostUpdateWorld();
}
private void updateThread() {
GameProfiler profiler = GameProfiler.getInstance();
GameProfiler.ProfileArea var2 = profiler.profile("Update Buildings");
try {
this.updateBuildings();
} catch (Throwable var11) {
if (var2 != null) {
try {
var2.close();
} catch (Throwable var7) {
var11.addSuppressed(var7);
}
}
throw var11;
}
if (var2 != null) {
var2.close();
}
var2 = profiler.profile("Update Static");
try {
ObjectRenderEffects.updateStatic();
} catch (Throwable var14) {
if (var2 != null) {
try {
var2.close();
} catch (Throwable var9) {
var14.addSuppressed(var9);
}
}
throw var14;
}
if (var2 != null) {
var2.close();
}
for(int i = 0; i < this.addCoopPlayers.size(); ++i) {
AddCoopPlayer acp = (AddCoopPlayer)this.addCoopPlayers.get(i);
acp.update();
if (acp.isFinished()) {
this.addCoopPlayers.remove(i--);
}
}
if (!GameServer.server) {
IsoPlayer.UpdateRemovedEmitters();
}
var2 = profiler.profile("Update DBs");
try {
this.updateDBs();
} catch (Throwable var12) {
if (var2 != null) {
try {
var2.close();
} catch (Throwable var5) {
var12.addSuppressed(var5);
}
}
throw var12;
}
if (var2 != null) {
var2.close();
}
if (this.updateSafehousePlayers > 0 && (GameServer.server || GameClient.client)) {
--this.updateSafehousePlayers;
if (this.updateSafehousePlayers == 0) {
this.updateSafehousePlayers = 200;
SafeHouse.updateSafehousePlayersConnected();
}
}
var2 = profiler.profile("Update VA");
try {
AnimalZones.updateVirtualAnimals();
} catch (Throwable var13) {
if (var2 != null) {
try {
var2.close();
} catch (Throwable var8) {
var13.addSuppressed(var8);
}
}
throw var13;
}
if (var2 != null) {
var2.close();
}
var2 = profiler.profile("Load Animal Defs");
try {
AnimalTracksDefinitions.loadTracksDefinitions();
} catch (Throwable var10) {
if (var2 != null) {
try {
var2.close();
} catch (Throwable var6) {
var10.addSuppressed(var6);
}
}
throw var10;
}
if (var2 != null) {
var2.close();
}
}
private void updateBuildings() {
for(int n = 0; n < this.currentCell.getBuildingList().size(); ++n) {
((IsoBuilding)this.currentCell.getBuildingList().get(n)).update();
}
}
private void updateDBs() {
try {
if (PlayerDB.isAvailable()) {
PlayerDB.getInstance().updateMain();
}
VehiclesDB2.instance.updateMain();
} catch (Exception var2) {
ExceptionLogger.logException(var2);
}
}
public IsoCell getCell() {
return this.currentCell;
}
private void PopulateCellWithSurvivors() {
}
public int getWorldSquareY() {
return this.currentCell.chunkMap[IsoPlayer.getPlayerIndex()].worldY * 8;
}
public int getWorldSquareX() {
return this.currentCell.chunkMap[IsoPlayer.getPlayerIndex()].worldX * 8;
}
public IsoMetaChunk getMetaChunk(int wx, int wy) {
return this.metaGrid.getChunkData(wx, wy);
}
public IsoMetaChunk getMetaChunkFromTile(int wx, int wy) {
return this.metaGrid.getChunkDataFromTile(wx, wy);
}
public float getGlobalTemperature() {
return ClimateManager.getInstance().getTemperature();
}
public String getWeather() {
return this.weather;
}
public void setWeather(String weather) {
this.weather = weather;
}
public int getLuaSpawnCellX() {
return PZMath.coordmodulo(this.luaPosX, 256);
}
/** @deprecated */
@Deprecated
public void setLuaSpawnCellX(int luaSpawnCellX) {
}
public int getLuaSpawnCellY() {
return PZMath.coordmodulo(this.luaPosY, 256);
}
/** @deprecated */
@Deprecated
public void setLuaSpawnCellY(int luaSpawnCellY) {
}
public int getLuaPosX() {
return this.luaPosX;
}
public void setLuaPosX(int luaPosX) {
this.luaPosX = luaPosX;
}
public int getLuaPosY() {
return this.luaPosY;
}
public void setLuaPosY(int luaPosY) {
this.luaPosY = luaPosY;
}
public int getLuaPosZ() {
return this.luaPosZ;
}
public void setLuaPosZ(int luaPosZ) {
this.luaPosZ = luaPosZ;
}
public void setSpawnRegion(String spawnRegionName) {
if (spawnRegionName != null) {
this.spawnRegionName = spawnRegionName;
}
}
public String getSpawnRegion() {
return this.spawnRegionName;
}
public String getWorld() {
return Core.gameSaveWorld;
}
public void transmitWeather() {
if (GameServer.server) {
GameServer.sendWeather();
}
}
public boolean isValidSquare(int x, int y, int z) {
return z >= -32 && z <= 31 ? this.metaGrid.isValidSquare(x, y) : false;
}
public ArrayList getRandomizedZoneList() {
return this.randomizedZoneList;
}
public RandomizedZoneStoryBase getRandomizedZoneStoryByName(String name) {
for(int i = 0; i < this.randomizedZoneList.size(); ++i) {
RandomizedZoneStoryBase rzs = (RandomizedZoneStoryBase)this.randomizedZoneList.get(i);
if (rzs.getName().equalsIgnoreCase(name)) {
return rzs;
}
}
return null;
}
public ArrayList getRandomizedBuildingList() {
return this.randomizedBuildingList;
}
public ArrayList getRandomizedVehicleStoryList() {
return this.randomizedVehicleStoryList;
}
public RandomizedVehicleStoryBase getRandomizedVehicleStoryByName(String name) {
for(int i = 0; i < this.randomizedVehicleStoryList.size(); ++i) {
RandomizedVehicleStoryBase rvs = (RandomizedVehicleStoryBase)this.randomizedVehicleStoryList.get(i);
if (rvs.getName().equalsIgnoreCase(name)) {
return rvs;
}
}
return null;
}
public RandomizedBuildingBase getRBBasic() {
return this.rbBasic;
}
public RandomizedWorldBase getRandomizedWorldBase() {
return this.randomizedWorldBase;
}
public static boolean getZombiesDisabled() {
return noZombies || !SystemDisabler.doZombieCreation || SandboxOptions.instance.zombies.getValue() == 6;
}
public static boolean getZombiesEnabled() {
return !getZombiesDisabled();
}
public ClimateManager getClimateManager() {
return ClimateManager.getInstance();
}
public IsoPuddles getPuddlesManager() {
return IsoPuddles.getInstance();
}
public static int getWorldVersion() {
return 249;
}
public HashMap getSpawnedZombieZone() {
return this.spawnedZombieZone;
}
public int getTimeSinceLastSurvivorInHorde() {
return this.timeSinceLastSurvivorInHorde;
}
public void setTimeSinceLastSurvivorInHorde(int timeSinceLastSurvivorInHorde) {
this.timeSinceLastSurvivorInHorde = timeSinceLastSurvivorInHorde;
}
public float getWorldAgeDays() {
float worldAgeDays = (float)GameTime.getInstance().getWorldAgeHours() / 24.0F;
worldAgeDays += (float)((SandboxOptions.instance.timeSinceApo.getValue() - 1) * 30);
return worldAgeDays;
}
public HashMap getAllTiles() {
return this.allTiles;
}
public ArrayList getAllTilesName() {
ArrayList result = new ArrayList(this.allTiles.keySet());
Collections.sort(result);
return result;
}
public ArrayList getAllTiles(String filename) {
return (ArrayList)this.allTiles.get(filename);
}
public boolean isHydroPowerOn() {
return this.hydroPowerOn;
}
public void setHydroPowerOn(boolean on) {
this.hydroPowerOn = on;
}
public ArrayList getTileImageNames() {
return this.tileImages;
}
public static void parseDistributions() {
ItemPickerJava.Parse();
ItemPickerJava.InitSandboxLootSettings();
}
public void setRules(Rules rules) {
this.rules = rules;
}
public Rules getRules() {
return this.rules;
}
public void setWgChunk(WorldGenChunk wgChunk) {
this.wgChunk = wgChunk;
}
public WorldGenChunk getWgChunk() {
return this.wgChunk;
}
public void setBlending(Blending blending) {
this.blending = blending;
}
public Blending getBlending() {
return this.blending;
}
public void setAttachmentsHandler(AttachmentsHandler attachmentsHandler) {
this.attachmentsHandler = attachmentsHandler;
}
public AttachmentsHandler getAttachmentsHandler() {
return this.attachmentsHandler;
}
public void setZoneGenerator(ZoneGenerator zoneGenerator) {
this.zoneGenerator = zoneGenerator;
}
public ZoneGenerator getZoneGenerator() {
return this.zoneGenerator;
}
public void setBiomeMap(BiomeMap biomeMap) {
this.biomeMap = biomeMap;
}
public BiomeMap getBiomeMap() {
return this.biomeMap;
}
public void setZombieVoronois(List zombieVoronois) {
this.zombieVoronois = zombieVoronois;
}
public List getZombieVoronois() {
return this.zombieVoronois;
}
static {
LUA_CHECKSUM_TIMEOUT_MS = TimeUnit.SECONDS.toMillis(60L);
instance = new IsoWorld();
compScoreToPlayer = new CompScoreToPlayer();
mapPath = "media/";
mapUseJar = true;
PropertyValueMap = new HashMap();
savedWorldVersion = -1;
totalWorldVersion = -1;
}
private static class CompScoreToPlayer implements Comparator {
public int compare(IsoZombie a, IsoZombie b) {
float aScore = this.getScore(a);
float bScore = this.getScore(b);
if (aScore < bScore) {
return 1;
} else {
return aScore > bScore ? -1 : 0;
}
}
public float getScore(IsoZombie zombie) {
float maxScore = Float.MIN_VALUE;
for(int pn = 0; pn < 4; ++pn) {
IsoPlayer player = IsoPlayer.players[pn];
if (player != null && player.current != null) {
float score = player.getZombieRelevenceScore(zombie);
maxScore = Math.max(maxScore, score);
}
}
return maxScore;
}
}
private static class s_performance {
static final PerformanceProfileProbe isoWorldUpdate = new PerformanceProfileProbe("IsoWorld.update");
static final PerformanceProfileProbe isoWorldRender = new PerformanceProfileProbe("IsoWorld.render");
}
public class Frame {
public ArrayList xPos;
public ArrayList yPos;
public ArrayList type;
public Frame(final IsoWorld this$0) {
Objects.requireNonNull(this$0);
super();
this.xPos = new ArrayList();
this.yPos = new ArrayList();
this.type = new ArrayList();
Iterator it = IsoWorld.instance.currentCell.getObjectList().iterator();
while(it != null && it.hasNext()) {
IsoMovingObject o = (IsoMovingObject)it.next();
byte type;
if (o instanceof IsoPlayer) {
type = 0;
} else if (o instanceof IsoSurvivor) {
type = 1;
} else {
if (!(o instanceof IsoZombie)) {
continue;
}
IsoZombie isoZombie = (IsoZombie)o;
if (isoZombie.ghost) {
continue;
}
type = 2;
}
this.xPos.add(PZMath.fastfloor(o.getX()));
this.yPos.add(PZMath.fastfloor(o.getY()));
this.type.add(Integer.valueOf(type));
}
}
}
public static class MetaCell {
public int x;
public int y;
public int zombieCount;
public IsoDirections zombieMigrateDirection;
public int[][] from = new int[3][3];
}
private static class CompDistToPlayer implements Comparator {
public float px;
public float py;
public int compare(IsoZombie a, IsoZombie b) {
float aScore = IsoUtils.DistanceManhatten((float)PZMath.fastfloor(a.getX()), (float)PZMath.fastfloor(a.getY()), this.px, this.py);
float bScore = IsoUtils.DistanceManhatten((float)PZMath.fastfloor(b.getX()), (float)PZMath.fastfloor(b.getY()), this.px, this.py);
if (aScore < bScore) {
return -1;
} else {
return aScore > bScore ? 1 : 0;
}
}
}
}
