Logo Search packages:      
Sourcecode: wims version File versions

SplashPanel.java

import java.awt.*;
import java.awt.geom.*;
import java.awt.event.*;
import java.awt.image.*;
import javax.swing.*;

public class SplashPanel extends JPanel implements MouseListener,Runnable{
      Plinko plinko;
      double w;
      double h;   
      int TOTAL;                          // total number of balls that have been dropped
      int[] HIST;                         // number of balls in each bin;
      double MAX;                         // maximum number of balls in a single bin
      Point[][] PINS;                     // coordinates of pins (including one at the base of each bin)
      double DIST;                        // vertical distance between pins
      double BALL_RAD;              // radius of ball
      int PIN_RAD;                        // radius of pin
      int BINS = 20;                      // total number of bins
      PlinkoBall FIRST_BALL;      // represents beginning of doubly linked list of plinko balls
      int BALL_COUNT;
      int BOTTOM_MARGIN = 5;
//    private static byte[] data;
      private final static int hx = 15;
      private final static int hy = 15;
      private final static int bgGrey = 192;
      Image[] IMAGES;
      boolean newBackground = true;
      boolean active = true;
      Thread thread;
      public SplashPanel( Plinko plinko ){
            setBackground( Color.white );
            addMouseListener( this );     
            this.plinko = plinko;
            for ( int i = 0; i<25; i++ ){
                  dropBall();
                  FIRST_BALL.ROW = 10+(int)(10*Math.random());
                  FIRST_BALL.COL = (int)(FIRST_BALL.ROW*Math.random());
                  FIRST_BALL.C = 10;
                  FIRST_BALL.t = i%11;
            }
            start();
      }

      public void start(){
            active = true;
            thread = new Thread(this);
            thread.start();
      }


      public void run(){
          while ( active ){
            if ( Math.random() < 0.4 ){
                dropBall();
                FIRST_BALL.ROW = 11;
                FIRST_BALL.COL = (int)(FIRST_BALL.ROW*Math.random());
                FIRST_BALL.C = 10;
            }
            repaint();
            try {Thread.sleep(100);} catch (InterruptedException e){}
          }
      }


      public void dropBall(){
          if ( FIRST_BALL == null ){
                  FIRST_BALL = new PlinkoBall();
          } else {
                  FIRST_BALL.previousBall = new PlinkoBall();
                  FIRST_BALL.previousBall.nextBall = FIRST_BALL;
                  FIRST_BALL = FIRST_BALL.previousBall;
          }
    }


    //Image backImage;
      Image background;
      Graphics2D backGraphics;
      int FUDGE = 200;

    public void setup(){
            if(plinko.wims_exercise == true){ FUDGE = 100;}
            if ( h-BOTTOM_MARGIN<h/2 ){
                  DIST = (double)(h-BOTTOM_MARGIN)/BINS;
            } else {
                  DIST = (double)(w-10)/(2*BINS);
            }

            PIN_RAD = (int)DIST/9 + 1;
            BALL_RAD = Math.max(2*DIST/7,2.0) + 1;

            // create images of colored balls
            IMAGES = new Image[ PlinkoBoard.COLORS.length ];
            Graphics2D g;
            int red;
            int green;
            int blue;
            for ( int i=0; i<PlinkoBoard.COLORS.length; i++ ){
                  IMAGES[i] = PlinkoBoard.getBall( BALL_RAD, PlinkoBoard.COLORS[i] );
            }

            PINS = new Point[BINS][];
            for (int i=0; i<BINS; i++){
                  PINS[i] = new Point[i+1];
                  for (int j=0; j<=i; j++){
                        PINS[i][j]= new Point((int)(DIST*(2*j-i)+w/2)-FUDGE/2,(int)(DIST*(i+1))-(FUDGE-15));
                  }
            }           
            
            // pins at the base of each bin
            for (int i=0; i<BINS; i++){
                  PINS[BINS-1][i]= new Point((int)(DIST*(2*i-BINS+1)+w/2),(int)(h-30-BALL_RAD));
            }
    }


      public void paintComponent( Graphics graphics ){
            // have a copy of the background on which to draw
            w = getWidth();
            h = getHeight();
            
            w = Math.max( getWidth(),getHeight() ) + FUDGE;
            h = w;

            Graphics2D g = (Graphics2D)graphics;
            g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);

            if ( background == null || background.getWidth(this) != h || background.getHeight(this) != w ){
                  setup();
                  background = createImage( (int)w, (int)h );
                  drawBackground((int)w,(int)h);
            }

            g.drawImage( background, 0, 0, this );

            // run through all active balls and draw them on the image
            PlinkoBall ball = FIRST_BALL;

            int red;
            int green;
            int blue;
            while ( ball != null ){
                  graphics.drawImage( IMAGES[ball.spaz], (int)(ball.X - BALL_RAD),  (int)(ball.Y - 2*BALL_RAD - PIN_RAD + 1), this );
                  if ( active ) increment( ball );
                  ball = ball.nextBall;
            }
            //g.drawImage(image,0,0,this);

            w = getWidth();
            h = getHeight();
            g.setColor( new Color( 128,128,128,220 ) );
            g.setFont( new Font("Helvetica",Font.BOLD,plinko.font_size) );
            //String str = "CLICK ANYWHERE TO BEGIN";
            String str = plinko.click_text;
            
            g.drawString( str, (int)(w-g.getFontMetrics().stringWidth(str)-5), (int)(h-5) );
      }


    public void increment( PlinkoBall ball ){
            // if ball has landed on pin, reset t to 0 and pick a direction
            if ( ball.t == ball.C && ball.ROW < BINS-2 ){
                  ball.ROW++;
                  ball.COL += ball.DIR;
                  ball.t = 0;
                  ball.DIR = 0;
                  if ( Math.random() < 0.5 ) ball.DIR = 1;

                  ball.C = 10;
                  
                  //if ( C>1 ) C += spaz;
            }

            double dx = DIST*ball.t*(2*ball.DIR - 1)/ball.C;

            if ( ball.ROW < 0 ){ // ball falling onto top pin
                  ball.X = PINS[0][0].x;
                  dx = Math.abs(dx);
                  ball.Y = PINS[0][0].y - DIST + DIST*ball.t*ball.t/(ball.C*ball.C);
            } else if ( ball.ROW < BINS-2 ) {
                  ball.X = PINS[ball.ROW][ball.COL].x + dx;
                  dx = Math.abs(dx);
                  //Y = PlinkoBoard.PINS[ROW][COL].y - (int)(dx*(A*dx/PlinkoBoard.DIST+B));
                  ball.Y = PINS[ball.ROW][ball.COL].y - DIST*PlinkoBoard.DYS[ball.C][ball.t];
            } else { // ball falling into bin
                  ball.X = PINS[ball.ROW][ball.COL].x + dx;
                  if ( dx>0 ){ 
                        ball.X = Math.min(ball.X,PINS[ball.ROW][ball.COL].x + 2*DIST - BALL_RAD );
                  } else {
                        ball.X = Math.max(ball.X,PINS[ball.ROW][ball.COL].x - 2*DIST + BALL_RAD + 1);
                  }
                  dx = Math.abs(dx);
                  ball.Y = PINS[ball.ROW][ball.COL].y  - dx*(ball.A*dx/DIST+ball.B);
            }

            ball.t++;

            if ( ball.Y > h - BOTTOM_MARGIN - PIN_RAD ){
                  if ( ball.previousBall != null && ball.nextBall != null){
                        ball.previousBall.nextBall = ball.nextBall;
                        ball.nextBall.previousBall = ball.previousBall;
                  } else if ( ball.previousBall != null && ball.nextBall == null ) {
                        ball.previousBall.nextBall = null;
                  } else if ( ball.previousBall == null && ball.nextBall != null ) {
                        ball.nextBall.previousBall = null;
                        FIRST_BALL = ball.nextBall;
                  } else  {
                        FIRST_BALL = null;
                        //plinko.bins.setEnabled( true );
                  }

                  BALL_COUNT--;
            }
    }
      
      
    public void drawBackground( int W, int H ){
            Point p;

            Graphics2D backgroundgraphics = (Graphics2D) background.getGraphics();
            backgroundgraphics.setRenderingHint( RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON );
            backgroundgraphics.setRenderingHint( RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON );
            backgroundgraphics.setColor(Color.white);
            backgroundgraphics.fillRect( 0, 0, W, H );
            backgroundgraphics.setColor(Color.black);
            Image img = PlinkoBoard.getBall( PIN_RAD, Color.black );

            // draw pins
            for (int i=0; i<BINS-1; i++){
                  for (int j=0;j<=i;j++){
                        p = PINS[i][j];
                        //backgroundgraphics.fillOval(p.x-PIN_RAD,p.y-PIN_RAD,2*PIN_RAD,2*PIN_RAD);
                  backgroundgraphics.drawImage(img, (int)(p.x-PIN_RAD),(int)(p.y-PIN_RAD),this );
                  }
            }
            repaint();
    }


      public void mouseClicked( MouseEvent me ){
            active = false;
            plinko.showFrame();
      }
      
      
      public void mouseEntered( MouseEvent me ){
      }


      public void mouseExited( MouseEvent me ){
      }


      public void mousePressed( MouseEvent me ){
      }


      public void mouseReleased(MouseEvent me){
      }

      
}

Generated by  Doxygen 1.6.0   Back to index