package voltage;
import java.awt.*;
import java.lang.Math;
import java.lang.Integer;
/**
* Parameters:
* VOLTAGE=int Voltage level of the battery. Defaults to 10
* AMPERAGE=int Amperage level of the lightbulb. Defaults to 2
*
* Synopsis:
*
* - Mon Aug 21 14:53:02 PDT 1995
* This tool allows users to derive the relationship between voltage,
* resistance, and amplitude through experimentation. Given a circuit
* containing a battery with a voltage and a lightbulb with an amperage,
* the user inserts resistors into the circuit. If the resistance is
* too low, the lightbulb explodes. If the resistance is too high,
* the lightbulb fails to light.
*
* History is located at the end of the sourcecode.
*
* @author Sean Russell
* Department of Computing and Information Sciences, University of Oregon
* Department of Physics, University of Oregon
*/
public class voltage extends java.applet.Applet
{
Resistance resistance; // The resistance array
int rwidth, rheight; // Resistor glyph idth and height
int bwidth, bheight;
int cx, cy, cw, ch; // Clipping area.
int ocx, ocy, ocw, och;
int ix = 0, iy = 0; // The x/y coords of whatever we're dragging
Image bang;
Image lightcircuit;
int voltage; // Voltage of the battery
Image lightbulb_on, lightbulb_broken;
Image lightswitch_on, battery;
Battery batts[] = new Battery[4];
int amperage; // Amperage of the lightbulb
boolean switch_on=false; // Whether the switch is on or not.
int rangeXStart, rangeYStart, // The location of the circuit area into
rangeXEnd, rangeYEnd; // which resistors can be dropped
int max_resistors = 6; // Max number of resistors
int max_width = 600; // Max width of the app window
int max_height = 150; // The max height of the app window
int bar = 30; // The y value on which the circuit
// lies.
int res_selected = 0; // 0 if no resistor is being dragged,
// <0 if a new resistor is being dragged,
// >0 if an old resistor is being dragged.
int bat_selected = 0; // 0 if no battery is being dragged,
// >0 if a new battery is being dragged.
boolean hide; // Determines whether the amperage is
// displayed.
boolean auplay = false;
/**
* gets the images and initializes all of the drawing area values.
* Reads arguments to the applet and makes sure that they are legal;
* if not, adjusts them until they are legal, and if arguments weren't
* given, generates random values.
*/
public void init()
{
int sv;
amperage = Integer.parseInt((getParameter("amperage") == null) ?
"2" : getParameter("amperage"));
voltage = Integer.parseInt((getParameter("voltage") == null) ?
"12" :
getParameter("voltage"));
hide = (getParameter("hide") == null) ? false : true;
if (voltage < amperage) throw new IllegalArgumentException("Bad circuit values");
while ((voltage % amperage) != 0)
{
voltage--;
if (voltage < amperage) voltage *= 10;
}
Image r = getImage(getCodeBase(), "images/resistor.gif");
lightswitch_on = getImage(getCodeBase(), "images/lightswitch-on.gif");
// Resistor dimensions
rwidth = 50;
rheight = 18;
battery = getImage(getCodeBase(), "images/battery.gif");
if (battery == null)
throw new IllegalArgumentException("images/battery.gif not found");
sv = ((voltage/2)<amperage) ? voltage : voltage/2 ;
sv = ((sv % amperage) != 0) ? voltage : sv;
for (int i=0; i<4; i++)
{
batts[i] = new Battery(this, battery, (i+1)*sv,
123 + ((battery.getWidth(this)+10)*i),
3+rheight+2);
}
// Main Battery dimensions (more or less... used for other calculations)
bwidth = 110;
bheight = 57;
lightcircuit = getImage(getCodeBase(), "images/light-circuit.gif");
bang = getImage(getCodeBase(), "images/bang1.gif");
lightbulb_on = getImage(getCodeBase(), "images/bulb-glow.gif");
lightbulb_broken = getImage(getCodeBase(), "images/bulb-broken.gif");
// Set up the area where the resistor glyphs in the circuit go
rangeXStart = bwidth;
rangeXEnd = bwidth + (rwidth*max_resistors);
rangeYStart = bar + bheight;
rangeYEnd = bar + bheight + 18;
resistance = new Resistance(this, max_resistors, r, rangeXStart, rangeYStart);
// Default clipping area
cx = cy = 0;
cw = max_width;
ch = max_height;
resize(max_width, max_height);
}
Image offimg;
Graphics offg;
public void paint(Graphics g) {
update(g);
}
public void update(Graphics g)
{
if (resistance == null) {
return;
}
if (offimg == null) {
Dimension d = size();
offimg = createImage(d.width, d.height);
offg = offimg.getGraphics();
}
String total = new String("Total Resistance: ");
int resist = resistance.resistance();
// Clear the screen
offg.setColor(getBackground());
offg.fillRect(0,0,max_width,max_height);
// Draw the dropzone for the circuit
offg.draw3DRect(rangeXStart-2, rangeYStart-2,
rangeXEnd - rangeXStart + 4,
rangeYEnd - rangeYStart + 4,
false);
offg.drawImage(lightcircuit, 0, bar, this);
offg.setColor(Color.black);
Output.print(offg, voltage, 30, bar+65);
if (!hide)
Output.print(offg, amperage, max_width - 47, bar+37);
total += Integer.toString(resist);
Output.print(offg, total, rangeXStart, rangeYEnd+16);
// Draw the resistors in the toolbox
offg.fill3DRect(100, 0, ((rwidth+10)*5)- 4,
3 + rheight + 2 + battery.getHeight(this) + 2,
false);
for (int i=0; i < 5; i++)
resistance.draw(offg, (int)Math.pow(2, i),
103 + ((rwidth+10)*i), 3);
for (int i=0; i < 4; i++)
batts[i].draw(offg);
// Draw the resistors in the circuit
resistance.draw(offg);
// Handle switch events
if (switch_on)
{
offg.setColor(getBackground());
offg.fillRect(469, bar, 32, 70);
offg.drawImage(lightswitch_on, 465, bar+23, this);
if ((amperage * resist) < voltage) // Blow up: too little resistance
{
if (auplay)
{
// Blow up: too little resistance
if ((amperage * resistance.resistance()) < voltage)
play(getCodeBase(), "sounds/electricity.au");
try {Thread.sleep(200);} catch (InterruptedException e){}
offg.drawImage(bang, 530, bar + 10, this);
try {Thread.sleep(100);} catch (InterruptedException e){}
auplay = false;
}
offg.setColor(getBackground());
offg.fillRect(530, bar + 8, bang.getWidth(this), bang.getHeight(this)+2);
offg.drawImage(lightbulb_broken, 542, bar + 20, this);
Output.print(offg, amperage, max_width + 20, bar-10);
}
else if ((amperage * resist) == voltage) // V=IR: Just right.
{ // Light the bulb
offg.drawImage(lightbulb_on, 542, bar + 20, this);
Output.print(offg, amperage, max_width + 20, bar-10);
}
}
if (res_selected != 0) // We're dragging a resistor; we draw it
resistance.draw(offg, Math.abs(res_selected), ix, iy);
if (bat_selected != 0) // We're dragging a battery; we draw it
batts[bat_selected - 1].draw(offg, ix, iy);
cx = cy = 0;
cw = max_width;
ch = max_height;
g.drawImage(offimg, 0, 0, null);
}
/**
* Initializes clipping variables; checks to see if the user clicked
* in the toolbox, in the resistance box, or on the switch, and
* reacts accordingly.
*/
public boolean mouseDown(java.awt.Event evt, int x, int y)
{
// We have to set up some variables for erasing
ix = ocx = (x - (rwidth/2));
iy = ocy = (y - (rheight/2));
// Check to see if they mouse downed in the new resistor
// area.
for (int i=0; i < 5; i++)
{
if ((x > ((i*(rwidth+10))+102)) &&
(x < ((i*(rwidth+10))+102+rwidth)) &&
(y > 2) && (y < rheight+3))
res_selected = (int)Math.pow(2, i)*-1;
}
// Check to see if they mouse downed on a new battery
if (res_selected == 0)
{
for (int i=0; i<4; i++)
if (batts[i].in(x, y)) bat_selected = i+1;
}
// If they didn't click on a new resistor, check to see
// if they clicked on an old resistor.
if ((res_selected == 0) && (bat_selected == 0))
res_selected = resistance.mouseDown(x, y);
// Check to see if they clicked on the onswitch
// to turn it on.
if ((res_selected == 0) && (bat_selected == 0))
{
if ((x<504) && (x>465) &&
(y<(bar+56)) && (y>bar))
switch_on = (switch_on)?false:true;
else
switch_on = false;
auplay = true;
}
repaint();
return true;
}
/**
* Adjusts clipping values for drags, and ignores the event otherwise.
*/
public boolean mouseDrag(java.awt.Event evt, int x, int y)
{
int w = 0,
h = 0;
if (res_selected != 0) // We only care about drag events if
{ // we're carrying something
w = rwidth;
h = rheight;
}
else if (bat_selected != 0)
{
w = battery.getWidth(this);
h = battery.getHeight(this);
}
if (w != 0)
{
// The following centers the object on the mouse
x -= w/2;
y -= h/2;
cx = Math.max(0, Math.min(Math.min(ocx, x), max_width));
cy = Math.max(0, Math.min(Math.min(ocy, y), max_height));
cw = Math.min(Math.abs(ocx-x)+ w , max_width-cx);
ch = Math.min(Math.abs(ocy-y)+ h , max_height-cy);
ocx = ix = x;
ocy = iy = y;
repaint();
}
return true;
}
/**
* Checks for dropping a resistor in the droprange and
* adds a resistor if so.
* Also checks for dropping a new battery on the main battery,
* and changes the main batt value if so.
*/
public boolean mouseUp(java.awt.Event evt, int x, int y)
{
if (res_selected != 0) // We only care about mouseUp events
{ // if we were carrying something
// Check to see if we're in the drop range
if ((x<rangeXEnd) && (x>rangeXStart) &&
(y<rangeYEnd) && (y>rangeYStart))
{
resistance.add(Math.abs(res_selected));
} // that they were dragging something:
res_selected = 0; // Add a new, or re-add an old
repaint();
}
if (bat_selected != 0)
{
if ((x < 73) && (y > (bar+50)) && (y < (bar+107)))
voltage = batts[bat_selected - 1].voltage;
bat_selected = 0;
repaint();
}
return true;
}
/**
* Just calls repaint()
*/
public void start()
{
repaint();
}
}
/**
* Dummy class to consolidate output functions in one place
*
* @author Sean Russell
*/
class Output
{
/**
* Print an integer value in g at (x,y)
*/
public static void print(Graphics g, int val, int x, int y)
{
g.setColor(Color.black);
g.drawString(Integer.toString(val), x+1, y+1);
g.drawString(Integer.toString(val), x+1, y);
g.setColor(Color.blue);
g.drawString(Integer.toString(val), x, y);
}
/**
* Print a string in g at (x,y)
*/
public static void print(Graphics g, String val, int x, int y)
{
g.setColor(Color.black);
g.drawString(val, x+1, y+1);
g.drawString(val, x+1, y);
g.setColor(Color.blue);
g.drawString(val, x, y);
}
}
/**
* Resistance represents the total resistance along a circuit, and is made
* up of resistors. The resistance in the wire itself can be represented
* by an additional resistor.
*
* @author Sean Russell
*/
class Resistance
{
Resistor resistor[];
Image res;
int num_resistors = 0;
int max_resistors = 0;
int xs, ys;
voltage parent;
/**
* Creates a resistance circuit given the number of resistors
* and the glyph to represent the resistors.
*/
Resistance(voltage parent, int num, Image i, int xs, int ys)
{
this.parent = parent;
res = i;
resistor = new Resistor[num];
max_resistors = num;
this.xs = xs;
this.ys = ys;
}
/**
* Draws all resistors on the circuit. Given a graphics context
* and the (x,y) start coordinates.
*/
public void draw(Graphics g)
{
for (int i=0; i < num_resistors; i++)
{
g.drawImage(res, resistor[i].x, resistor[i].y, parent);
Output.print(g, resistor[i].resistance,
resistor[i].x + 20, resistor[i].y + 14);
}
}
/**
* Draws a single resistor given graphics context g, the resistance
* val, and the (x,y) coordinates to draw the glyph at.
* val is the factor of the resistor, not the actual resistance
*/
public void draw(Graphics g, int val, int x, int y)
{
g.drawImage(res, x, y, parent);
Output.print(g, val, x+20, y+14);
}
/**
* Adds a resistor with resistance size to the circuit.
* size is the factor of the resistor
*/
public void add(int size)
{
if (num_resistors < max_resistors)
{
num_resistors++;
resistor[num_resistors-1] =
new Resistor(size, res,
xs + ((num_resistors-1)*res.getWidth(parent)),
ys);
}
}
/**
* Checks to see if the mouseDown occurs over a resistor in
* the circuit, and if so, selects that resistor.
*/
public int mouseDown(int x, int y)
{
int sel = 0;
int val = 0;
for (int i=0; (i < num_resistors) && (sel==0); i++)
if (resistor[i].in(x, y)) sel = i+1;
if (sel != 0) val = resistor[sel-1].resistance;
if (sel != 0) remove(sel);
return val;
}
/**
* Removes the indexed resistor.
* which = [1, num_resistors]
*/
public void remove(int which)
{
for (int i=which-1; i < (num_resistors-1); i++)
{
resistor[i].resistance = resistor[i+1].resistance;
}
if (num_resistors > 0) num_resistors--;
}
/**
* Totals and returns the resistance of the circuit.
*/
public int resistance()
{
int val = 0;
for (int i=0; i < num_resistors; i++) val += resistor[i].resistance;
return val;
}
}
/**
* Represents a resistor, including the resistance, width and height
* of the glyph graphically representing the resistor, and the x/y
* location of this resistor.
*
* @author Sean Russell
*
*/
class Resistor
{
public int resistance;
int x, y;
int w, h;
Resistor()
{
resistance = x = y = w = h = 0;
}
/**
* Creates a resistor given:
* res resistance
* i the glyph, from which we draw height and width data
* x,y the (x,y) coordinates of the glyph
*/
Resistor(int res, Image i, int x, int y)
{
resistance = res;
this.x = x;
this.y = y;
w = 50;
h = 18;
}
/**
* Initializes a resistor with the values:
* res resistance
* i the glyph, from which we draw height and size().width data
* x,y the (x,y) coordinates of the glyph
*/
public void init(int res, Image i, int x, int y)
{
resistance = res;
this.x = x;
this.y = y;
w = 50;
h = 18;
}
/**
* Checks to see if (x,y) are within the space taken up by this
* resistor's glyph. Returns true if so, otherwise false.
*/
public boolean in(int x, int y)
{
if ((x > this.x) && (x < (this.x + w)) &&
(y > this.y) && (y < (this.y + w)))
return true;
return false;
}
/**
* Zeros the resistor's values.
*/
public void clear()
{
resistance = x = y = w = h = 0;
}
}
/**
* A battery, with voltage, glyph and graphics coordinates
*/
class Battery
{
voltage parent;
Image glyph;
public int voltage;
int x, y;
/**
* Create a battery with the glyph i, the voltage v,
* and the x/y coordinates of (xloc, ylox)
*/
Battery(voltage parent, Image i, int v, int xloc, int yloc)
{
this.parent = parent;
glyph = i;
voltage = v;
x = xloc;
y = yloc;
}
/**
* Changes the x and y coordinates of this battery
*/
public void change(int xloc, int yloc)
{
x = xloc;
y = yloc;
}
/**
* Answers whether the given coordinate is within this battery's
* glyph area with true or false
*/
public boolean in(int xloc, int yloc)
{
if (
(xloc > x) && (yloc > y) &&
(xloc < (x + glyph.getWidth(parent))) &&
(yloc < (y + glyph.getHeight(parent)))
)
return true;
return false;
}
/**
* Paints a battery at its coordinates, and adds the voltage
*/
public void draw(Graphics g)
{
g.drawImage(glyph, x, y, parent);
Output.print(g, voltage, x+15, y+14);
}
/**
* Paints a battery at the given coordinates, and adds the voltage
*/
public void draw(Graphics g, int xloc, int yloc)
{
g.drawImage(glyph, xloc, yloc, parent);
Output.print(g, voltage, xloc+15, yloc+14);
}
}
/**
* History
*
* - Wed Aug 23 16:26:40 PDT 1995
* First major progress in the program. Everything is going pretty
* smoothly, since most of the non-UI AWT (of which there is very little
* in this code) stuff is straightforward. Java comes across as
* increasingly elegant, as long as one understands that it only
* resembles C++. The absence of a preprocessor makes life more
* difficult, and some constructions are a bit unnatural for those of
* us more used to traditional C/C++, but I'm pleased. Most of the
* implementation of this code was done within about a day and a half
* of reasonable effort.
* The dragging and clipping example supplied with Java was a bit
* oddly implemented, but it helped.
* Left to do:
* + On/Off switch
* + Lightbulb animation
* + Cosmetics
* + Text gadgets for voltage and amperage
*
* - Thu Aug 24 12:15:43 PDT 1995
* It is done, unless Greg wants me to add thos text gadgets for the
* battery and the lightbulb. I don't think its neccessary, since we
* hava a parameter list now. The on/off switch took all of 10 minutes
* to implement. Lightbulb animation is simple, but it works. Had
* remarkably few bugs.
* Modified the reisitor levels to be powers of 2.
* Still waiting on graphics from Amy.
*
* - Fri Aug 25 12:00:27 PDT 1995
* Late yesterday I completely revamped the display. Amy draw a really
* nice circuit diagram so that the entire thing looks really slick.
* It took about 1.5f hours to implement and debug.
* Today mostly cosmetic modifications. Made the resistor toolbar
* horizontal rather than vertical, which saves a lot of space. Changed
* dropbox from yellow to a 3DRect. Added exception handling in the case
* of missing GIFs. Threw in some animation for when the lightbulb blows
* up. Added some quasi-external output functions so all of the printing
* is centralized. Cleaned up the code a lot, and optimized. I had to
* streamline the code a lot; I was doing things like calling update()
* unneccessarily, etc.
*
* - Tue Sep 5 11:42:01 PDT 1995
* Greg came back from his vacation and is not completely satisfied with
* the circuit simulator. Still to do:
* + Drag-n-drop values for the battery (done: Tue Sep 5 13:25:49 PDT 1995)
* + Hidden but fixed amp value (done: Tue Sep 5 13:25:49 PDT 1995)
* + require that the user turn off the circuit, and shock them (virtually)
* if they don't.
* Little modifications. Most notably:
* + Added "hide" parameter, for optional hiding of amperage
* + Batterys are now multiples of the "voltage" argument
* + Text output is darker (more readable?)
*/
interface HISTORY {}
