6 files changed, 420 insertions, 103 deletions

@@ -29,12 +29,12 @@ public class PauseTimer {
         
         if (in.isElapsed())
         {
-            if (ticks == 0)
-            {
-                return true;
-            } else {
-                ticks--;
-            }
+            ticks--;
+        }
+        
+        if (ticks <= 0)
+        {
+            return true;
         }
         
         return false;
@@ -79,7 +79,7 @@ public class ChoiceWindow implements Renderable {
                 g2.drawImage(Window.Selector.getImage(fw-Window.Selector.getLeftX(), fh-Window.Selector.getTopY()), tx-SPACER, ty-fh-SPACER, null);
             }
 
-            g2.setPaint(new TexturePaint(SystemGraphic.getTextColor(), new Rectangle(tx, ty, fw, fh)));
+            g2.setPaint(new TexturePaint(SystemGraphic.getTextColor(0), new Rectangle(tx, ty, fw, fh)));
             g2.drawString(choice, tx, ty);
             
             ty+=(SPACER+fh);
@@ -0,0 +1,79 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.window;
+
+import java.util.regex.MatchResult;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+
+/**
+ *
+ * @author hatkirby
+ */
+public enum MessageEscape
+{
+    Color("\\\\C\\[(\\d+)\\]"),
+    Pause("\\\\P");
+
+    private Pattern pattern;
+    private MessageEscape(String pattern)
+    {
+        this.pattern = Pattern.compile(pattern);
+    }
+
+    public static String removeEscapes(String message)
+    {
+        for (MessageEscape escape : values())
+        {
+            message = escape.pattern.matcher(message).replaceAll("");
+        }
+
+        return message;
+    }
+
+    public boolean match(String substring)
+    {
+        Matcher m = pattern.matcher(substring);
+        
+        return (m.lookingAt() && (m.start() == 0));
+    }
+    
+    public String removeEscape(String message)
+    {
+        return pattern.matcher(message).replaceFirst("");
+    }
+
+    MessageEscapePair getMatch(String substring)
+    {
+        Matcher m = pattern.matcher(substring);
+        m.lookingAt();
+        
+        return new MessageEscapePair(this, m.toMatchResult());
+    }
+}
+
+class MessageEscapePair
+{
+    MessageEscape escape;
+    MatchResult match;
+    
+    public MessageEscapePair(MessageEscape escape, MatchResult match)
+    {
+        this.escape = escape;
+        this.match = match;
+    }
+    
+    public MessageEscape getMessageEscape()
+    {
+        return escape;
+    }
+    
+    public MatchResult getMatchResult()
+    {
+        return match;
+    }
+}
\ No newline at end of file
@@ -14,11 +14,7 @@ import com.fourisland.fourpuzzle.util.Inputable;
 import com.fourisland.fourpuzzle.util.Interval;
 import com.fourisland.fourpuzzle.util.Renderable;
 import java.awt.Graphics2D;
-import java.awt.Rectangle;
-import java.awt.TexturePaint;
 import java.awt.image.BufferedImage;
-import java.util.ArrayList;
-import java.util.List;
 import java.util.concurrent.CountDownLatch;
 
 /**
@@ -30,10 +26,9 @@ public class MessageWindow implements Renderable {
     private static final int SPACER = 4;
     private static final int HEIGHT = (4*(Display.getFontMetrics().getHeight()+SPACER));
     
-    private volatile List<String> messages;
+    TextRenderer tr;
     int width;
     BufferedImage cacheBase;
-    int num = 0;
     int upTo = 0;
     boolean bounceArrow = false;
     Interval in = Interval.createTickInterval(4);
@@ -42,7 +37,9 @@ public class MessageWindow implements Renderable {
         width = Game.WIDTH - Window.Default.getFullWidth(0);
         cacheBase = Window.Default.getImage(width, HEIGHT);
         
-        initalizeMessages(message);
+        tr = new TextRenderer(width);
+        tr.setEscapes(true);
+        tr.initalizeText(message);
     }
     
     boolean hasFace = false;
@@ -55,7 +52,10 @@ public class MessageWindow implements Renderable {
         this.face = FaceSet.getFaceSet(faceSet).getImage(face);
         hasFace = true;
         
-        initalizeMessages(message);
+        tr = new TextRenderer(width);
+        tr.setEscapes(true);
+        tr.setIndent(48 + (SPACER*2));
+        tr.initalizeText(message);
     }
     
     private static void displayMessage(final MessageWindow mw) throws InterruptedException
@@ -101,96 +101,24 @@ public class MessageWindow implements Renderable {
         displayMessage(new MessageWindow(message, faceSet, face));
     }
     
-    private void initalizeMessages(String message)
-    {
-        messages = new ArrayList<String>();
-        
-        int length = width - SPACER;
-        if (hasFace)
-        {
-            length -= (48 + (SPACER*3));
-        }
-        
-        String temp = message;
-        int len = 0;
-        while (!temp.isEmpty())
-        {
-            while ((Display.getFontMetrics().stringWidth(temp.substring(0, len)) < length) && (len < temp.length()))
-            {
-                len++;
-            }
-
-            if (len != temp.length())
-            {
-                while ((!temp.substring(len, len+1).equals(" ")) && (len > 0))
-                {
-                    len--;
-                }
-            }
-            
-            messages.add(temp.substring(0, len));
-            
-            if (len != temp.length())
-            {
-                temp = temp.substring(len+1);
-            } else {
-                temp = "";
-            }
-            
-            len = 0;
-        }
-        
-        setLength();
-    }
-    
-    private void setLength()
-    {
-        num = 0;
-        
-        for (int i=0;i<Math.min(messages.size(),4);i++)
-        {
-            num += messages.get(i).length();
-        }
-    }
-    
     public void render(Graphics2D g2)
     {
         int y = MessageWindowLocation.Bottom.getY();
-
-        Display.setFont(g2);
         
         g2.drawImage(cacheBase, 0, y, null);
         
         int fh = g2.getFontMetrics().getHeight();
-        int tx = Window.Default.getLeftX();
         int ty = Window.Default.getTopY()+fh-(SPACER/2)+y;
-        int msgs = Math.min(messages.size(), 4);
-        int toPrint = upTo;
         
         if (hasFace)
         {
-            g2.drawImage(face, tx+SPACER, ty-fh+SPACER, null);
-
-            tx += 48 + (SPACER*2);
+            g2.drawImage(face, Window.Default.getLeftX()+SPACER, ty-fh+SPACER, null);
         }
         
-        for (int i=0;i<msgs;i++)
-        {
-            String message = messages.get(i);
-            int fw = g2.getFontMetrics().stringWidth(message);
-            
-            g2.setPaint(new TexturePaint(SystemGraphic.getTextColor(), new Rectangle(tx, ty, fw, fh)));
-            g2.drawString(message.substring(0, Math.min(toPrint, message.length())), tx, ty);
-            
-            ty+=(SPACER+fh);
-            
-            toPrint -= Math.min(toPrint, message.length());
-        }
+        g2.drawImage(tr.render(upTo), Window.Default.getLeftX(), Window.Default.getTopY()+y, null);
         
-        if (upTo < num)
+        if (tr.isCascadingDone())
         {
-            upTo+=3;
-        } else {
             g2.drawImage(SystemGraphic.getDownArrow(), (Window.Default.getFullWidth(width)/2)-5, y+HEIGHT+SPACER+(bounceArrow ? 1 : 0), null);
             
             if (in.isElapsed())
@@ -202,20 +130,19 @@ public class MessageWindow implements Renderable {
     
     private synchronized boolean pushEnter()
     {
-        if (upTo >= num)
+        if (tr.isCascadingDone())
         {
-            int msgs = messages.size();
-            for (int i=0;i<Math.min(4, msgs);i++)
+            int msgs = tr.numLines();
+            if (upTo >= (msgs-4))
             {
-                messages.remove(0);
-            }
-            
-            if (messages.size() > 0)
-            {
-                upTo = 0;
-                setLength();
-            } else {
                 return true;
+            } else {
+                upTo += 4;
+                
+                if (upTo > msgs)
+                {
+                    upTo = msgs;
+                }
             }
         }
         
@@ -64,14 +64,19 @@ public class SystemGraphic {
         return systemGraphic.getSubimage(sca.x, sca.y, sca.width, sca.height);
     }
     
-    public static BufferedImage getTextColor()
+    public static BufferedImage getTextColor(int color)
     {
         if (systemGraphic == null)
         {
             initalize();
         }
         
-        return systemGraphic.getSubimage(0, 48, 16, 16);
+        if (color < 10)
+        {
+            return systemGraphic.getSubimage(color*16, 48, 16, 16);
+        } else {
+            return systemGraphic.getSubimage(color*16, 64, 16, 16);
+        }
     }
     
     public static BufferedImage getUpArrow()
@@ -0,0 +1,306 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.fourisland.fourpuzzle.window;
+
+import com.fourisland.fourpuzzle.Display;
+import com.fourisland.fourpuzzle.Game;
+import com.fourisland.fourpuzzle.util.PauseTimer;
+import java.awt.Graphics2D;
+import java.awt.Rectangle;
+import java.awt.TexturePaint;
+import java.awt.image.BufferedImage;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Vector;
+
+/**
+ *
+ * @author hatkirby
+ */
+public class TextRenderer {
+    
+    private static final int SPACER = 4;
+    
+    private boolean initalized = false;
+    private int width;
+    private List<LineOfText> messages = new ArrayList<LineOfText>();
+    
+    public TextRenderer(int width)
+    {
+        this.width = width;
+    }
+    
+    private boolean useEscapes = false;
+    public void setEscapes(boolean use)
+    {
+        if (initalized == true)
+        {
+            throw new IllegalStateException("Already initalized");
+        }
+        
+        useEscapes = use;
+    }
+    
+    private int indent = 0;
+    public void setIndent(int indent)
+    {
+        if (initalized == true)
+        {
+            throw new IllegalStateException("Already initalized");
+        }
+        
+        this.indent = indent;
+    }
+    
+    public void initalizeText(String message)
+    {
+        if (initalized == true)
+        {
+            throw new IllegalStateException("Already initalized");
+        }
+        
+        int length = width - SPACER - indent;
+        int len = 0;
+        LineOfText temp = new LineOfText(message);
+        
+        if (useEscapes)
+        {
+            for (int i=0; i<temp.length(); i++)
+            {
+                if (temp.toString().substring(i, i+1).equals("\\"))
+                {
+                    for (MessageEscape escape : MessageEscape.values())
+                    {
+                        if (escape.match(temp.toString().substring(i)))
+                        {
+                            temp.addEscape(i, escape.getMatch(temp.toString().substring(i)));
+                            temp = new LineOfText(escape.removeEscape(temp.toString()), temp.escapes);
+                            
+                            break;
+                        }
+                    }
+                }
+            }
+            
+            temp = new LineOfText(MessageEscape.removeEscapes(temp.toString()), temp.escapes);
+        }
+        
+        while (!temp.toString().isEmpty())
+        {
+            while ((Display.getFontMetrics().stringWidth(temp.toString().substring(0, len)) < length) && (len < temp.length()))
+            {            
+                len++;
+            }
+
+            if (len != temp.toString().length())
+            {
+                while ((!temp.toString().substring(len, len+1).equals(" ")) && (len > 0))
+                {
+                    len--;
+                }
+            }
+            
+            messages.add(temp.part(0, len));
+            
+            if (len != temp.length())
+            {
+                temp = temp.part(len+1, temp.length());
+            } else {
+                break;
+            }
+            
+            len = 0;
+        }
+        
+        initalized = true;
+    }
+    
+    int upTo = Integer.MIN_VALUE;
+    int num = 0;
+    int lastStart = Integer.MIN_VALUE+1;
+    PauseTimer pt = new PauseTimer(0);
+    public BufferedImage render(int start)
+    {
+        if (initalized == false)
+        {
+            throw new IllegalStateException("TextRenderer must be initalized prior to rendering");
+        }
+        
+        if (lastStart != start)
+        {
+            num = 0;
+            for (int i=start;i<Math.min(messages.size(),start+4);i++)
+            {
+                num += messages.get(i).length();
+            }
+            
+            lastStart = start;
+            upTo = 0;
+        }
+        
+        BufferedImage temp = Display.createCanvas(width, Game.HEIGHT);
+        Graphics2D g = temp.createGraphics();
+        Display.setFont(g);
+        
+        int currentColor = 0;
+        
+        int fh = g.getFontMetrics().getHeight();
+        int ty = fh-(SPACER/2);
+        int toPrint = upTo;
+        int end = Math.min(messages.size(), start+4);
+        
+        for (int i=start;i<end;i++)
+        {
+            LineOfText message = messages.get(i);
+            int tx = indent;
+            g.setPaint(new TexturePaint(SystemGraphic.getTextColor(currentColor), new Rectangle(0, ty, width, fh)));
+            
+            for (int j=0;j<Math.min(toPrint, message.length());j++)
+            {
+                boolean breakout = false;
+                for (MessageEscapePair escape : message.getEscapes(j))
+                {
+                    switch (escape.getMessageEscape())
+                    {
+                        case Color: currentColor = Integer.decode(escape.getMatchResult().group(1));
+                                    g.setPaint(new TexturePaint(SystemGraphic.getTextColor(currentColor), new Rectangle(0, ty, width, fh)));
+                                    
+                                    break;
+                                    
+                        case Pause: pt.setTimer(10);
+                                    message.getEscapes(j).remove(escape);
+                        
+                                    breakout = true;
+                                    break;
+                    }
+                    
+                    if (breakout)
+                    {
+                        break;
+                    }
+                }
+            
+                g.drawString(message.toString().substring(j, j+1), tx, ty);
+                
+                tx+=(g.getFontMetrics().stringWidth(message.toString().substring(j, j+1)));
+            }
+            
+            ty+=(SPACER+fh);
+            
+            toPrint -= Math.min(toPrint, message.length());
+        }
+        
+        if (pt.isElapsed() && (upTo < num))
+        {
+            upTo+=3;
+        }
+        
+        return temp;
+    }
+    
+    public int numLines()
+    {
+        return messages.size();
+    }
+    
+    public boolean isCascadingDone()
+    {
+        return (upTo >= num);
+    }
+
+}
+
+class LineOfText implements CharSequence
+{
+    String line;
+    Map<Integer, Vector<MessageEscapePair>> escapes = new HashMap<Integer, Vector<MessageEscapePair>>();
+    public LineOfText(String line)
+    {
+        this.line = line;
+    }
+
+    public LineOfText(String line, Map<Integer, Vector<MessageEscapePair>> escapes)
+    {
+        this.line = line;
+        
+        for (int i=0; i<line.length(); i++)
+        {
+            if (escapes.containsKey(i))
+            {
+                for (MessageEscapePair escape : escapes.get(i))
+                {
+                    addEscape(i, escape);
+                }
+            }
+        }
+    }
+    
+    public void addEscape(int index, MessageEscapePair escape)
+    {
+        if (!escapes.containsKey(index))
+        {
+            escapes.put(index, new Vector<MessageEscapePair>());
+        }
+        
+        escapes.get(index).add(escape);
+    }
+    
+    public Vector<MessageEscapePair> getEscapes(int index)
+    {
+        if (!escapes.containsKey(index))
+        {
+            return new Vector<MessageEscapePair>();
+        } else {
+            return escapes.get(index);
+        }
+    }
+    
+    public LineOfText part(int start, int end)
+    {
+        LineOfText temp = new LineOfText(line.substring(start, end));
+        
+        for (int i=start; i<end; i++)
+        {
+            if (escapes.containsKey(i))
+            {
+                for (MessageEscapePair escape : escapes.get(i))
+                {
+                    temp.addEscape(i, escape);
+                }
+            }
+        }
+        
+        return temp;
+    }
+    
+    @Override
+    public String toString()
+    {
+        return line;
+    }
+    
+    public void setString(String message)
+    {
+        this.line = message;
+    }
+
+    public int length()
+    {
+        return line.length();
+    }
+
+    public char charAt(int index)
+    {
+        return line.charAt(index);
+    }
+
+    public CharSequence subSequence(int start, int end)
+    {
+        return line.subSequence(start, end);
+    }
+}
\ No newline at end of file