// knotmosaic.java  compile    javac -cp . knotmosaic.java
//                  execute    java  -cp . knotmosaic
//                  reads knotmosaic.dat  writes knotmosaicw.dat
//                  show  knotmosaic1.dat  2.dat  3.dat  4.dat

import java.io.*;
import java.util.*;
import java.text.*;
import java.awt.*;
import java.awt.event.*;

public class knotmosaic  extends Frame
{
  int win_w = 600;
  int win_h = 660;
  int win_x = 160;
  int win_y = 180;
  int win_cx = 20;
  int win_cy = win_y-40;   
  int n = 10; // grid cells
  int step = 40;
  int  grid[][]  = new int[n][n]; // has chip number
  int  tgrid[][]  = new int[n][n]; // has color 
  Graphics gg;
  Boolean scontinue = false;
  Boolean sgrid = true;
  Boolean debug = false;
  int count = 0; // count
  int score = 0; // score
  int scolor = 1; // red default  0 white
  Color lcolor[] = {Color.white, Color.red, Color.green, Color.blue,
		    Color.yellow, Color.pink, Color.black};
  int chipselected = -1;
  String filename = "knotmosaic.dat";
  int amiss = 0;
    
  public knotmosaic()
  {
    System.out.println("knotmosaic.java running");

    setTitle("knotmosaic");
    setSize(win_w,win_h);
    setBackground(Color.white);
    setForeground(Color.black);
    addWindowListener(new WindowAdapter()
    {
      public void windowClosing(WindowEvent e)
      {
        System.exit(0);
      }
    });

    setVisible(true);
    this.addMouseListener (new mousePressHandler());
    for(int i=0; i<n; i++)
    {
      for(int j=0; j<n; j++)
      {
	grid[i][j] = 0; // no chips
	tgrid[i][j] = 0; // no color
      }
    }
  } // end knotmosaic constructor

  public void paint(Graphics g)
  {
    gg = g;
    g.drawString("Knot Mosaics  select chip, place on grid", 40, 45);
    g.drawString("left click to select chip. left click to place on grid", 40, 60);
    g.drawString("chip", win_cx, win_cy-15);
    g.drawString("grid", win_x,  win_y-15);

    g.drawString("Menu:   show knot1",         40, 75);
    g.drawString("            show knot2",    40, 90);
    g.drawString("            show knot3",    40, 105);
    g.drawString("            show knot4",    40, 120);
    g.drawString("            read file",     40, 135);
    g.drawString("quit",      200, 75);
    g.drawString("clear",     200, 90);
    g.drawString("   ",       200, 105); // was continue
    g.drawString("check",     200, 120);
    g.drawString("write file",200, 135);
    g.drawString("no grid",   300, 75);
    g.drawString("show grid", 300, 90);
    g.drawString("    ",      300, 105);
    g.drawString("miss = "+amiss, 300, 120);
    g.drawString("color",     300, 135);
    g.drawString("file "+filename, 400, 135);
    g.setColor(lcolor[scolor]);
    g.fillRect(340, 125, 10, 10);
    g.setColor(Color.black);
    draw_grid(g);
    draw_chips(g);
    mrun();
    
  } // end paint

  class mousePressHandler extends MouseAdapter
  {
    public void mousePressed (MouseEvent e)
    {
      char key=' ';
      int xm, ym, bm;
      int xc, xlc, yc, ylc;
      int maxgx = win_x+n*step;
      int maxgy = win_y+n*step;
      int maxcx = win_cx+step;
      int maxcy = win_cy+12*(step+5);
      xm = e.getX();
      ym = e.getY();
      bm = e.getButton();
      if(debug) System.out.println("mouse xm="+xm+", ym="+ym+", bm="+bm);
      if(bm==1) // right click  menu and point
      {
        if(     ym>60 && ym<75 && xm>85 && xm<160) { knot1(); }
        else if(ym>75 && ym<90 && xm>85 && xm<160) { knot2(); }
        else if(ym>90 && ym<105 && xm>85 && xm<160) { knot3(); }
        else if(ym>105 && ym<120 && xm>85 && xm<160) { knot4(); }
        else if(ym>120 && ym<135 && xm>85 && xm<160) { mread(); }
        else if(ym>60 && ym<75 && xm>200 && xm<300) { mquit(); }
        else if(ym>75 && ym<90 && xm>200 && xm<300) { mclear(); }
        else if(ym>90 && ym<105 && xm>200 && xm<300) {} // mcontinue();
        else if(ym>105 && ym<120 && xm>200 && xm<300) { mcheck(); }
        else if(ym>120 && ym<135 && xm>200 && xm<300) { mwrite(); }
        else if(ym>60 && ym<75 && xm>300 && xm<400) { mnogrid(); }
        else if(ym>75 && ym<90 && xm>300 && xm<400) { mdogrid(); }
        else if(ym>90 && ym<105 && xm>300 && xm<400) {} // mfaster();
        else if(ym>105 && ym<120 && xm>300 && xm<400) {} // mslower();
        else if(ym>120 && ym<135 && xm>300 && xm<400) { mcolor(); }
        else if(xm>win_x && xm<maxgx && ym>win_y && ym< maxgy)
	       { ongrid(xm,ym); }
	else if(xm>win_cx && xm<maxcx && ym>win_cy && ym< maxcy)
	       { onchip(xm,ym); }
      }
      else // bm==3  left click
      {
	  // mrun();
      }
      requestFocus();
      repaint();
    }
  } // end mousePressHandler

  void ongrid(int xp, int yp)
  {
    int x = xp - win_x;
    int y = yp - win_y;
    int ix = x/step;
    int iy = y/step;
    if(chipselected>0)
    {
      if(debug) System.out.println("ongrid xp="+xp+", yp="+yp+
				   ",ix="+ix+", iy="+iy);
      tgrid[ix][iy] = scolor;
      grid[ix][iy] = chipselected;
      chipselected = 0;
    }
    else if(chipselected==0)
    {
      tgrid[ix][iy] = 0;
      grid[ix][iy] = 0;
    }
  } // end ongrid

  void onchip(int xp, int yp)
  {
    int y = yp - win_cy;
    int c = y/(step+7);
      
    if(debug) System.out.println("onchip xp="+xp+", yp="+yp+", y="+y+",c="+c);
    chipselected = c;
  } // end onchip
    
  void draw_grid(Graphics g)
  {
    int x = win_x;
    int y = win_y;
    int xl = win_x+step*n;
    int yl = win_y+step*n;
    
    if(sgrid)
    {
      setForeground(Color.black);
      g.setColor(Color.black);
    }
    else
    {
      g.setColor(Color.white);
    } // end if
	
    for(int i=0; i<=n; i++)
    {
      g.drawLine(x, y, x, yl);
      x = x + step;
    }
    x = win_x;
    y = win_y;
    for(int j=0; j<=n; j++)
    {
      g.drawLine(x, y, xl, y);
      y = y + step;
    }
  } // end draw_grid 

  void draw_chips(Graphics g)
  {
    int m = 11; // chips to drag and drop
    int x = win_cx;
    int y = win_cy;
    int xl = x+step;
    int yl = y+step;
     
    // g.setColor(lcolor[scolor]);
    // g.setLineWidth(2);
    
    for(int i=0; i<m; i++)
    {
      g.drawLine(x, y, x, yl);
      g.drawLine(xl, y, xl, yl);
      g.drawLine(x, y, xl, y);
      g.drawLine(x, yl, xl, yl);
      drawc(i, x, xl, y, yl);  
      y = y+step+7;
      yl = y+step;
    }
    // g.setLineWidth(1);
  } // end draw_chips 

  void drawc(int i, int x, int xl, int y, int yl)
  { 
    double r = (double)(step/2);
    double Pi = Math.PI;
    double da = Pi/20.0;
    double ang = 0.0;
    double p1x, p1y, p2x, p2y;
    if(debug) System.out.println("drawc i="+i);
    switch(i)
    {
      case 0: break;
      case 1: ang = 0.0;
	      for(int j=0; j<10; j++)
	      {
		p1x = (double)x+r*Math.cos(ang);
		p1y = (double)y+r*Math.sin(ang);
		p2x = (double)x+r*Math.cos(ang+da);
		p2y = (double)y+r*Math.sin(ang+da);
		gg.drawLine((int)p1x, (int)p1y, (int)p2x, (int)p2y);
                ang = ang+da;
	      }  break;
      case 2: ang = 3.0*Pi/2.0;
	      for(int j=0; j<10; j++)
	      {
	        p1x = (double)x+r*Math.cos(ang);
	        p1y = (double)yl+r*Math.sin(ang);
	        p2x = (double)x+r*Math.cos(ang+da);
	        p2y = (double)yl+r*Math.sin(ang+da);
	        gg.drawLine((int)p1x, (int)p1y, (int)p2x, (int)p2y);
                ang = ang+da;
	      }  break;
      case 3: ang = Pi/2.0;
	      for(int j=0; j<10; j++)
	      {
	        p1x = (double)xl+r*Math.cos(ang);
	        p1y = (double)y+r*Math.sin(ang);
	        p2x = (double)xl+r*Math.cos(ang+da);
	        p2y = (double)y+r*Math.sin(ang+da);
	        gg.drawLine((int)p1x, (int)p1y, (int)p2x, (int)p2y);
                ang = ang+da;
	      }  break;
      case 4: ang = Pi;
	      for(int j=0; j<10; j++)
	      {
	        p1x = (double)xl+r*Math.cos(ang);
	        p1y = (double)yl+r*Math.sin(ang);
	        p2x = (double)xl+r*Math.cos(ang+da);
	        p2y = (double)yl+r*Math.sin(ang+da);
	        gg.drawLine((int)p1x, (int)p1y, (int)p2x, (int)p2y);
                ang = ang+da;
	      }  break;
      case 5: ang = 0.0;
	      for(int j=0; j<10; j++)
	      {
	        p1x = (double)x+r*Math.cos(ang);
	        p1y = (double)y+r*Math.sin(ang);
	        p2x = (double)x+r*Math.cos(ang+da);
	        p2y = (double)y+r*Math.sin(ang+da);
	        gg.drawLine((int)p1x, (int)p1y, (int)p2x, (int)p2y);
                ang = ang+da;
	      }
              ang = Pi;
	      for(int j=0; j<10; j++)
	      {
	        p1x = (double)xl+r*Math.cos(ang);
	        p1y = (double)yl+r*Math.sin(ang);
	        p2x = (double)xl+r*Math.cos(ang+da);
	        p2y = (double)yl+r*Math.sin(ang+da);
	        gg.drawLine((int)p1x, (int)p1y, (int)p2x, (int)p2y);
                ang = ang+da;
	      }  break;
      case 6: ang = Pi/2.0;
	      for(int j=0; j<10; j++)
	      {
	        p1x = (double)xl+r*Math.cos(ang);
	        p1y = (double)y+r*Math.sin(ang);
	        p2x = (double)xl+r*Math.cos(ang+da);
	        p2y = (double)y+r*Math.sin(ang+da);
	        gg.drawLine((int)p1x, (int)p1y, (int)p2x, (int)p2y);
                ang = ang+da;
	      }
              ang = 3.0*Pi/2.0;
	      for(int j=0; j<10; j++)
	      {
	        p1x = (double)x+r*Math.cos(ang);
	        p1y = (double)yl+r*Math.sin(ang);
	        p2x = (double)x+r*Math.cos(ang+da);
	        p2y = (double)yl+r*Math.sin(ang+da);
	        gg.drawLine((int)p1x, (int)p1y, (int)p2x, (int)p2y);
                ang = ang+da;
	      }  break;
      case 7: gg.drawLine(x+step/2, y, x+step/2, yl); break;
      case 8: gg.drawLine(x, y+step/2, xl, y+step/2); break;
      case 9: gg.drawLine(x+step/2, y, x+step/2, yl);
	      gg.drawLine(x, y+step/2, x-3+step/2, y+step/2);
              gg.drawLine(x+3+step/2, y+step/2, xl, y+step/2); break;
      case 10: gg.drawLine(x, y+step/2, xl, y+step/2);
              gg.drawLine(x+step/2, y, x+step/2, y-3+step/2);
              gg.drawLine(x+step/2, y+3+step/2, x+step/2, yl); break;
      case 11: // failed check
	      gg.drawLine(x+1, y+3, xl-3, yl-1);
	      gg.drawLine(x+2, y+2, xl-2, yl-2);
	      gg.drawLine(x+3, y+1, xl-1, yl-3);
	      gg.drawLine(xl-1, y+3, x+3, yl-1);
	      gg.drawLine(xl-2, y+2, x+2, yl-2);
	      gg.drawLine(xl-3, y+1, x+1, yl-3);
	      break;
    } // end switch
  } // end drawc
    
  void knot1()
  {
    int dpts[][] = new int[100][4]; // c, chip, x, y
    int npts = 42;
    int x, xl, y, yl;
    dpts[0][0] = 1; // color 
    dpts[0][1] = 4; // chip 
    dpts[0][2] = 1; // x 
    dpts[0][3] = 1; // y 
    dpts[1][0] = 1;
    dpts[1][1] = 2;
    dpts[1][2] = 2;
    dpts[1][3] = 1;
    dpts[2][0] = 1;
    dpts[2][1] = 3;
    dpts[2][2] = 1;
    dpts[2][3] = 2;
    dpts[3][0] = 1;
    dpts[3][1] = 9;
    dpts[3][2] = 2;
    dpts[3][3] = 2;
    dpts[4][0] = 1;
    dpts[4][1] = 2;
    dpts[4][2] = 3;
    dpts[4][3] = 2;
    dpts[5][0] = 1;
    dpts[5][1] = 3;
    dpts[5][2] = 2;
    dpts[5][3] = 3;
    dpts[6][0] = 1;
    dpts[6][1] = 1;
    dpts[6][2] = 3;
    dpts[6][3] = 3;
    dpts[7][0] = 2;
    dpts[7][1] = 4;
    dpts[7][2] = 6;
    dpts[7][3] = 1;
    dpts[8][0] = 2;
    dpts[8][1] = 2;
    dpts[8][2] = 7;
    dpts[8][3] = 1;
    dpts[9][0] = 2;
    dpts[9][1] = 4;
    dpts[9][2] = 5;
    dpts[9][3] = 2;
    dpts[10][0] = 2;
    dpts[10][1] = 10;
    dpts[10][2] = 6;
    dpts[10][3] = 2;
    dpts[11][0] = 2;
    dpts[11][1] = 1;
    dpts[11][2] = 7;
    dpts[11][3] = 2;
    dpts[12][0] = 2;
    dpts[12][1] = 3;
    dpts[12][2] = 5;
    dpts[12][3] = 3;
    dpts[13][0] = 2;
    dpts[13][1] = 1;
    dpts[13][2] = 6;
    dpts[13][3] = 3;
    dpts[14][0] = 3; // y=4
    dpts[14][1] = 4;
    dpts[14][2] = 1;
    dpts[14][3] = 4;
    dpts[15][0] = 3;
    dpts[15][1] = 2;
    dpts[15][2] = 2;
    dpts[15][3] = 4;
    dpts[16][0] = 3;
    dpts[16][1] = 4;
    dpts[16][2] = 5;
    dpts[16][3] = 4;
    dpts[17][0] = 3;
    dpts[17][1] = 2;
    dpts[17][2] = 6;
    dpts[17][3] = 4;
    dpts[18][0] = 3; // y=5
    dpts[18][1] = 3;
    dpts[18][2] = 1;
    dpts[18][3] = 5;
    dpts[19][0] = 3;
    dpts[19][1] = 6;
    dpts[19][2] = 2;
    dpts[19][3] = 5;
    dpts[20][0] = 3;
    dpts[20][1] = 2;
    dpts[20][2] = 3;
    dpts[20][3] = 5;
    dpts[21][0] = 3;
    dpts[21][1] = 4;
    dpts[21][2] = 4;
    dpts[21][3] = 5;
    dpts[22][0] = 3;
    dpts[22][1] = 5;
    dpts[22][2] = 5;
    dpts[22][3] = 5;
    dpts[23][0] = 3;
    dpts[23][1] = 1;
    dpts[23][2] = 6;
    dpts[23][3] = 5;
    dpts[24][0] = 3; // y=6
    dpts[24][1] = 3;
    dpts[24][2] = 2;
    dpts[24][3] = 6;
    dpts[25][0] = 3;
    dpts[25][1] = 6;
    dpts[25][2] = 3;
    dpts[25][3] = 6;
    dpts[26][0] = 3;
    dpts[26][1] = 10;
    dpts[26][2] = 4;
    dpts[26][3] = 6;
    dpts[27][0] = 3;
    dpts[27][1] = 1;
    dpts[27][2] = 5;
    dpts[27][3] = 6;
    dpts[28][0] = 3; // y=7
    dpts[28][1] = 4;
    dpts[28][2] = 2;
    dpts[28][3] = 7;
    dpts[29][0] = 3;
    dpts[29][1] = 10;
    dpts[29][2] = 3;
    dpts[29][3] = 7;
    dpts[30][0] = 3;
    dpts[30][1] = 6;
    dpts[30][2] = 4;
    dpts[30][3] = 7;
    dpts[31][0] = 3;
    dpts[31][1] = 2;
    dpts[31][2] = 5;
    dpts[31][3] = 7;
    dpts[32][0] = 3; // y=8
    dpts[32][1] = 4;
    dpts[32][2] = 1;
    dpts[32][3] = 8;
    dpts[33][0] = 3;
    dpts[33][1] = 5;
    dpts[33][2] = 2;
    dpts[33][3] = 8;
    dpts[34][0] = 3;
    dpts[34][1] = 1;
    dpts[34][2] = 3;
    dpts[34][3] = 8;
    dpts[35][0] = 3;
    dpts[35][1] = 3;
    dpts[35][2] = 4;
    dpts[35][3] = 8;
    dpts[36][0] = 3;
    dpts[36][1] = 6;
    dpts[36][2] = 5;
    dpts[36][3] = 8;
    dpts[37][0] = 3;
    dpts[37][1] = 2;
    dpts[37][2] = 6;
    dpts[37][3] = 8;
    dpts[38][0] = 3; // y=9
    dpts[38][1] = 3;
    dpts[38][2] = 1;
    dpts[38][3] = 9;
    dpts[39][0] = 3;
    dpts[39][1] = 1;
    dpts[39][2] = 2;
    dpts[39][3] = 9;
    dpts[40][0] = 3;
    dpts[40][1] = 3;
    dpts[40][2] = 5;
    dpts[40][3] = 9;
    dpts[41][0] = 3;
    dpts[41][1] = 1;
    dpts[41][2] = 6;
    dpts[41][3] = 9;

    if(debug) System.out.println("menu knot1");
    for(int i=0; i<npts; i++)
    {
      tgrid[dpts[i][2]][dpts[i][3]] = dpts[i][0]; // color
      grid[dpts[i][2]][dpts[i][3]] = dpts[i][1]; // chip
    }

  } // end knot1
    
  void knot2()
  {
    if(debug) System.out.println("menu knot2");
    String filename = "knotmosaic2.dat";

    read(filename);
  } // end knot2

  void knot3()
  {
    if(debug) System.out.println("menu knot3");
    String filename = "knotmosaic3.dat";

    read(filename);
  } // end knot3

  void knot4()
  {
    if(debug) System.out.println("menu knot4");
    String filename = "knotmosaic4.dat";

    read(filename);
  } // end knot4
    
  void mquit()
  {
    if(debug) System.out.println("menu quit");
    System.exit(0);
  } // end mquit

  void mclear()
  {
    if(debug) System.out.println("menu clear");
    count = 0;
    score = 0;
    amiss = 0;
    chipselected = 0;
    gg.setColor(Color.white);
    gg.drawRect(400, 60, 100, 15); // clear count
    gg.drawRect(400, 90, 100, 15); // clear score
    gg.drawRect(300, 130, 50, 15); // clear miss
    for(int i=0; i<n; i++)
    {
      for(int j=0; j<n; j++)
      {
	grid[i][j] = 0;
	tgrid[i][j] = 0;
      } // end j
    } // end i
    draw_grid(gg);
  } // end mclear

  void mcolor()
  {
    if(debug) System.out.println("menu color");
    scolor++;
    if(scolor>6) scolor=1;
    gg.setColor(lcolor[scolor]);
    gg.fillRect(240, 125, 10, 10);
  } // end mcolor

  void mnogrid()
  {
    if(debug) System.out.println("menu no grid");
    sgrid = false;
    draw_grid(gg);
  } // end mnogrid

  void mdogrid()
  {
    if(debug) System.out.println("menu show grid");
    sgrid = true;
    draw_grid(gg);
  } // end mdogrid

  void mpoint(int x, int y)
  {
    int xl = win_x+step*n;
    int yl = win_y+step*n;
    if(debug) System.out.println("menu point x="+x+", y="+y);
    if(x>xl || y>yl) return;
    x = x - win_x;
    y = y - win_y;
    if(x<0 || y<0) return;
    x = x/step;
    y = y/step;
    if(grid[x][y]==scolor)
    {
      grid[x][y] = 0; // delete second click
    }
    else
    {
      grid[x][y] = scolor; // change color OK
    }
  } // end mpoint

  void mcheck() // check chip conections
  {
    int topc[] =  {2, 4, 5, 6, 7, 9, 10};
    int leftc[] = {1, 3, 5, 6, 8, 9, 10};
    int rigtc[] = {1, 2, 5, 6, 9, 8, 10};
    int botc[]  = {1, 3, 5, 6, 7, 9, 10};
    int chip = 0;
    int top = 0;
    int left = 0;
    int rigt = 0;
    int bot = 0;
    int miss = 0;
    int group = 0;
    
    // 1 needs topc, leftc
    // 2 needs leftc, botc
    // 3 needs topc, rigtc
    // 4 needs rigtc, botc
    // 5, 6, 7, 8 needs all four
    if(debug) System.out.println("menu check connections");
    amiss = 0;
    for(int i=0; i<n; i++)
    {
      for(int j=0; j<n; j++)
      {
	if(grid[i][j] != 0)
        {
	  chip = grid[i][j];
	  if(chip < 1 || chip > 10) continue;
	  group = chip;
	  if(chip == 5 || chip == 6 || chip == 9 || chip == 10)  group = 5;
	  if(debug) System.out.println("mcheck group ="+group+", i="+i+", j="+j);

	  top = 5; // default OK
	  if(j != 0) top  = grid[i][j-1];
                     // grid[i][j-1] = 9; // if missing
                     // tgrid[i][j-1] = 6;
	             // miss++;
	  left = 5;
	  if(i != 0) left = grid[i-1][j];
	  rigt = 5;
	  if(i <n-1) rigt = grid[i+1][j];
	  bot = 5;
	  if(j <n-1) bot =  grid[i][j+1];
          if(debug) System.out.println("top="+top+", left="+left+", rigt="+rigt+", bot="+bot);
	  switch(group) // only partly finished, only checking empty
	  {
	    case 1: // need top j-1, and left i-1
	      if(top  == 0) {grid[i][j-1]=9; tgrid[i][j-1]=6; miss++;}
	      if(left == 0) {grid[i-1][j]=9; tgrid[i-1][j]=6; miss++;}
	    break;
	    case 2: // need left i-1, and bot j+1
	      if(left == 0) {grid[i-1][j]=11; tgrid[i-1][j]=6; miss++;}
	      if(bot  == 0) {grid[i][j+1]=11; tgrid[i][j+1]=6; miss++;}
	    break;
	    case 3: // need top j-1, and rigt i+1 
	      if(top  == 0) {grid[i][j-1]=11; tgrid[i][j-1]=6; miss++;}
	      if(rigt == 0) {grid[i+1][j]=11; tgrid[i+1][j]=6; miss++;}
	    break;
	    case 4: // need rigt i+1, and bot j+1
	      if(rigt == 0) {grid[i+1][j]=11; tgrid[i+1][j]=6; miss++;}
	      if(bot  == 0) {grid[i][j+1]=11; tgrid[i][j+1]=6; miss++;}
	    break;
	    case 7: // need top j-1, and bot i+1 
	      if(top  == 0) {grid[i][j-1]=11; tgrid[i][j-1]=6; miss++;}
	      if(bot  == 0) {grid[i][j+1]=11; tgrid[i][j+1]=6; miss++;}
	    break;
	    case 8: // need rigt i+1, and bot j+1
	      if(rigt == 0) {grid[i+1][j]=11; tgrid[i+1][j]=6; miss++;}
	      if(left == 0) {grid[i-1][j]=11; tgrid[i-1][j]=6; miss++;}
	    break;
	    case 5: // need all 4 i+1 i-1 j+1 j-1
	      if(rigt == 0) {grid[i+1][j]=11; tgrid[i+1][j]=6; miss++;}
	      if(left == 0) {grid[i-1][j]=11; tgrid[i-1][j]=6; miss++;}
	      if(bot  == 0) {grid[i][j+1]=11; tgrid[i][j+1]=6; miss++;}
	      if(top  == 0) {grid[i][j-1]=11; tgrid[i][j-1]=6; miss++;}
	    break;	  
          } // end switch
	}
      } // end j
    } // end i
    amiss = miss;
    System.out.println("mcheck amiss ="+amiss);
    
  } // end mcheck

  void mrun()
  {
    int scv[] = {0, 1, 1, 1, 1, 2, 2, 1, 1, 4, 4, 0};
    int x, xl, y, yl;
    
    count=0;
    score=0; // chip
    if(debug) System.out.println("menu run");
    for(int i=0; i<n; i++)
    {
      for(int j=0; j<n; j++)
      {
	score += scv[grid[i][j]]; // tgrid is color
	if(grid[i][j] != 0)
        {
	  count++;
          // tgrid[dpts[i][2]][dpts[i][3]] = dpts[i][0]; // color
          // grid[dpts[i][2]][dpts[i][3]] = dpts[i][1]; // chip
          x = win_x + i*step;
          xl = x+step;
          y = win_y + j*step;
          yl = y+step;
          setForeground(lcolor[tgrid[i][j]]);
          gg.setColor(lcolor[tgrid[i][j]]);
          drawc(grid[i][j], x, xl, y, yl);    
	}
      } // end j
    } // end i
    if(debug) System.out.println("count="+count+", score="+score);
    gg.setColor(Color.white);
    gg.fillRect(400, 60, 100, 15);
    gg.setColor(Color.black);
    gg.drawString("count =     "+count, 400, 75);
    gg.setColor(Color.white);
    gg.fillRect(400, 90, 100, 15);
    gg.setColor(Color.black);
    setForeground(Color.black);
    gg.drawString("score =     "+score, 400, 90);
  } // end mrun  one update

  void mread()
  {
    // String filename = "knotmosaic.dat"; // global default

    read(filename);
  } // end mread
    
  void read(String filename) 
  {
    int dpts[][] = new int[100][4]; // c, chip, x, y
    int npts = 0;    
    StringTokenizer T;
    String token;
    int c, chip, x, y, xl, yl;
    
    System.out.println("reading "+filename);
    try
    {
      FileReader fin = new FileReader(filename);
      BufferedReader in = new BufferedReader(fin);
      String input_line;
      String line;
      int amount;
      int len;
      int index;
      int last;
   
      input_line = in.readLine(); // npts 
      if(debug) System.out.println("input:"+input_line);
      len = input_line.length();
      if(input_line.substring(0,1).equals(" ")) 
      {
        input_line = input_line.substring(1,len);
        if(debug) System.out.println("short input:"+input_line);
      }
      len = input_line.length();
      if(debug) System.out.println("length="+len);
 
      index = 0; // npts
      last = input_line.indexOf(' ',index);
      if(debug) System.out.println("num_index last="+last);
      if(debug) System.out.println(input_line.substring(index,last)+
			 "| len="+(input_line.substring(index,last).length()));
      npts = Integer.parseInt(input_line.substring(index,last));
      if(debug) System.out.println("num_points="+npts);
      
      // read data points, c, chip, x, y
      if(debug) System.out.println("reading c, chip, x, y  data points"); 
      for(int i=0; i<npts; i++)
      {
        input_line = in.readLine();
        len = input_line.length();
        if(input_line.substring(0,1).equals(" ")) 
        {
          input_line = input_line.substring(1,len);
          if(debug) System.out.println("short input:"+input_line);
        }
        if(debug) System.out.println(input_line); 
        T = new StringTokenizer(input_line," ");
        token = T.nextToken(); // c
        amount = Integer.parseInt(token);
        if(debug && i<5) System.out.println("c amount="+amount);
        c = amount;
        token = T.nextToken(); // c
        amount = Integer.parseInt(token);
        if(debug && i<5) System.out.println("chip amount="+amount);
        chip = amount;
        token = T.nextToken(); // x
        amount = Integer.parseInt(token);
        if(debug && i<5) System.out.println("x amount="+amount);
        x = amount;
        token = T.nextToken(); // y
        amount = Integer.parseInt(token);
        if(debug && i<5) System.out.println("y amount="+amount);
        y = amount;
        dpts[i][0] = c;
        dpts[i][1] = chip;
        dpts[i][2] = x;
        dpts[i][3] = y;
      } // end i
    } // end try
    catch(IOException exception)
    {
      System.out.println(filename+" "+exception);
    }
    if(debug) System.out.println("read finished");
    for(int i=0; i<n; i++)
    {
      for(int j=0; j<n; j++)
      {
	grid[i][j] = 0;
      } // end j
    } // end i
    System.out.println("read filling graphics");
    for(int i=0; i<npts; i++)
    {
      tgrid[dpts[i][2]][dpts[i][3]] = dpts[i][0]; // c
      grid[dpts[i][2]][dpts[i][3]] = dpts[i][1]; // chip
      // copy chip lines
      // set color
      x = win_x + dpts[i][2]*step;
      xl = x+step;
      y = win_y + dpts[i][3]*step;
      yl = y+step;
      if(debug) System.out.println("x"+x+", xl="+xl+", y="+y+", yl="+yl);
      gg.setColor(lcolor[dpts[i][0]]);
      drawc(dpts[i][1], x, xl, y, yl);    
    }
  } // end read

  void mwrite()
  {
    // String filename = "knotmosaic.dat"; // global
    int npts = 0;
    
    System.out.println("menu writing "+filename);

    try
    {
      BufferedWriter out = new BufferedWriter(new FileWriter(filename));
      PrintWriter File_out = new PrintWriter(out);
      if(debug) System.out.println("opened "+filename+" for writing");

      for(int i=0; i<n; i++)
      {
        for(int j=0; j<n; j++)
        {
	  if(grid[i][j]!=0)
	  {
	    npts++;
	  }
        } // end j
      } // end i
      File_out.println(npts+" ");
      if(debug) System.out.println("write npts="+npts);
      for(int i=0; i<n; i++)
      {
        for(int j=0; j<n; j++)
        {
	  if(grid[i][j]!=0)
	  {
	    File_out.println(tgrid[i][j]+" "+grid[i][j]+" "+i+" "+j+" ");
	  }
        } // end j
      } // end i
      File_out.close();
    } // end try
    catch(IOException exception)
    {
      System.out.println("knotmosaic.java "+exception);
    }
    if(debug) System.out.println("knotmosaic.java finished writing "+filename);
  } // end mwrite
    
  public static void main (String[] args)
  {
    new knotmosaic();
  }
} // end knotmosaic.java