freeze for "find the stupid bug"

LogBlockHeatMapper/src/main/java/de/nplusc/izc/logblockheatmapper/LogBlockHeatmapperRegionTrimmer.java

@@ -29,10 +29,7 @@ import java.awt.GradientPaint;
 import java.awt.Graphics2D;
 import java.awt.image.BufferedImage;
 import java.io.*;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.Map;
-import java.util.TreeMap;
+import java.util.*;
 import javax.imageio.ImageIO;
 
 /**
@@ -45,7 +42,10 @@ enum BlockState
     NONE,
     BUFFER,
     ACTIVITY,
-    MAYBE
+    BUFFER_PURGED,
+    ACTIVITY_PURGED,
+    WORKBENCH_FORCED,
+    WORKBENCH_FORCED_BUFFER,
 }
 
 enum RegionState
@@ -56,12 +56,69 @@ enum RegionState
     WATERIZE
 }
 
+class CoordHolder
+{
+    public final int x;
+    public final int y;
+    public final int z;
+
+    public final String blocktype;
+
+    CoordHolder(int x, int y, int z, String blocktype) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.blocktype = blocktype;
+    }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        CoordHolder that = (CoordHolder) o;
+        return x == that.x &&
+                y == that.y &&
+                z == that.z &&
+                Objects.equals(blocktype, that.blocktype);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(x, y, z, blocktype);
+    }
+}
 public class LogBlockHeatmapperRegionTrimmer
 {
+    static List<String> blocktypes = Arrays.asList(
+            "minecraft:crafting_table",
+            "minecraft:furnace",
+            "minecraft:barrel",
+            "minecraft:ender_chest",
+            "minecraft:shulker_box",
+            "minecraft:black_shulker_box",
+            "minecraft:gray_shulker_box",
+            "minecraft:white_shulker_box",
+            "minecraft:light_gray_shulker_box",
+            "minecraft:red_shulker_box",
+            "minecraft:pink_shulker_box",
+            "minecraft:purple_shulker_box",
+            "minecraft:magenta_shulker_box",
+            "minecraft:orange_shulker_box",
+            "minecraft:brown_shulker_box",
+            "minecraft:cyan_shulker_box",
+            "minecraft:light_blue_shulker_box",
+            "minecraft:yellow_shulker_box",
+            "minecraft:lime_shulker_box",
+            "minecraft:green_shulker_box",
+            "minecraft:blue_shulker_box",
+            "minecraft:hopper"
+    );
+
       //x  y
     static int[ ][ ] dataField ;
     
+    static Map<String,Integer> keepRegionsIn = new TreeMap<>();
+
     static Map<String,RegionState> keepRegions = new TreeMap<>();
     
     static int radius=0;
@@ -69,7 +126,9 @@ public class LogBlockHeatmapperRegionTrimmer
     static int coreRadius=0;
     
     static int regionRedius = 0;
-    
+
+    static final int treshold = 100;
+
     static final Color removeA = new Color(255, 127, 39);
     static final Color removeB = new Color(251, 100, 0);
     
@@ -83,19 +142,32 @@ public class LogBlockHeatmapperRegionTrimmer
     static final Color keepCoreB = new Color(0, 106, 0);
     
     static final Color activity = new Color(87, 87, 87);
-    
     static final Color activityBuffer = new Color(157, 157, 157);
+
+    static final Color activityPurged = new Color(230, 230, 230);
+    static final Color activityBufferPurged = new Color(255, 255, 255);
+
+    static final Color workbench_keep = new Color(255, 255, 0);
+    static final Color workbench_keep_buffer = new Color(128, 128, 0);
     
     static final Color coreEdge = new Color(255, 0, 0);
 
-    private static void setRegion(int x,int y, RegionState s)
+    private static void setRegion(int x,int y, int s)
+    {
+        int rx = (int)Math.floor((x)/512.0f);
+        int ry = (int)Math.floor((y)/512.0f);
+        keepRegionsIn.putIfAbsent(("r."+rx+"."+ry+".mca"),0);
+        keepRegionsIn.put(("r."+rx+"."+ry+".mca"),keepRegionsIn.get(("r."+rx+"."+ry+".mca"))+s);
+    }
+
+    private static void setRegionFinal(int x,int y, RegionState s)
     {
         int rx = (int)Math.floor((x)/512.0f);
         int ry = (int)Math.floor((y)/512.0f);
         keepRegions.put(("r."+rx+"."+ry+".mca"),s);
     }
     
-    
+    static Map<CoordHolder,Integer> workbenchCalculations = new HashMap<>();
     
     
     /**
@@ -146,10 +218,10 @@ public class LogBlockHeatmapperRegionTrimmer
         {
             for(int j=0;j<coreRadius;j++)
             {
-            setRegion(i, j, RegionState.CORE);
-            setRegion(i, -j, RegionState.CORE);
-            setRegion(-i, j, RegionState.CORE);
-            setRegion(-i, -j, RegionState.CORE);
+                setRegionFinal(i, j, RegionState.CORE);
+                setRegionFinal(i, -j, RegionState.CORE);
+                setRegionFinal(-i, j, RegionState.CORE);
+                setRegionFinal(-i, -j, RegionState.CORE);
             }
             System.out.print(i+" Preparation Core Lines\r");
         }
@@ -175,62 +247,230 @@ public class LogBlockHeatmapperRegionTrimmer
             String[] xes = xx.split("\\t");
             int l = Integer.parseInt(xes[0]);
             boolean register=false;
-            int f = Integer.parseInt(xes[1]);
-            int t = Integer.parseInt(xes[2]);
- 
+            String from = xes[2].intern();
+            String to = xes[3].intern();
             int x= Integer.parseInt(xes[4])+radius,y= Integer.parseInt(xes[6])+radius;
-            //-y=up
-            if(x<radius*2&&x>=0&&y<radius*2&&y>=0)
+
+            int z = Integer.parseInt(xes[5]);
+            if(blocktypes.contains(from)||blocktypes.contains(to))
+            {
+                if(blocktypes.contains(from))
+                {
+                    CoordHolder location = new CoordHolder(x,y,z,from);
+                    if(!workbenchCalculations.containsKey(location))
+                    {
+                        workbenchCalculations.put(location,-1);
+                    }
+                    else
+                    {
+                        workbenchCalculations.put(location,workbenchCalculations.get(location)-1);
+                    }
+                }
+                else
+                {
+                    CoordHolder location = new CoordHolder(x,y,z,to);
+                    if(!workbenchCalculations.containsKey(location))
+                    {
+                        workbenchCalculations.put(location,1);
+                    }
+                    else
+                    {
+                        workbenchCalculations.put(location,workbenchCalculations.get(location)+1);
+                    }
+                }
+
+            }
+            else
             {
-                for(int i=-30;i<31;i++)
+
+                //-y=up
+                if(x<radius*2&&x>=0&&y<radius*2&&y>=0)
                 {
-                    if((x+i)<(radius*2)&&(x+i)>0)
+                    for(int i=-30;i<31;i++)
                     {
-                        for(int j=-30;j<31;j++)
+                        if((x+i)<(radius*2)&&(x+i)>0)
                         {
-                            if((y+j)<(radius*2)&&(y+j)>0)
+                            for(int j=-30;j<31;j++)
                             {
-                                //only switching NONE to BUFFER
-                                if(dataField[y+j][x+i]==BlockState.NONE.ordinal())
+                                if((y+j)<(radius*2)&&(y+j)>0)
                                 {
-                                    dataField[y+j][x+i]=BlockState.BUFFER.ordinal();
-                                    setRegion(x+i-radius, y+i-radius, RegionState.KEEP);
+                                    //only switching NONE to BUFFER
+                                    if(dataField[y+j][x+i]==BlockState.NONE.ordinal())
+                                    {
+                                        dataField[y+j][x+i]=BlockState.BUFFER_PURGED.ordinal();
+                                        // setRegion(x+i-radius, y+i-radius, 1);
+                                        // propagating buffer markers in second pass... buffer rendering handled in same pass
+                                    }
                                 }
                             }
                         }
                     }
+                    dataField[y][x]=BlockState.ACTIVITY.ordinal();
+                    setRegion(x-radius, y-radius, 1);
+
                 }
-                dataField[y][x]=BlockState.ACTIVITY.ordinal();
-                setRegion(x-radius, y-radius, RegionState.KEEP);
-                
             }
             if(l%10000==0)
             {
                 System.out.print(l+"changes so far\r");
             }
-            
-            
         });
-        System.out.print("\nDatabase crunched to 100%\n");
+        System.out.println("\nDatabase crunched to 100%\n");
+
+        System.out.print("\nCalculating Workbenches("+workbenchCalculations.size()+") \n");
+
+        workbenchCalculations.forEach((c,i) ->
+        {
+            if(i>0)
+            {
+                setRegion(c.x-radius,c.y-radius,10000); // force keep
+            }
+        });
+
+        System.out.println("\nWorkbenches calculated\n");
 
         for(int i=-regionBase;i<=regionBase;i++)
         {
             for(int j=-regionBase;j<=regionBase;j++)
             {
-                RegionState[] neighbors=new RegionState[8];
-
-                neighbors[0]=keepRegions.get(("r."+(i-1)+"."+(j-1)+".mca"));
-                neighbors[1]=keepRegions.get(("r."+(i-1)+"."+(j-0)+".mca"));
-                neighbors[2]=keepRegions.get(("r."+(i-1)+"."+(j+1)+".mca"));
-                neighbors[3]=keepRegions.get(("r."+(i-0)+"."+(j-1)+".mca"));
-                neighbors[4]=keepRegions.get(("r."+(i-0)+"."+(j+1)+".mca"));
-                neighbors[5]=keepRegions.get(("r."+(i+1)+"."+(j-1)+".mca"));
-                neighbors[6]=keepRegions.get(("r."+(i+1)+"."+(j-0)+".mca"));
-                neighbors[7]=keepRegions.get(("r."+(i+1)+"."+(j+1)+".mca"));
-                RegionState current=keepRegions.get(("r."+(i)+"."+(j)+".mca"));
-                if(current==null)
+                int current=keepRegionsIn.getOrDefault(("r."+(i)+"."+(j)+".mca"),-1);
+                System.out.println("Processing r."+(i)+"."+(j)+".mca; ("+i+"/"+regionBase+"|"+j+"/"+regionBase);
+                if(current<treshold)
                 {
                     keepRegions.put(("r."+(i)+"."+(j)+".mca"),RegionState.REMOVE);
+                    for(int pi = 0;pi<512;pi++)
+                    {
+                        for(int pj = 0;pj<512;pi++)
+                        {
+                            BlockState k = BlockState.values()[dataField[i*512+pi][j*512+pj]];
+
+                            if(k==BlockState.ACTIVITY)
+                            {
+                                dataField[i*512+pi][j*512+pj]=BlockState.ACTIVITY_PURGED.ordinal();
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    keepRegions.put(("r."+(i)+"."+(j)+".mca"),RegionState.KEEP);
+
+                    for(int pi = 0;pi<512;pi++)
+                    {
+                        for(int pj = 0;pj<512;pi++)
+                        {
+                            int kx = i*512+pi+radius;
+                            int ky = j*512+pj+radius;
+                            if(kx<0||ky<0||kx>=dataField.length||ky>=dataField.length)
+                            {
+                                continue; // coordinate not valid. can't crunch
+                            }
+                            BlockState k = BlockState.values()[dataField[kx][ky]];
+
+                            if(k==BlockState.ACTIVITY)
+                            {
+                                if(pi<30&&pj<30)
+                                {
+                                    keepRegions.put(("r."+(i-1)+"."+(j-1)+".mca"),RegionState.KEEP);
+                                }
+                                if(pi<30)
+                                {
+                                    keepRegions.put(("r."+(i-1)+"."+(j)+".mca"),RegionState.KEEP);
+                                }
+                                if (pj<30)
+                                {
+                                    keepRegions.put(("r."+(i)+"."+(j-1)+".mca"),RegionState.KEEP);
+                                }
+                                int max = 512-30;
+
+                                if(pi>max&&pj>max)
+                                {
+                                    keepRegions.put(("r."+(i+1)+"."+(j+1)+".mca"),RegionState.KEEP);
+                                }
+                                if(pi>max)
+                                {
+                                    keepRegions.put(("r."+(i+1)+"."+(j)+".mca"),RegionState.KEEP);
+                                }
+                                if (pj>max)
+                                {
+                                    keepRegions.put(("r."+(i)+"."+(j+1)+".mca"),RegionState.KEEP);
+                                }
+
+                                //propagating buffers
+                                int kxmin = Math.max(0,kx-30);
+                                int kymin = Math.max(0,ky-30);
+
+                                int kxmax = Math.min(dataField.length,kx+30);
+                                int kymax = Math.min(dataField.length,ky+30);
+
+                                for(int ki = kxmin;ki<kxmax;ki++)
+                                {
+                                    for(int kj = kymin;kj<kymax;kj++)
+                                    {
+                                        int ov = dataField[kj][ki];
+                                        if(ov==BlockState.NONE.ordinal()||ov==BlockState.BUFFER_PURGED.ordinal())
+                                        {
+                                            dataField[kj][ki] = BlockState.BUFFER.ordinal();
+                                        }
+                                    }
+                                }
+                            }
+
+                            if(k==BlockState.WORKBENCH_FORCED)
+                            {
+                                if(pi<50&&pj<50)
+                                {
+                                    keepRegions.put(("r."+(i-1)+"."+(j-1)+".mca"),RegionState.KEEP);
+                                }
+                                if(pi<50)
+                                {
+                                    keepRegions.put(("r."+(i-1)+"."+(j)+".mca"),RegionState.KEEP);
+                                }
+                                if (pj<50)
+                                {
+                                    keepRegions.put(("r."+(i)+"."+(j-1)+".mca"),RegionState.KEEP);
+                                }
+                                int max = 512-50;
+
+                                if(pi>max&&pj>max)
+                                {
+                                    keepRegions.put(("r."+(i+1)+"."+(j+1)+".mca"),RegionState.KEEP);
+                                }
+                                if(pi>max)
+                                {
+                                    keepRegions.put(("r."+(i+1)+"."+(j)+".mca"),RegionState.KEEP);
+                                }
+                                if (pj>max)
+                                {
+                                    keepRegions.put(("r."+(i)+"."+(j+1)+".mca"),RegionState.KEEP);
+                                }
+
+                                //propagating buffers
+                                int kxmin = Math.max(0,kx-50);
+                                int kymin = Math.max(0,ky-50);
+
+                                int kxmax = Math.min(dataField.length,kx+50);
+                                int kymax = Math.min(dataField.length,ky+50);
+
+                                for(int ki = kxmin;ki<kxmax;ki++)
+                                {
+                                    for(int kj = kymin;kj<kymax;kj++)
+                                    {
+                                        int ov = dataField[kj][ki];
+                                        if(ov==BlockState.NONE.ordinal()||ov==BlockState.BUFFER_PURGED.ordinal()||ov==BlockState.BUFFER.ordinal())
+                                        {
+                                            dataField[kj][ki] = BlockState.WORKBENCH_FORCED_BUFFER.ordinal();
+                                        }
+                                    }
+                                }
+                            }
+
+
+
+
+                        }
+                    }
+
                 }
                 /*for(int k=0;k<8;k++)
                 {
@@ -309,6 +549,18 @@ public class LogBlockHeatmapperRegionTrimmer
                     case ACTIVITY:
                         color = activity.getRGB();
                         break;
+                    case BUFFER_PURGED:
+                        color = activityBufferPurged.getRGB();
+                        break;
+                    case ACTIVITY_PURGED:
+                        color = activityPurged.getRGB();
+                        break;
+                    case WORKBENCH_FORCED:
+                        color = workbench_keep.getRGB();
+                        break;
+                    case WORKBENCH_FORCED_BUFFER:
+                        color = workbench_keep_buffer.getRGB();
+                        break;
                 }
 
                 ImageLineHelper.setPixelRGB8(iline, j, color);
@@ -324,6 +576,7 @@ public class LogBlockHeatmapperRegionTrimmer
             fileActions = new PrintStream(new FileOutputStream("mergeMap.sh"));
             fileActions.println("mkdir oldChunks");
             System.out.println("mkdir oldChunks");
+
             fileActions.println("mkdir oldChunksWaterize");
             System.out.println("mkdir oldChunksWaterize");
             keepRegions.forEach((k,v)->
@@ -362,3 +615,11 @@ public class LogBlockHeatmapperRegionTrimmer
 
 //use mcserver;
 //mysql> SELECT id,replaced,type,data,x,y,z from `lb-surv` into outfile D:\\emc2\\arca_slash\\heatmap.tsv FIELDS TERMINATED BY `\t` LINES TERMINATED BY `\n`
+
+/*
+    SELECT blocks.id, blocks.id, blocks.type, blocks.replaced, blocks.x,blocks.y, blocks.z FROM `lb-players` as player, `lb-surv-blocks` as blocks
+        where player.playerid = blocks.playerid
+        AND player.UUID NOT LIKE 'l%'
+        INTO OUTFILE 'C:/lmaa/crunchme/survival2-oct-novirt.csv'
+        ;
+*/