lib/classpath/examples/gnu/classpath/examples/CORBA/swing/x5/PlayingDesk.java

   1 /* PlayingDesk.java --
   2  Copyright (C) 2005 Free Software Foundation, Inc.
   3
   4  This file is part of GNU Classpath.
   5
   6  GNU Classpath is free software; you can redistribute it and/or modify
   7  it under the terms of the GNU General Public License as published by
   8  the Free Software Foundation; either version 2, or (at your option)
   9  any later version.
  10
  11  GNU Classpath is distributed in the hope that it will be useful, but
  12  WITHOUT ANY WARRANTY; without even the implied warranty of
  13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  General Public License for more details.
  15
  16  You should have received a copy of the GNU General Public License
  17  along with GNU Classpath; see the file COPYING.  If not, write to the
  18  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19  02110-1301 USA.
  20
  21  Linking this library statically or dynamically with other modules is
  22  making a combined work based on this library.  Thus, the terms and
  23  conditions of the GNU General Public License cover the whole
  24  combination.
  25
  26  As a special exception, the copyright holders of this library give you
  27  permission to link this library with independent modules to produce an
  28  executable, regardless of the license terms of these independent
  29  modules, and to copy and distribute the resulting executable under
  30  terms of your choice, provided that you also meet, for each linked
  31  independent module, the terms and conditions of the license of that
  32  module.  An independent module is a module which is not derived from
  33  or based on this library.  If you modify this library, you may extend
  34  this exception to your version of the library, but you are not
  35  obligated to do so.  If you do not wish to do so, delete this
  36  exception statement from your version. */
  37
  38
  39 package gnu.classpath.examples.CORBA.swing.x5;
  40
  41 import java.awt.Color;
  42 import java.awt.Graphics;
  43 import java.awt.Point;
  44 import java.awt.event.MouseEvent;
  45 import java.awt.event.MouseListener;
  46 import java.rmi.RemoteException;
  47 import java.util.ArrayList;
  48 import java.util.Collection;
  49 import java.util.Iterator;
  50
  51 import javax.swing.JComponent;
  52
  53 import org.omg.CORBA.ORB;
  54
  55 /**
  56  * Manages actions, related to the game rules and also does all painting.
  57  *
  58  * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
  59  */
  60 public class PlayingDesk
  61   extends JComponent
  62   implements MouseListener, State
  63 {
  64   /**
  65    * Use serialVersionUID for interoperability.
  66    */
  67   private static final long serialVersionUID = 1;
  68
  69   /**
  70    * Indicates that the field point state is the red oval.
  71    */
  72   public static final int RED = 0;
  73
  74   /**
  75    * Indicates that the field point state is the black cross.
  76    */
  77   public static final int BLACK = 1;
  78
  79   /**
  80    * Indicates that the field point state is the hint, suggested by the fan.
  81    */
  82   public static final int HINT = 2;
  83
  84   /**
  85    * The access to the main frame methods.
  86    */
  87   ClientFrame frame;
  88
  89   /**
  90    * The access to the player communicator.
  91    */
  92   PlayerImpl player;
  93
  94   /**
  95    * The game manager.
  96    */
  97   GameManager manager;
  98
  99   /**
 100    * The player ORB.
 101    */
 102   ORB orb;
 103
 104   /**
 105    * The player IOR.
 106    */
 107   String ior;
 108
 109   /**
 110    * True if the player ORB started ok.
 111    */
 112   boolean ok;
 113
 114   /**
 115    * The grid spacing.
 116    */
 117   static int W = 16;
 118
 119   /**
 120    * The radius of the dots being painted.
 121    */
 122   static int R = W / 3;
 123
 124   /**
 125    * The collection of the red dots.
 126    */
 127   ArrayList reds = new ArrayList();
 128
 129   /**
 130    * The collection of the black dots.
 131    */
 132   ArrayList blacks = new ArrayList();
 133
 134   /**
 135    * The array of hints.
 136    */
 137   ArrayList hints = new ArrayList();
 138
 139   /**
 140    * When the game is completed, obtains the value of the two end points of the
 141    * created line.
 142    */
 143   Point[] endOfGame;
 144
 145   public PlayingDesk()
 146   {
 147     try
 148       {
 149         player = new PlayerImpl();
 150         player.desk = this;
 151
 152         OrbStarter.startPlayer(player, this);
 153
 154         jbInit();
 155       }
 156     catch (Exception e)
 157       {
 158         e.printStackTrace();
 159       }
 160   }
 161
 162   /**
 163    * Paint this component.
 164    */
 165   public void paintComponent(Graphics g)
 166   {
 167     int w = getWidth();
 168     int h = getHeight();
 169
 170     g.setColor(Color.white);
 171     g.fillRect(0, 0, w, h);
 172
 173     drawGrid(w, h, g);
 174     drawFigures(g);
 175   }
 176
 177   /**
 178    * Check maybe a game is finished after setting the point N
 179    */
 180   public Point[] checkFinished(Collection x, Point N)
 181   {
 182     Iterator iter = x.iterator();
 183     Point p;
 184
 185     // The victory, if happens, must occur inside these boundaries:
 186     int ax = N.x - 5;
 187     int bx = N.x + 5;
 188
 189     int ay = N.y - 5;
 190     int by = N.y + 5;
 191
 192     while (iter.hasNext())
 193       {
 194         p = (Point) iter.next();
 195
 196         if (p.x > ax && p.x < bx && p.y > ay && p.y < by)
 197           {
 198             // Check the vertical line down
 199             if (pointPresent(p.x, p.y + 1, x))
 200               if (pointPresent(p.x, p.y + 2, x))
 201                 if (pointPresent(p.x, p.y + 3, x))
 202                   if (pointPresent(p.x, p.y + 4, x))
 203                     return new Point[] { p, new Point(p.x, p.y + 4) };
 204
 205             // Check the horizontal line left
 206             if (pointPresent(p.x + 1, p.y, x))
 207               if (pointPresent(p.x + 2, p.y, x))
 208                 if (pointPresent(p.x + 3, p.y, x))
 209                   if (pointPresent(p.x + 4, p.y, x))
 210                     return new Point[] { p, new Point(p.x + 4, p.y) };
 211
 212             // Check the diagonal line right down.
 213             if (pointPresent(p.x + 1, p.y + 1, x))
 214               if (pointPresent(p.x + 2, p.y + 2, x))
 215                 if (pointPresent(p.x + 3, p.y + 3, x))
 216                   if (pointPresent(p.x + 4, p.y + 4, x))
 217                     return new Point[] { p, new Point(p.x + 4, p.y + 4) };
 218
 219             // Check the diagonal line left down.
 220             if (pointPresent(p.x - 1, p.y + 1, x))
 221               if (pointPresent(p.x - 2, p.y + 2, x))
 222                 if (pointPresent(p.x - 3, p.y + 3, x))
 223                   if (pointPresent(p.x - 4, p.y + 4, x))
 224                     return new Point[] { p, new Point(p.x - 4, p.y + 4) };
 225           }
 226       }
 227     return null;
 228   }
 229
 230   /**
 231    * Called when the "end of the game" situation is detected.
 232    */
 233   public void drawFinishLine(int xa, int ya, int xb, int yb, Graphics g)
 234   {
 235     g.setColor(Color.blue);
 236
 237     int hW = W / 2;
 238     g.drawLine(xa * W + hW, ya * W + hW, xb * W + hW, yb * W + hW);
 239   }
 240
 241   /**
 242    * Check for the presence of the given point in the collection.
 243    */
 244   public final boolean pointPresent(int x, int y, Collection in)
 245   {
 246     Iterator iter = in.iterator();
 247     Point p;
 248     while (iter.hasNext())
 249       {
 250         p = (Point) iter.next();
 251         if (p.x == x && p.y == y)
 252           return true;
 253       }
 254     return false;
 255   }
 256
 257   public void drawGrid(int w, int h, Graphics g)
 258   {
 259     g.setColor(Color.lightGray);
 260
 261     // Draw vertical lines:
 262     for (int x = 0; x < w; x += W)
 263       {
 264         g.drawLine(x, 0, x, h);
 265       }
 266
 267     // Draw horizontal lines:
 268     for (int y = 0; y < h; y += W)
 269       {
 270         g.drawLine(0, y, w, y);
 271       }
 272
 273     g.setColor(Color.gray);
 274     g.drawRect(0,0, frame.DESK_SIZE.width, frame.DESK_SIZE.height);
 275     g.drawRect(0,0, frame.DESK_SIZE.width+3, frame.DESK_SIZE.height+3);
 276   }
 277
 278   public void drawFigures(Graphics g)
 279   {
 280     g.setColor(Color.red);
 281     drawDots(reds, g, RED);
 282
 283     g.setColor(Color.black);
 284     drawDots(blacks, g, BLACK);
 285
 286     g.setColor(Color.lightGray);
 287     drawDots(hints, g, HINT);
 288
 289     if (endOfGame != null)
 290       drawFinishLine(endOfGame[0].x, endOfGame[0].y, endOfGame[1].x,
 291         endOfGame[1].y, g);
 292   }
 293
 294   public Point makePoint(int x, int y)
 295   {
 296     return new Point(x / W, y / W);
 297   }
 298
 299   /**
 300    * Draw a collection of dots (the collor must be set before calling the
 301    * method).
 302    */
 303   public void drawDots(Collection dots, Graphics g, int mode)
 304   {
 305     Iterator iter = dots.iterator();
 306     int x;
 307     int y;
 308
 309     int hW = W / 2;
 310     int RR = R * 2;
 311     int hR = R / 2;
 312     Point p;
 313     while (iter.hasNext())
 314       {
 315         p = (Point) iter.next();
 316         x = p.x * W + hW;
 317         y = p.y * W + hW;
 318
 319         if (mode == RED)
 320           g.drawOval(x - R, y - R, RR, RR);
 321         else if (mode == BLACK)
 322           {
 323             g.drawLine(x - R, y - R, x + R, y + R);
 324             g.drawLine(x - R, y + R, x + R, y - R);
 325           }
 326         else
 327           {
 328             // Hint.
 329             g.drawOval(x - hR, y - hR, R, R);
 330           }
 331       }
 332   }
 333
 334   private void jbInit()
 335     throws Exception
 336   {
 337     addMouseListener(this);
 338   }
 339
 340   public void mouseClicked(MouseEvent e)
 341   {
 342     try
 343       {
 344         int state = player.get_current_state();
 345
 346         // Check if the state is correct.
 347         if (state == I_WAIT_FOR_YOUR_MOVE)
 348           {
 349             frame.talk(Color.black,
 350               "It is now time for our partner's move, not ours. Please wait.");
 351           }
 352         else if (state == DISCONNECTED)
 353           {
 354             frame.talk(Color.black,
 355               "We are not connected to the playing partner yet.");
 356           }
 357         else if (state == I_HAVE_LOST)
 358           {
 359             frame.talk(Color.black,
 360               "We have already lost this battle, but why not to try again?");
 361           }
 362         else if (state == I_HAVE_WON)
 363           {
 364             frame.talk(Color.black,
 365               "The victory is ours, nothing more to do here.");
 366           }
 367         else if (player.partner == null)
 368           frame.talk(Color.black, "No other player so far.");
 369         else
 370           {
 371             int x = e.getX();
 372             int y = e.getY();
 373
 374             if (x>frame.DESK_SIZE.width ||
 375                 y>frame.DESK_SIZE.height)
 376             {
 377               frame.talk(Color.black,"Outside the game area.");
 378               return;
 379             }
 380
 381             Point p = makePoint(x, y);
 382
 383             // Ignore clicks on the occupied cells.
 384             if (pointPresent(p.x, p.y, reds)
 385               || (pointPresent(p.x, p.y, blacks)))
 386               {
 387                 frame.talk(Color.black,
 388                   "This is against the rules, select the unoccupied cell.");
 389                 return;
 390               }
 391
 392             reds.add(p);
 393
 394             endOfGame = checkFinished(reds, p);
 395             repaint();
 396
 397             if (endOfGame != null)
 398               {
 399                 frame.talk(Color.red, "Our move " + p.x + "-" + p.y
 400                   + " and we win!");
 401                 player.set_current_state(I_HAVE_WON);
 402               }
 403             else
 404               {
 405                 frame.talk(Color.black, "Our move " + p.x + "-" + p.y
 406                   + ". Waiting for the other side move...");
 407                 player.set_current_state(I_WAIT_FOR_YOUR_MOVE);
 408               }
 409
 410             player.partner.receive_move(p.x, p.y, endOfGame);
 411           }
 412       }
 413     catch (RemoteException ex)
 414       {
 415         // We will print the exception because this is a demo application
 416         // that may be modified for learning purposes.
 417         ex.printStackTrace();
 418       }
 419   }
 420
 421   /**
 422    * Handle the move of the other playing side.
 423    */
 424   public void friendsMove(int x, int y, Point[] victory)
 425   {
 426     try
 427       {
 428         int state = player.get_current_state();
 429         if (state != I_WAIT_FOR_YOUR_MOVE || pointPresent(x, y, blacks))
 430           {
 431             stateFailed("Move " + x + "-" + y);
 432           }
 433         else
 434           {
 435             blacks.add(new Point(x, y));
 436
 437             if (victory != null)
 438               {
 439                 frame.talk(Color.red,
 440                   " We have lost this time, unfortunately..");
 441                 player.set_current_state(I_HAVE_LOST);
 442                 endOfGame = victory;
 443               }
 444             else
 445               {
 446                 frame.talk(Color.black, "Partner goes " + x + "-" + y
 447                   + ". Your move?");
 448                 player.set_current_state(I_THINK);
 449               }
 450             repaint();
 451           }
 452       }
 453     catch (RemoteException rex)
 454       {
 455         rex.printStackTrace();
 456       }
 457   }
 458
 459   /**
 460    * Prepare for the new game.
 461    */
 462   public void reset()
 463   {
 464     blacks.clear();
 465     reds.clear();
 466     hints.clear();
 467     endOfGame = null;
 468     repaint();
 469   }
 470
 471   public void mouseEntered(MouseEvent m)
 472   {
 473     // Nothing to do.
 474   }
 475
 476   public void mousePressed(MouseEvent m)
 477   {
 478     // Nothing to do.
 479   }
 480
 481   public void mouseReleased(MouseEvent m)
 482   {
 483     // Nothing to do.
 484   }
 485
 486   public void mouseExited(MouseEvent m)
 487   {
 488     // Nothing to do.
 489   }
 490
 491   /**
 492    * The systems detected the error conditions. The game cannot continue (the
 493    * chat is still possible).
 494    */
 495   public void stateFailed(String reason)
 496   {
 497     try
 498       {
 499         player.receive_chat(ChatConstants.REMOTE_PLAYER,
 500           "Wrong move, game cannot continue (our state was "
 501             + player.get_current_state() + ")");
 502         frame.talk(Color.red, "The remote side violates communicating rules.");
 503         player.set_current_state(State.ERROR);
 504       }
 505     catch (RemoteException ex)
 506       {
 507         // We will print the exception because this is a demo application
 508         // that may be modified for learning purposes.
 509         ex.printStackTrace();
 510       }
 511   }
 512 }