[pre]package egalib.ega;

import java.awt.Color;

public final class EGAColor
{
    private static final int[] HEX_VALUES = new int[]{
      0x000000, 0x0000aa, 0x00aa00, 0x00aaaa, 0xaa0000, 0xaa00aa, 0xaaaa00, 0xaaaaaa,
      0x000055, 0x0000ff, 0x00aa55, 0x00aaff, 0xaa0055, 0xaa00ff, 0xaaaa55, 0xaaaaff,
      0x005500, 0x0055aa, 0x00ff00, 0x00ffaa, 0xaa5500, 0xaa55aa, 0xaaff00, 0xaaffaa,
      0x005555, 0x0055ff, 0x00ff55, 0x00ffff, 0xaa5555, 0xaa55ff, 0xaaff55, 0xaaffff,
      0x550000, 0x5500aa, 0x55aa00, 0x55aaaa, 0xff0000, 0xff00aa, 0xffaa00, 0xffaaaa,
      0x550055, 0x5500ff, 0x55aa55, 0x55aaff, 0xff0055, 0xff00ff, 0xffaa55, 0xffaaff,
      0x555500, 0x5555aa, 0x55ff00, 0x55ffaa, 0xff5500, 0xff55aa, 0xffff00, 0xffffaa,
      0x555555, 0x5555ff, 0x55ff55, 0x55ffff, 0xff5555, 0xff55ff, 0xffff55, 0xffffff
   };
   
   public static final EGAColor[] EGA_COLORS = new EGAColor[64];
   
   static
   {
       for (int x=0; x<64; x++)
       {
           EGA_COLORS[x] = new EGAColor(x);
       }
   }
   
   public final int index;
   
   public final Color awtColor;
   
   public EGAColor(int index)
   {
       this.index=index;
       this.awtColor = new Color(HEX_VALUES[index]);
   }
}
          
          [/pre]

[pre]package egalib.ega;

import java.awt.*;

public final class EGAGraphics
{
    private EGAColor[] palette = new EGAColor[16];
    
    private Graphics awt;
    
    private int cIndex;
    
    private static final Font 
        F_BIG = new Font("SansSerif",Font.PLAIN,10),
        F_MED = new Font("SansSerif",Font.PLAIN,8),
        F_SMALL = new Font("SansSerif",Font.PLAIN,6);
        
    public static final byte BIG = 1, MED = 2, SMALL = 3;
    
    public EGAGraphics(Graphics g)
    {
        awt=g;
        for (int x=0; x<16; x++)
        {
            palette[x] = EGAColor.EGA_COLORS[x];
        }
        cIndex=0;
        awt.setColor(palette[cIndex].awtColor);
        awt.setFont(F_SMALL);
    }
    
    public void updatePalette(EGAColor color, int index)
    {
        palette[index]=color;
        if (cIndex==index)
            awt.setColor(palette[index].awtColor);
    }
    
    public void setPalette(EGAColor[] palette)
    {
        if (palette.length!=16)
            throw new RuntimeException("Palette must be an array of length 16!");
        for (int x=0; x<16; x++)
        {
            if (palette[x]==null)
                throw new NullPointerException("EGAColor in palette was null!");
            this.palette[x]=palette[x];
        }
    }
    
    public void setColor(int index)
    {
        cIndex=index;
        awt.setColor(palette[index].awtColor);
    }
    
    public void drawRect(int x, int y, int w, int h)
    {
        awt.drawRect(x,y,w,h);
    }
    
    public void fillRect(int x, int y, int w, int h)
    {
        awt.fillRect(x,y,w,h);
    }
    
    public void drawString(String string, int x, int y)
    {
        awt.drawString(string,x,y);
    }
    
    public void drawShape(Shape shape)
    {
        ((Graphics2D)awt).draw(shape);
    }
    
    public void fillShape(Shape shape)
    {
        ((Graphics2D)awt).fill(shape);
    }
    
    public void fontSize(byte _enum)
    {
        switch (_enum)
        {
            case BIG:
                awt.setFont(F_BIG);
                break;
            case SMALL:
                awt.setFont(F_SMALL);
                break;
            case MED:
                awt.setFont(F_MED);
                break;
        }
    }
}
    
    [/pre]

[pre]package egalib.ega;

import java.applet.Applet;
import java.awt.*;
import java.awt.image.*;
import java.awt.geom.*;

public final class EGADisplay
{
    private Applet applet;
    
    private Canvas canvas;
    
    private BufferedImage buffer;
    
    private EGAGraphics graphics;
    
    public EGADisplay(Applet applet)
    {
        this.applet=applet;
        
        applet.setIgnoreRepaint(true);
        applet.setLayout(new BorderLayout());
        
        GraphicsConfiguration config =
            GraphicsEnvironment.getLocalGraphicsEnvironment().
            getDefaultScreenDevice().getDefaultConfiguration();
        canvas = new Canvas(config);
        canvas.setIgnoreRepaint(true);
        applet.add(canvas,BorderLayout.CENTER);
        buffer = config.createCompatibleImage(40,30,Transparency.OPAQUE);
        canvas.requestFocus();
        graphics = new EGAGraphics(buffer.getGraphics());
    }
    
    public EGAGraphics getGraphics()
    {
        return graphics;
    }
    
    public void show()
    {
        Graphics2D g = (Graphics2D)canvas.getGraphics();
        g.setTransform(AffineTransform.getScaleInstance(canvas.getWidth()/buffer.getWidth(),canvas.getHeight()/buffer.getHeight()));
        g.drawImage(buffer,0,0,null);
    }
    
    public void attachInput(EGAInput input)
    {
        canvas.addKeyListener(input);
        canvas.addMouseListener(input);
    }
}[/pre]

[pre]package egalib.ega;

import java.awt.event.*;

public final class EGAInput implements KeyListener, MouseListener
{
    private boolean[] keys = new boolean[256];
    private boolean[] mouse = new boolean[4];
    private int mx,my;
    
    public int mouseX()
    {
        return mx;
    }
    
    public int mouseY()
    {
        return my;
    }
    
    public boolean mouseFocus()
    {
        return mouse[3];
    }
    
    public boolean mouseDown(int button)
    {
        return mouse[button-1];
    }
    
    public boolean keyDown(int key)
    {
        return keys[key];
    }
    
    public void keyPressed(KeyEvent event)
    {
        int code = event.getKeyCode();
        if (code<256)
            keys[code]=true;
    }
    
    public void keyReleased(KeyEvent event)
    {
        int code = event.getKeyCode();
        if (code<256)
            keys[code]=false;
    }
    
    public void mousePressed(MouseEvent event)
    {
        mouse[event.getButton()-1]=true;
        mx = event.getX();
        my = event.getY();
    }
    
    public void mouseReleased(MouseEvent event)
    {
        mouse[event.getButton()-1]=false;
        mx = event.getX();
        my = event.getY();
    }
    
    public void mouseEntered(MouseEvent event)
    {
        mouse[3]=true;
        mx = event.getX();
        my = event.getY();
    }
    
    public void mouseExited(MouseEvent event)
    {
        mouse[3]=false;
        mx = event.getX();
        my = event.getY();
    }
    
    public void keyTyped(KeyEvent e){}
    public void mouseClicked(MouseEvent e){}
}
    [/pre]

[pre]package egalib.game;

import java.applet.Applet;
import egalib.ega.*;

public abstract class EGAGame extends Applet implements Runnable
{
    protected volatile EGADisplay ega_display;
    
    protected volatile EGAInput ega_input;
    
    protected volatile Thread ega_thread;
    
    public final void init()
    {
        ega_display = new EGADisplay(this);
        ega_input = new EGAInput();
        ega_display.attachInput(ega_input);
        ega_load();
    }
    
    public final void start()
    {
        ega_thread = new Thread(this);
        ega_thread.start();
    }
    
    public final void stop()
    {
        ega_thread.interrupt();
        ega_thread = null;
    }
    
    public final void destroy()
    {
        
    }
    
    public final void run()
    {
        while (!ega_thread.isInterrupted())
        {
            ega_update();
            ega_paint(ega_display.getGraphics());
            ega_display.show();
            try
            {
                Thread.sleep(30);
            }
            catch (Exception e){}
        }
    }
    
    public abstract void ega_update();
    public abstract void ega_paint(EGAGraphics g);
    public abstract void ega_load();
}[/pre]