refactor(tier): update validation logic for drive tier in research operations

Author: MrSilly07

src/main/java/com/researchcube/client/screen/ResearchTableScreen.java

@@ -499,6 +499,7 @@ private void renderTreeView(GuiGraphics g, int x, int y, int mouseX, int mouseY)
 
     /**
      * Renders the progress view showing active research details.
+     * Shows: name, tier, category, description, costs, progress bar.
      */
     private void renderProgressView(GuiGraphics g, int x, int y) {
         int vx = x + ResearchTableMenu.PROGRESS_VIEW_X;
@@ -521,45 +522,97 @@ private void renderProgressView(GuiGraphics g, int x, int y) {
             return;
         }
 
-        int textY = vy + 8;
-        int lineHeight = 12;
+        int textY = vy + 6;
+        int lineHeight = 11;
+        int tierColor = activeDef.getTier().getColor() | 0xFF000000;
 
-        // Line 1: Research name with tier color
-        int nameColor = activeDef.getTier().getColor() | 0xFF000000;
-        g.drawString(font, activeDef.getDisplayName(), vx + 8, textY, nameColor, false);
+        // Header: Research name with tier badge
+        String nameStr = activeDef.getDisplayName();
         String tierBadge = " [" + activeDef.getTier().getDisplayName() + "]";
-        g.drawString(font, tierBadge, vx + 8 + font.width(activeDef.getDisplayName()), textY, 0xFF888888, false);
-        textY += lineHeight + 4;
+        g.drawString(font, nameStr, vx + 8, textY, tierColor, false);
+        g.drawString(font, tierBadge, vx + 8 + font.width(nameStr), textY, 0xFF888888, false);
+        textY += lineHeight + 2;
 
-        // Line 2: Category
+        // Category line
         if (activeDef.getCategory() != null && !activeDef.getCategory().isEmpty()) {
             g.drawString(font, "Category: " + activeDef.getCategory(), vx + 8, textY, 0xFFCCAA00, false);
             textY += lineHeight;
         }
 
-        // Line 3: Description
+        // Description/flavor text (supports multi-line wrapping)
         if (activeDef.getDescription() != null && !activeDef.getDescription().isEmpty()) {
             String desc = activeDef.getDescription();
-            if (font.width(desc) > vw - 20) {
-                while (font.width(desc + "\u2026") > vw - 20 && desc.length() > 3) {
-                    desc = desc.substring(0, desc.length() - 1);
+            int maxWidth = vw - 16;
+
+            // Split into multiple lines if needed
+            List<String> lines = new ArrayList<>();
+            while (!desc.isEmpty() && lines.size() < 2) {
+                if (font.width(desc) <= maxWidth) {
+                    lines.add(desc);
+                    break;
+                }
+                // Find break point
+                int cutIdx = desc.length();
+                while (cutIdx > 0 && font.width(desc.substring(0, cutIdx)) > maxWidth) {
+                    cutIdx--;
+                }
+                // Try to break at space
+                int spaceIdx = desc.lastIndexOf(' ', cutIdx);
+                if (spaceIdx > cutIdx / 2) {
+                    cutIdx = spaceIdx;
+                }
+                lines.add(desc.substring(0, cutIdx).trim());
+                desc = desc.substring(cutIdx).trim();
+            }
+            if (!desc.isEmpty() && lines.size() == 2) {
+                // Add ellipsis to last line if there's more
+                String lastLine = lines.get(1);
+                while (font.width(lastLine + "...") > maxWidth && lastLine.length() > 3) {
+                    lastLine = lastLine.substring(0, lastLine.length() - 1);
+                }
+                lines.set(1, lastLine + "...");
+            }
+
+            for (String line : lines) {
+                g.drawString(font, line, vx + 8, textY, 0xFFAAB0C0, false);
+                textY += lineHeight - 1;
+            }
+        }
+
+        // Costs summary (compact, single line)
+        StringBuilder costsStr = new StringBuilder();
+        if (!activeDef.getItemCosts().isEmpty()) {
+            for (var cost : activeDef.getItemCosts()) {
+                if (costsStr.length() > 0) costsStr.append(", ");
+                costsStr.append(cost.getItem().getDescription().getString()).append(" x").append(cost.count());
+            }
+        }
+        if (activeDef.getFluidCost() != null) {
+            if (costsStr.length() > 0) costsStr.append(" | ");
+            costsStr.append(activeDef.getFluidCost().amount()).append("mB ").append(activeDef.getFluidCost().getFluidName());
+        }
+        if (costsStr.length() > 0) {
+            String costs = "Costs: " + costsStr;
+            if (font.width(costs) > vw - 16) {
+                while (font.width(costs + "...") > vw - 16 && costs.length() > 10) {
+                    costs = costs.substring(0, costs.length() - 1);
                 }
-                desc += "\u2026";
+                costs += "...";
             }
-            g.drawString(font, desc, vx + 8, textY, 0xFFAAB0C0, false);
+            g.drawString(font, costs, vx + 8, textY, 0xFF77AADD, false);
             textY += lineHeight;
         }
 
         // Progress info
-        textY += 8;
+        textY += 4;
         float progress = Math.min(1.0f, menu.getScaledProgress());
         int percent = (int) (progress * 100);
         float totalSeconds = activeDef.getDurationSeconds();
         float remainingSeconds = totalSeconds * (1.0f - progress);
         int mins = (int) (remainingSeconds / 60);
         int secs = (int) (remainingSeconds % 60);
 
-        String progressText = String.format("Progress: %d%% - %d:%02d remaining", percent, mins, secs);
+        String progressText = String.format("Progress: %d%%  |  Time remaining: %d:%02d", percent, mins, secs);
         g.drawString(font, progressText, vx + 8, textY, 0xFFE6EAF5, false);
 
         // Progress bar
@@ -575,14 +628,16 @@ private void renderProgressView(GuiGraphics g, int x, int y) {
         g.fill(barX + barW - 1, barY, barX + barW, barY + barH, PANEL_BORDER_LIGHT);
         g.fill(barX, barY + barH - 1, barX + barW, barY + barH, PANEL_BORDER_LIGHT);
 
-        // Filled portion
+        // Filled portion with gradient effect
         int filledWidth = Math.round((barW - 2) * progress);
         if (filledWidth > 0) {
-            int barColor = nameColor;
-            g.fill(barX + 1, barY + 1, barX + 1 + filledWidth, barY + barH - 1, barColor);
+            g.fill(barX + 1, barY + 1, barX + 1 + filledWidth, barY + barH - 1, tierColor);
+            // Highlight at top of bar
+            int highlightColor = (tierColor & 0x00FFFFFF) | 0x44FFFFFF;
+            g.fill(barX + 1, barY + 1, barX + 1 + filledWidth, barY + 2, highlightColor);
         }
 
-        // Percentage text on bar
+        // Percentage text on bar (centered)
         String pctStr = percent + "%";
         int textWidth = font.width(pctStr);
         g.drawString(font, pctStr, barX + (barW - textWidth) / 2, barY + 2, 0xFFFFFFFF, true);

src/main/java/com/researchcube/client/screen/ResearchTreeScreen.java

@@ -1,8 +1,10 @@
 package com.researchcube.client.screen;
 
+import com.researchcube.ResearchCubeMod;
 import com.researchcube.block.ResearchTableBlockEntity;
 import com.researchcube.menu.ResearchTableMenu;
 import com.researchcube.network.StartResearchPacket;
+import com.researchcube.registry.ModFluids;
 import com.researchcube.research.FluidCost;
 import com.researchcube.research.ItemCost;
 import com.researchcube.research.ResearchDefinition;
@@ -41,10 +43,15 @@
  */
 public class ResearchTreeScreen extends AbstractContainerScreen<ResearchTableMenu> {
 
-    private static final int BG_OUTER = 0xFFC6C6C6;
-    private static final int PANEL_BG = 0xFF252838;
-    private static final int PANEL_DARK = 0xFF121521;
-    private static final int PANEL_LIGHT = 0xFF5A6078;
+    // ── Texture ──
+    private static final ResourceLocation TEXTURE =
+            ResourceLocation.fromNamespaceAndPath(ResearchCubeMod.MOD_ID, "textures/gui/research_table.png");
+    private static final int TEX_W = ResearchTableMenu.GUI_WIDTH;
+    private static final int TEX_H = ResearchTableMenu.GUI_HEIGHT;
+
+    // Colors (for dynamic elements)
+    private static final int PANEL_BORDER_LIGHT = 0xFF7E87A6;
+    private static final int PANEL_BORDER_DARK = 0xFF1A1A1A;
     private static final int GRAPH_BG = 0xFF171A26;
 
     private static final int EDGE_SINGLE = 0xFF9CA3AF;
@@ -408,99 +415,48 @@ protected void renderBg(GuiGraphics g, float partialTick, int mouseX, int mouseY
         int x = leftPos;
         int y = topPos;
 
-        // Outer background
-        g.fill(x, y, x + imageWidth, y + imageHeight, BG_OUTER);
-        g.fill(x, y, x + imageWidth, y + 1, 0xFFFFFFFF);
-        g.fill(x, y, x + 1, y + imageHeight, 0xFFFFFFFF);
-        g.fill(x + imageWidth - 1, y, x + imageWidth, y + imageHeight, PANEL_DARK);
-        g.fill(x, y + imageHeight - 1, x + imageWidth, y + imageHeight, PANEL_DARK);
-
-        // Upper panel (contains graph)
-        drawPanel(g, x + ResearchTableMenu.UPPER_PANEL_X, y + ResearchTableMenu.UPPER_PANEL_Y,
-                ResearchTableMenu.UPPER_PANEL_W, ResearchTableMenu.UPPER_PANEL_H);
-
-        // Machine panel area
-        drawPanel(g, x + ResearchTableMenu.MACHINE_PANEL_X, y + ResearchTableMenu.MACHINE_PANEL_Y,
-                ResearchTableMenu.MACHINE_PANEL_W, 80);
-
-        // Player inventory panel
-        drawPanel(g, x + ResearchTableMenu.PLAYER_INV_X - 8, y + ResearchTableMenu.PLAYER_INV_Y - 10,
-                178, 90);
-
-        // Slot backgrounds for machine panel
-        drawSlotBg(g, x + ResearchTableMenu.DRIVE_X, y + ResearchTableMenu.DRIVE_Y);
-        drawSlotBg(g, x + ResearchTableMenu.CUBE_X, y + ResearchTableMenu.CUBE_Y);
-        for (int row = 0; row < 2; row++) {
-            for (int col = 0; col < 3; col++) {
-                drawSlotBg(g, x + ResearchTableMenu.COST_X + col * 18, y + ResearchTableMenu.COST_Y + row * 18);
-            }
-        }
-        drawSlotBg(g, x + ResearchTableMenu.BUCKET_IN_X, y + ResearchTableMenu.BUCKET_IN_Y);
-        drawSlotBg(g, x + ResearchTableMenu.BUCKET_OUT_X, y + ResearchTableMenu.BUCKET_OUT_Y);
-        drawSlotBg(g, x + ResearchTableMenu.IDEA_CHIP_X, y + ResearchTableMenu.IDEA_CHIP_Y);
+        // ── Static background from texture (same as ResearchTableScreen) ──
+        g.blit(TEXTURE, x, y, 0, 0, imageWidth, imageHeight, TEX_W, TEX_H);
+
+        // ── Fluid gauge (dynamic) ──
         drawFluidGauge(g, x + ResearchTableMenu.FLUID_GAUGE_X, y + ResearchTableMenu.FLUID_GAUGE_Y,
                 ResearchTableMenu.FLUID_GAUGE_W, ResearchTableMenu.FLUID_GAUGE_H);
 
-        // Player inventory slot backgrounds
-        for (int row = 0; row < 3; row++) {
-            for (int col = 0; col < 9; col++) {
-                drawSlotBg(g, x + ResearchTableMenu.PLAYER_INV_X + col * 18, y + ResearchTableMenu.PLAYER_INV_Y + row * 18);
-            }
-        }
-        for (int col = 0; col < 9; col++) {
-            drawSlotBg(g, x + ResearchTableMenu.HOTBAR_X + col * 18, y + ResearchTableMenu.HOTBAR_Y);
-        }
-
-        // Graph viewport
+        // Graph viewport (render on top of texture background)
         int gx = x + GRAPH_X;
         int gy = y + GRAPH_Y;
         g.fill(gx, gy, gx + GRAPH_W, gy + GRAPH_H, GRAPH_BG);
-        g.fill(gx, gy, gx + GRAPH_W, gy + 1, PANEL_DARK);
-        g.fill(gx, gy, gx + 1, gy + GRAPH_H, PANEL_DARK);
-        g.fill(gx + GRAPH_W - 1, gy, gx + GRAPH_W, gy + GRAPH_H, PANEL_LIGHT);
-        g.fill(gx, gy + GRAPH_H - 1, gx + GRAPH_W, gy + GRAPH_H, PANEL_LIGHT);
+        g.fill(gx, gy, gx + GRAPH_W, gy + 1, PANEL_BORDER_DARK);
+        g.fill(gx, gy, gx + 1, gy + GRAPH_H, PANEL_BORDER_DARK);
+        g.fill(gx + GRAPH_W - 1, gy, gx + GRAPH_W, gy + GRAPH_H, PANEL_BORDER_LIGHT);
+        g.fill(gx, gy + GRAPH_H - 1, gx + GRAPH_W, gy + GRAPH_H, PANEL_BORDER_LIGHT);
 
         g.enableScissor(gx + 1, gy + 1, gx + GRAPH_W - 1, gy + GRAPH_H - 1);
         drawEdges(g, gx, gy);
         drawNodes(g, gx, gy);
         g.disableScissor();
     }
 
-    private void drawSlotBg(GuiGraphics g, int sx, int sy) {
-        int x0 = sx - 1;
-        int y0 = sy - 1;
-        g.fill(x0, y0, x0 + 18, y0 + 18, 0xFF8B8B8B);
-        g.fill(x0 + 1, y0 + 1, x0 + 17, y0 + 17, 0xFF30303A);
-        g.fill(x0, y0, x0 + 18, y0 + 1, 0xFF151728);
-        g.fill(x0, y0, x0 + 1, y0 + 18, 0xFF151728);
-    }
-
     private void drawFluidGauge(GuiGraphics g, int gx, int gy, int gw, int gh) {
-        g.fill(gx - 1, gy - 1, gx + gw + 1, gy + gh + 1, 0xFF121521);
-        g.fill(gx, gy, gx + gw, gy + gh, 0xFF1B2030);
+        g.fill(gx - 1, gy - 1, gx + gw + 1, gy + gh + 1, PANEL_BORDER_DARK);
+        g.fill(gx, gy, gx + gw, gy + gh, 0xFF222222);
 
         int fluidAmount = menu.getFluidAmount();
         int fluidType = menu.getFluidType();
         if (fluidAmount > 0 && fluidType > 0) {
             int fillHeight = Math.min(gh, Math.round((float) gh * fluidAmount / ResearchTableBlockEntity.TANK_CAPACITY));
             int fillY = gy + gh - fillHeight;
-            int color = switch (fluidType) {
-                case 1 -> 0xFF00C8FF;
-                case 2 -> 0xFFB05DFF;
-                case 3 -> 0xFFFFC741;
-                case 4 -> 0xFFFF76D6;
-                default -> 0xFF6C768E;
-            };
+            int color = ModFluids.getFluidColor(fluidType);
             g.fill(gx, fillY, gx + gw, gy + gh, color);
+
+            if (fillHeight > 2) {
+                int shine = (color & 0x00FFFFFF) | 0x44000000;
+                g.fill(gx, fillY, gx + gw, fillY + 1, shine);
+            }
         }
-    }
 
-    private void drawPanel(GuiGraphics g, int px, int py, int pw, int ph) {
-        g.fill(px, py, px + pw, py + ph, PANEL_BG);
-        g.fill(px, py, px + pw, py + 1, PANEL_DARK);
-        g.fill(px, py, px + 1, py + ph, PANEL_DARK);
-        g.fill(px + pw - 1, py, px + pw, py + ph, PANEL_LIGHT);
-        g.fill(px, py + ph - 1, px + pw, py + ph, PANEL_LIGHT);
+        g.fill(gx + gw, gy - 1, gx + gw + 1, gy + gh + 1, PANEL_BORDER_LIGHT);
+        g.fill(gx - 1, gy + gh, gx + gw + 1, gy + gh + 1, PANEL_BORDER_LIGHT);
     }
 
     private void drawEdges(GuiGraphics g, int graphScreenX, int graphScreenY) {

src/main/java/com/researchcube/util/TierUtil.java

@@ -12,7 +12,7 @@ private TierUtil() {}
     /**
      * Validates whether a research operation is allowed based on tier rules:
      *   - cube.tier >= research.tier
-     *   - drive.tier == research.tier
+     *   - drive.tier >= research.tier (higher tier drives can research lower tier research)
      *
      * @param cubeTier     the tier of the cube in the Research Table
      * @param driveTier    the tier of the drive in the Research Table
@@ -31,7 +31,7 @@ public static boolean canResearch(ResearchTier cubeTier, ResearchTier driveTier,
         if (!cubeTier.isAtLeast(researchTier)) {
             return false;
         }
-        // Drive must exactly match the research tier
-        return driveTier == researchTier;
+        // Drive must be at least the research tier (higher tier drives can research lower tier)
+        return driveTier.isAtLeast(researchTier);
     }
 }