Merge pull request #178 from runejs/more-renames

refactor: fully rename caches, make private

Author: Promises

src/main/java/org/runejs/client/Game.java

@@ -1985,7 +1985,7 @@ public static void clearCaches() {
         PlayerAppearance.clearPlayerModelCache();
         GameInterface.clearInterfaceCaches();
         ((Class35) Rasterizer3D.interface3).clearTextures();
-        ClientScript.clientScriptCache.clear();
+        ClientScript.clearClientScriptCache();
         CacheArchive.skeletonCacheArchive.clearCache();
         CacheArchive.skinDefinitionCacheArchive.clearCache();
         CacheArchive.gameInterfaceCacheArchive.clearCache();

src/main/java/org/runejs/client/Landscape.java

@@ -221,7 +221,7 @@ public static void loadRegion() {
                         MovedStatics.spawnGroundItem(y, x);
                 }
                 clearTemporaryObjects();
-                GameObjectDefinition.objectModelCache.clear();
+                GameObjectDefinition.clearStaticModelCache();
                 if(GameShell.clientFrame != null) {
                     OutgoingPackets.buffer.putPacket(121);
                     OutgoingPackets.buffer.putIntBE(1057001181);

src/main/java/org/runejs/client/MovedStatics.java

@@ -1253,7 +1253,7 @@ public static void handleVarPlayers(int varPlayerIndex) {
 	                    Rasterizer3D.createPalette(0.6);
 	                    ((Class35) Rasterizer3D.interface3).setBrightness(0.6);
 	                }
-	                clearImageCache();
+	                ItemDefinition.clearImageCache();
 	                clearScreen = true;
 	            }
 	            if(varPlayerType == 3) {
@@ -3098,10 +3098,6 @@ public static void drawLoadingText(int percent, Color color, String desc) {
         }
     }
 
-    public static void clearImageCache() {
-        ItemDefinition.itemImageCache.clear();
-    }
-
     public static void method778(HuffmanEncoding arg1) {
         aHuffmanEncoding_2590 = arg1;
     }

src/main/java/org/runejs/client/audio/Instrument.java

@@ -128,25 +128,25 @@ public int evaluateWave(int phase, int amplitude, int table) {
         return 0;
     }
 
-    public static void method776(int[] arg0, int arg1, int arg2) {
-        arg2 = arg1 + arg2 - 7;
-        while(arg1 < arg2) {
-            arg0[arg1++] = 0;
-            arg0[arg1++] = 0;
-            arg0[arg1++] = 0;
-            arg0[arg1++] = 0;
-            arg0[arg1++] = 0;
-            arg0[arg1++] = 0;
-            arg0[arg1++] = 0;
-            arg0[arg1++] = 0;
+    private static void resetOutput(int[] dest, int counter, int length) {
+        length = counter + length - 7;
+        while(counter < length) {
+            dest[counter++] = 0;
+            dest[counter++] = 0;
+            dest[counter++] = 0;
+            dest[counter++] = 0;
+            dest[counter++] = 0;
+            dest[counter++] = 0;
+            dest[counter++] = 0;
+            dest[counter++] = 0;
         }
-        arg2 += 7;
-        while(arg1 < arg2)
-            arg0[arg1++] = 0;
+        length += 7;
+        while(counter < length)
+            dest[counter++] = 0;
     }
 
     public int[] synthesize(int n_s, int dt) {
-        method776(output, 0, n_s);
+        resetOutput(output, 0, n_s);
         if(dt < 10) {
             return output;
         }

src/main/java/org/runejs/client/cache/cs/ClientScript.java

@@ -14,7 +14,7 @@
 
 public class ClientScript extends CachedNode {
 
-    public static NodeCache clientScriptCache = new NodeCache(128);
+    private static NodeCache clientScriptCache = new NodeCache(128);
 
     public int[] intOperands;
     public int intStackCount;
@@ -24,6 +24,10 @@ public class ClientScript extends CachedNode {
     public int localIntCount;
     public int[] opcodes;
 
+    public static void clearClientScriptCache() {
+        clientScriptCache.clear();
+    }
+
 
     public static void clientScriptDebugger() {
         int len = CacheArchive.clientScriptCacheArchive.getLength();

src/main/java/org/runejs/client/cache/def/ActorDefinition.java

@@ -21,10 +21,10 @@
 public class ActorDefinition extends CachedNode implements EntityDefinition {
 
     public static int count;
-    public static NodeCache actorDefinitionNodeCache = new NodeCache(64);
-    public static NodeCache actorChildModelCache = new NodeCache(50);
-    public static CacheArchive aCacheArchive_1375;
-    public static CacheArchive aCacheArchive_1577;
+    private static NodeCache actorDefinitionCache = new NodeCache(64);
+    private static NodeCache actorModelCache = new NodeCache(50);
+    private static CacheArchive actorDefinitionArchive;
+    private static CacheArchive actorModelArchive;
 
     public boolean isClickable = true;
     public int boundaryDimension = 1;
@@ -116,28 +116,28 @@ public static ImageRGB method578() {
     }
 
     public static ActorDefinition getDefinition(int id) {
-        ActorDefinition definition = (ActorDefinition) actorDefinitionNodeCache.get(id);
+        ActorDefinition definition = (ActorDefinition) actorDefinitionCache.get(id);
         if(definition != null)
             return definition;
-        byte[] data = aCacheArchive_1375.getFile(9, id);
+        byte[] data = actorDefinitionArchive.getFile(9, id);
         definition = new ActorDefinition();
         definition.id = id;
         if(data != null)
             definition.readValues(new Buffer(data));
-        actorDefinitionNodeCache.put(id, definition);
+        actorDefinitionCache.put(id, definition);
         return definition;
     }
 
     public static void clearActorCache() {
-        actorDefinitionNodeCache.clear();
-        actorChildModelCache.clear();
+        actorDefinitionCache.clear();
+        actorModelCache.clear();
     }
 
-    public static void initializeActorCache(CacheArchive arg0, CacheArchive arg2) {
-        aCacheArchive_1375 = arg2;
-        count = aCacheArchive_1375.fileLength(9);
+    public static void initializeActorCache(CacheArchive models, CacheArchive definitions) {
+        actorDefinitionArchive = definitions;
+        count = actorDefinitionArchive.fileLength(9);
 
-        aCacheArchive_1577 = arg0;
+        actorModelArchive = models;
     }
 
     public Model getChildModel(AnimationSequence animation1, AnimationSequence animation2, int arg3, int arg4) {
@@ -148,11 +148,11 @@ public Model getChildModel(AnimationSequence animation1, AnimationSequence anima
             }
             return actorDefinition.getChildModel(animation1, animation2, arg3, arg4);
         }
-        Model model1 = (Model) actorChildModelCache.get(id);
+        Model model1 = (Model) actorModelCache.get(id);
         if(model1 == null) {
             boolean bool = false;
             for(int model : models) {
-                if(!aCacheArchive_1577.loaded(model, 0)) {
+                if(!actorModelArchive.loaded(model, 0)) {
                     bool = true;
                 }
             }
@@ -161,7 +161,7 @@ public Model getChildModel(AnimationSequence animation1, AnimationSequence anima
             }
             Model[] class40_sub5_sub17_sub5s = new Model[models.length];
             for(int i = 0; models.length > i; i++) {
-                class40_sub5_sub17_sub5s[i] = Model.getModel(aCacheArchive_1577, models[i]);
+                class40_sub5_sub17_sub5s[i] = Model.getModel(actorModelArchive, models[i]);
             }
             if(class40_sub5_sub17_sub5s.length == 1) {
                 model1 = class40_sub5_sub17_sub5s[0];
@@ -177,7 +177,7 @@ public Model getChildModel(AnimationSequence animation1, AnimationSequence anima
             assert model1 != null;
             model1.createBones();
             model1.applyLighting(ambient + 64, 850 + contrast, -30, -50, -30, true);
-            actorChildModelCache.put(id, model1);
+            actorModelCache.put(id, model1);
         }
         Model class40_sub5_sub17_sub5_0_;
         if(animation1 != null && animation2 != null) {
@@ -315,7 +315,7 @@ public Model getHeadModel() {
         }
         boolean cached = false;
         for(int headModelIndex : headModelIndexes) {
-            if(!aCacheArchive_1577.loaded(headModelIndex, 0)) {
+            if(!actorModelArchive.loaded(headModelIndex, 0)) {
                 cached = true;
             }
         }
@@ -324,7 +324,7 @@ public Model getHeadModel() {
         }
         Model[] models = new Model[headModelIndexes.length];
         for(int i = 0; i < headModelIndexes.length; i++) {
-            models[i] = Model.getModel(aCacheArchive_1577, headModelIndexes[i]);
+            models[i] = Model.getModel(actorModelArchive, headModelIndexes[i]);
         }
         Model headModel;
         if(models.length == 1) {

src/main/java/org/runejs/client/cache/def/GameObjectDefinition.java

@@ -20,12 +20,12 @@ public class GameObjectDefinition extends CachedNode implements EntityDefinition
     public static int count;
     public static int[] OBJECT_TYPES = new int[]{0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3};
     public static boolean lowMemory = false;
-    public static CacheArchive definitionCache;
-    public static CacheArchive modelCache;
-    private static NodeCache objectDefinitionCache = new NodeCache(64);
-    public static NodeCache objectModelCache = new NodeCache(500);
+    private static CacheArchive definitionArchive;
+    private static CacheArchive modelArchive;
+    private static NodeCache definitionCache = new NodeCache(64);
+    private static NodeCache modelCacheStatic = new NodeCache(500);
     private static Model[] objectModelHolder = new Model[4];
-    private static NodeCache terrainObjectModelCache = new NodeCache(10);
+    private static NodeCache modelCacheDynamic = new NodeCache(10);
     private static NodeCache animatedObjectModelCache = new NodeCache(30);
 
     public int unkn1;
@@ -150,11 +150,11 @@ public static void addTemporaryObject(int objectId, int x, int orientation, int
     }
 
     public static GameObjectDefinition getDefinition(int objectId) {
-        GameObjectDefinition gameObjectDefinition = (GameObjectDefinition) objectDefinitionCache.get(objectId);
+        GameObjectDefinition gameObjectDefinition = (GameObjectDefinition) definitionCache.get(objectId);
         if(gameObjectDefinition != null) {
             return gameObjectDefinition;
         }
-        byte[] is = definitionCache.getFile(6, objectId);
+        byte[] is = definitionArchive.getFile(6, objectId);
         gameObjectDefinition = new GameObjectDefinition();
         gameObjectDefinition.id = objectId;
         if(is == null) {
@@ -175,22 +175,26 @@ public static GameObjectDefinition getDefinition(int objectId) {
             gameObjectDefinition.solid = false;
             gameObjectDefinition.walkable = false;
         }
-        objectDefinitionCache.put(objectId, gameObjectDefinition);
+        definitionCache.put(objectId, gameObjectDefinition);
         return gameObjectDefinition;
     }
 
     public static void clearGameObjectModelCache() {
-        objectDefinitionCache.clear();
-        objectModelCache.clear();
-        terrainObjectModelCache.clear();
+        definitionCache.clear();
+        modelCacheStatic.clear();
+        modelCacheDynamic.clear();
         animatedObjectModelCache.clear();
     }
 
+    public static void clearStaticModelCache() {
+        modelCacheStatic.clear();
+    }
+
     public static void initializeGameObjectDefinitionCache(CacheArchive modelCache, boolean lowMemory, CacheArchive definitionCache) {
-        GameObjectDefinition.definitionCache = definitionCache;
-        count = GameObjectDefinition.definitionCache.fileLength(6);
+        GameObjectDefinition.definitionArchive = definitionCache;
+        count = GameObjectDefinition.definitionArchive.fileLength(6);
         GameObjectDefinition.lowMemory = lowMemory;
-        GameObjectDefinition.modelCache = modelCache;
+        GameObjectDefinition.modelArchive = modelCache;
     }
 
     public static boolean isObjectLoaded(int type, int id) {
@@ -209,13 +213,13 @@ public Model createTerrainObjectModel(int arg0, int arg1, int arg2, int arg3, in
         } else {
             l = arg2 + (id << 10) + (arg4 << 3);
         }
-        Model model = (Model) terrainObjectModelCache.get(l);
+        Model model = (Model) modelCacheDynamic.get(l);
         if(model == null) {
             model = createObjectModel(!nonFlatShading, false, arg2, arg4);
             if(model == null) {
                 return null;
             }
-            terrainObjectModelCache.put(l, model);
+            modelCacheDynamic.put(l, model);
         }
         if(adjustToTerrain || nonFlatShading) {
             model = new Model(adjustToTerrain, nonFlatShading, model);
@@ -293,16 +297,16 @@ public Model createObjectModel(boolean shaded, boolean hasBones, int orientation
                 if(bool) {
                     modelId += 65536;
                 }
-                model = (Model) objectModelCache.get(modelId);
+                model = (Model) modelCacheStatic.get(modelId);
                 if(model == null) {
-                    model = Model.getModel(modelCache, modelId & 0xffff);
+                    model = Model.getModel(modelArchive, modelId & 0xffff);
                     if(model == null) {
                         return null;
                     }
                     if(bool) {
                         model.method818();
                     }
-                    objectModelCache.put(modelId, model);
+                    modelCacheStatic.put(modelId, model);
                 }
                 if(modelCount > 1) {
                     objectModelHolder[modelIndex] = model;
@@ -327,16 +331,16 @@ public Model createObjectModel(boolean shaded, boolean hasBones, int orientation
             if(bool) {
                 modelId += 65536;
             }
-            model = (Model) objectModelCache.get(modelId);
+            model = (Model) modelCacheStatic.get(modelId);
             if(model == null) {
-                model = Model.getModel(modelCache, 0xffff & modelId);
+                model = Model.getModel(modelArchive, 0xffff & modelId);
                 if(model == null) {
                     return null;
                 }
                 if(bool) {
                     model.method818();
                 }
-                objectModelCache.put(modelId, model);
+                modelCacheStatic.put(modelId, model);
             }
         }
         boolean bool;
@@ -542,7 +546,7 @@ public boolean isTypeModelLoaded(int type) {
         if(objectTypes != null) {
             for(int i = 0; objectTypes.length > i; i++) {
                 if(objectTypes[i] == type) {
-                    return modelCache.loaded(objectModels[i] & 0xffff, 0);
+                    return modelArchive.loaded(objectModels[i] & 0xffff, 0);
                 }
             }
             return true;
@@ -555,7 +559,7 @@ public boolean isTypeModelLoaded(int type) {
         }
         boolean bool = true;
         for(int i = 0; objectModels.length > i; i++) {
-            bool &= modelCache.loaded(0xffff & objectModels[i], 0);
+            bool &= modelArchive.loaded(0xffff & objectModels[i], 0);
         }
         return bool;
     }
@@ -582,7 +586,7 @@ public boolean method612() {
         }
         boolean bool = true;
         for(int i = 0; objectModels.length > i; i++) {
-            bool &= modelCache.loaded(0xffff & objectModels[i], 0);
+            bool &= modelArchive.loaded(0xffff & objectModels[i], 0);
         }
         return bool;
     }