/*
* Copyright (c) 1995 Luis Fernandes
*
* Permission to use, copy, hack, and distribute this software and its
* documentation for NON-COMMERCIAL purposes and without fee is hereby
* granted provided that this copyright notice appears in all copies.
*
*/
/* $Id: Abacus.java,v 1.1.1.1 2002/01/13 18:54:33 gjbadros Exp $ */
/* $Log: Abacus.java,v $
/* Revision 1.1.1.1 2002/01/13 18:54:33 gjbadros
/* Imported based on a staging area from my old CVS tree.
/*
/* Revision 1.1 2000/05/11 22:50:57 gjb
/* Added
/*
# Revision 1.3f 1995/06/01 22:59:31 elf
# Value of each column is now displayed in the top frame.
#
# Redraw (via update) is clipped to a region that surrounds the
# appropriate column that needs updating.
#
# Revision 1.2f 1995/04/17 16:40:13 elf
# Implemented user-defined resource "VALUE" which may to used to set
# the initial condition (bead-configuration) of the abacus.
#
# Eliminated *some* re-draw flicker by moving the repaint() call to
# animateBead() rather than keeping it in moveBead() where it caused
# the applet to redraw everytime a bead moved (this was especially bad
# when several beads moved at once).
# */
import java.awt.*;
/* This is a java-applet simulation of a Chinese abacus.
Each column is stored internally in an integer array called
'column' that is initialized to represent the resting positions of
the beads: 2 bead on top deck row-pos 0 & 1, pos 2 empty; 5 beads
lower deck pos 4-8, pos 3 empty. The initial value is
499d=111110011 where a '1' represents a position that is occupied
by a bead and a '0' represents an empty position. As the beads are
moved, the 1's are shifted (using << and >>) accordingly to
represent their new locations.
*/
/* The illustration below represents 1 column of the abacus.
* O represents the bead;
* | represents an empty position (the rod)
* = represents the frame
*
* ============= Row Position (index 'r' )
* O 0
* O 1 Upper Deck
* | 2
* =============
* | 3
* O 4
* O 5 Lower Deck
* O 6
* O 7
* O 8
* =============
*
*/
public class Abacus extends java.applet.Applet
{
/* initial attributes of the abacus*/
static final int MAXCOLS=10; /* number of columns the abacus will have */
static final int BEADHEIGHT=17;
static final int BEADWIDTH=17;
static final int FRAMEWIDTH=10; /* thickness of the frame*/
static final int COLGAP=2; /* gap between 2 cols*/
static final int ROWGAP=2; /* gap between 2 rows*/
static final int NTOPROWS=3; /*(2 beads, 1 gap on top-deck)*/
static final int NBOTROWS=6; /*(5 beads, 1 gap on top-deck)*/
static final int NCOLS=MAXCOLS; /* number of columns*/
static final int NROWS=(NTOPROWS+NBOTROWS); /* number of rows*/
static final int MIDFRAME=(FRAMEWIDTH+(NTOPROWS*BEADHEIGHT)+((NTOPROWS+1)*ROWGAP));
//size().width & size().height of window depends on attributes of the abacus
static final int INITWIDTH=((2*FRAMEWIDTH)+(NCOLS*BEADWIDTH)+((NCOLS+1)*COLGAP));
static final int INITHEIGHT=((3*FRAMEWIDTH)+(NROWS*BEADHEIGHT)+((NROWS+1)*ROWGAP));
private int column[]=new int[MAXCOLS];
private int cx, cy; // for xlating x,y to row,col
private int ux, uy; // for clipping region
private boolean overflow; // when the abacus overflows this is true
private boolean carry; // when a calc causes a carry to the next col
Image bead, nobead; // holds picture of a bead and an empty loc
Font valueFont; // to paint the value
public
void init()
{
String valattr;
/* Init the internal configuration of the beads: 499d=111110011
* (2 bead on top deck pos 0 & 1; 5 beads lower deck pos 4-8,
* pos 2 & 3 are empty initially) */
for(int i=0; i<MAXCOLS; i++) column[i]=499;
/* check for user-specified value resource*/
valattr=getParameter("value");
/* System.out.println("==>"+valattr); */
if((valattr==null) || (valattr.length()>MAXCOLS) )
{
/* if no attribute is specified, or the value is too big,
* use default*/
System.out.println(valattr+"(VALUE resource) is either too big or unspecified; ignoring.\n");
}
else /* set each column according to the user-specified value*/
{
int len=valattr.length();
for(int i=0; i<len; i++)
{
int val=Integer.valueOf(valattr.substring(i,i+1)).intValue();
// set value in the upper-deck
if(val>4)
{
/* System.out.println("Col "+i+"%5="+val%5); */
animateBead(1, i);
}
// set value in the lower-deck
int remainder=val%5;
if(remainder>0)
{
animateBead(3+remainder, i);
}
}
}
bead=getImage(getCodeBase(), "images/diamond.gif");
nobead=getImage(getCodeBase(), "images/nodiamond.gif");
valueFont=new java.awt.Font("Courier", Font.BOLD, 10);
resize(INITWIDTH, INITHEIGHT); /* initial size */
}
private
void displayValue(Graphics g)
{
char valchars[]= new char [MAXCOLS*3];
String value= new String (valchars);
if(overflow) value+="*";
/* look at each column*/
for(int col=0; col<MAXCOLS; col++)
{
int r;
int val=0;
/* find the empty row, and determine what the value is*/
/* top-deck*/
for(r=2; r>=0; r--)
{
if(!RowOccupied(r, column[col])) break;
}
val+=((2-r)*5);
/* bottom-deck*/
for(r=3; r<9; r++)
{
if(!RowOccupied(r, column[col])) break;
}
val+=(r-3);
/* System.out.println("\tColumn"+col+"value="+val);*/
value=value+" "+Integer.toString(val);
}
if(overflow)
g.setColor(Color.red);
else
g.setColor(Color.yellow);
g.drawString(value, 5, 10);
}
/* draw the abacus */
public
void paint(Graphics g)
{
if (bead == null) {
return;
}
drawFrame(g);
for(int i=0; i<MAXCOLS; i++)
{
drawColumn(g, i);
}
displayValue(g);
}/* init()*/
public void update(Graphics g)
{
paint(g);
g.setColor(Color.black);
g.fillRect(0,0,INITWIDTH, FRAMEWIDTH);
displayValue(g);
}
public
boolean mouseUp(java.awt.Event evt, int x, int y) {
/* row,col returned in cx,cy*/
boolean i=translateXY2RowCol(x, y);
if(i) /*valid row,col...*/
{
if(RowOccupied(cy,column[cx]))
{
animateBead(cy,cx);
ux=FRAMEWIDTH+(cx*(COLGAP+BEADWIDTH));
uy=FRAMEWIDTH+(cy*(ROWGAP+BEADHEIGHT));
repaint();
}
}
return true;
} /*mouseUp()*/
private
void drawColumn(Graphics g, int col)
{
for(int beadnum=0; beadnum<9; beadnum++)
{
if(RowOccupied(beadnum,column[col]))
{
drawBead(g, beadnum, col);
}
else
{
undrawBead(g, beadnum, col);
}
}
} /*drawColumn()*/
private
void drawBead(Graphics g, int row, int col)
{
if(row<3) /* beads in the top-deck */
{
g.drawImage(bead, FRAMEWIDTH+COLGAP+(col*(BEADWIDTH+COLGAP)),
FRAMEWIDTH+(row*(BEADHEIGHT+ROWGAP))+2, this);
}
else /* account for the middle-rail */
{
g.drawImage(bead, FRAMEWIDTH+COLGAP+(col*(BEADWIDTH+COLGAP)),
(2*FRAMEWIDTH)+(row*(BEADHEIGHT+ROWGAP))+2, this);
}
} /*drawBead()*/
private
void undrawBead(Graphics g, int row, int col)
{
if(row<3) /* beads in the top-deck */
{
g.drawImage(nobead, FRAMEWIDTH+COLGAP+(col*(BEADWIDTH+COLGAP)),
FRAMEWIDTH+(row*(BEADHEIGHT+ROWGAP))+2, this);
}
else /* account for the middle-rail */
{
g.drawImage(nobead, FRAMEWIDTH+COLGAP+(col*(BEADWIDTH+COLGAP)),
(2*FRAMEWIDTH)+(row*(BEADHEIGHT+ROWGAP))+2, this);
}
} /*undrawBead()*/
private
void drawFrame(Graphics g)
{
g.setColor(Color.blue);
/* the rails*/
for(int i=0; i<NCOLS; i++)
g.drawLine(FRAMEWIDTH+COLGAP+(BEADWIDTH/2)+(i*(BEADWIDTH+COLGAP)), 0,
FRAMEWIDTH+COLGAP+(BEADWIDTH/2)+(i*(BEADWIDTH+COLGAP)),
INITHEIGHT);
g.setColor(Color.black);
g.fillRect(0,0,INITWIDTH, FRAMEWIDTH); /*top bar*/
g.fillRect(0,INITHEIGHT-FRAMEWIDTH, INITWIDTH, FRAMEWIDTH); /*bot bar*/
g.fillRect(INITWIDTH-FRAMEWIDTH, 0, INITWIDTH, INITHEIGHT); /*right bar*/
g.fillRect(0,0, FRAMEWIDTH, INITHEIGHT-FRAMEWIDTH); /*left bar*/
/* middle bar*/
g.fillRect(0, MIDFRAME, INITWIDTH, FRAMEWIDTH);
}/*drawFrame()*/
public
void animateBead(int r, int c)
{
if(r<3) /* selection in upper deck*/
{
int i;
/* find empty row in upperdeck; pos 0,1,2*/
for(i=0; i<3; i++) if(!RowOccupied(i,column[c])) break;
if(i<r) /* if empty row is above cur bead...*/
moveBeadUp(r,c);
else
moveBeadDn(r,c);
}
else /* selection in lower deck*/
{
int i;
/* find empty row in lowerdeck; pos 3-8 */
for(i=3; i<9; i++) if(!RowOccupied(i,column[c])) break;
if(i<r) /* if empty row is above cur bead...*/
moveBeadUp(r,c);
else
moveBeadDn(r,c);
}
}/*animateBead()*/
private
void moveBeadUp(int r, int c)
{
/* keep looking for an empty position directly above*/
if(RowOccupied(r-1,column[c])) moveBeadUp(r-1,c);
column[c]=column[c]-(1<<r); /* row 'r' is now empty */
column[c]=column[c]+(1<<((r-1))); /* row 'r-1' now is occupied*/
// check whether we have to carry to next column
if(!RowOccupied(0,column[c]))
{
System.out.println("Carry to col"+(c-1));
carry=true;
}
else if(c==0 && r==1)
{
overflow=false;
}
} /*moveBeadUp()*/
private
void moveBeadDn(int r, int c)
{
/* keep looking for an empty position directly below*/
if(RowOccupied(r+1,column[c])) moveBeadDn(r+1,c);
column[c]=column[c]-(1<<r); /* row 'r' is now empty */
column[c]=column[c]+(1<<((r+1))); /* row 'r+1' now is occupied*/
// check whether we have to carry to next column if in the top frame
if(!RowOccupied(0,column[c]) && r<3)
{
if(c==0)
{
System.out.println("***OVERFLOW***");
overflow=true;
return;
}
System.out.println("Carry to col"+(c-1));
carry=true;
}
}/* moveBeadDown()*/
/* ///////////////Misc Functions///////////////////////*/
/* translateXY2RowCol, converts x,y coord a row,col coord. The top
* deck has 3 rows (1 is empty), the bottom deck has 6 rows (1 is
* empty). Row # 3 is invalid because the middle-frame occupies this
* position. Coordinates for the bottom deck are adjusted for this
* anomaly, i.e. row #4 on the screen, is actually index #3 into the
* Column array.
*
* passed: (pointers to) absolute x,y coordinates representing
* the click-location
* returns: - as globals cx, cy, the row (0-9), col (0-NCOLS)
* index
* - True if click was on a bead or empty position
* - False if click was at mid-frame location
*/
private
boolean translateXY2RowCol(int x, int y)
{
cx=(x-FRAMEWIDTH)/(COLGAP+BEADWIDTH);
if(cy<MIDFRAME)
{
cy=(y-FRAMEWIDTH)/(ROWGAP+BEADHEIGHT);
}
else /* account for the middle-frame (+1 bead size().height) (+4 is fudge)*/
{
cy=(y-((2*FRAMEWIDTH)-BEADHEIGHT))/(ROWGAP+BEADHEIGHT);
}
/* technically, the mid-frame occupies position 3 & click is invalid*/
if(cy==3) return(false);
else if(cy>2) /* if pos (row) is greater than 3 ...*/
{
cy--; /* ...adjust by 1 row*/
return(true);
}
else
{
return(true);
}
}/*translateXY2RowCol()*/
final private
boolean RowOccupied(int r, int c)
{
if((c & 1<<(r))==0)
{
return false;
}
else
{
return true;
}
}/*RowOccupied()*/
}
