//------------------------------------------------------------------------------
// Master Mind Applet
//
// Copyright 1996, All rights reserved
// You are free to use this java source code at your desire.
// You also understand that by using this code, you are on your own.
// I cannot offer any support if you have problems and no warrantees
// are implied or offered for your use of this source code. 
//
// Version: 0.8
// Author: Anupriyo Chakravarti (anuhome@anupriyo.com)
// Created: 09/01/96
//
// To do:
//  1. This is the quick and dirty version in which I just got everything to
//     work! I still need to clean up the code, make it object-oriented!
//     Most of the attributes are public and the 'alert' method is duplicated
//     in two places! That's why it is not yet 1.0
//------------------------------------------------------------------------------


import java.awt.*;
import java.lang.*;

class MMindNumber
{
  String  secret = "xxxx";
  String  input = "xxxx";
  int     cows = 0;
  int     bulls = 0;
  int     games = 0;
  int     tries = 0;
  int     curtries = 0;
  
  static Label  alertLabel;
  
  void alert(String msg)
  {
    alertLabel.setText(msg);
  }
  
  public void match()
  {
    cows = 0;
    bulls = 0;
    for (int i = 0; i < 4; i++)
    {
      for (int j = 0; j < 4; j++)
      {
        if (secret.substring(i, i+1).equals(input.substring(j, j+1)))
        {
          if (i == j)
            bulls++;
          else
            cows++;
        }
      }
    }
  }

  public boolean islegal(String g, boolean showmessage)
  {
    if (g.length() != 4)
    {
      if (showmessage)
        alert("Your guess must have exactly 4 digits.");
      return false;
    }
    if (g.substring(0, 1).equals("0"))
    {
      if (showmessage)
        alert("The first digit of your guess cannot be zero.");
      return false;
    }

    int i, j;
    for (i = 0; i < 4; i++)
    {
      for (j = (i + 1); j < 4; j++)
      {
        if (g.substring(i, i+1).equals(g.substring(j, j+1)))
        {
          if (showmessage)
            alert("You guess cannot have any digits more than once.");
          return false;
        }
      }
    }
    return true;
  }

  public void generate()
  {
    secret = "1111";
    boolean legal = false;
    while (!legal)
    {
      secret = Long.toString(Math.round(Math.random() * 9000 + 1000));
      legal = islegal(secret, false);
    }
  }
}

class ThreeDPanel extends Panel
{
    boolean raised = true;
    boolean framed = true;
    int     thickness = 4;
    Color   lightColor = Color.lightGray;
    Color   darkColor = Color.gray;
  
    ThreeDPanel()
    {
    }
    
    public void paint(Graphics g)
    {
        int top = 0;
        int left = 0;
        int right = size().width - 1;
        int bottom = size().height - 1;
        
        Color oldColor = g.getColor();
        
        Color topColor = lightColor;
        Color bottomColor = darkColor;
        if (!raised)
        {
          topColor = darkColor;
          bottomColor = lightColor;
        }

        for (int i = 0; i < thickness; i++)
        {
          if (framed && (i == (thickness/2)))
          {
            Color tempColor = topColor;
            topColor = bottomColor;
            bottomColor = tempColor;
          }
          g.setColor(topColor);
          g.drawLine(left, bottom, left, top);
          g.drawLine(left, top, right - 1, top);
          g.setColor(bottomColor);
          g.drawLine(right, top, right, bottom);
          g.drawLine(right, bottom, left + 1, bottom);
          left++;
          right--;
          top++;
          bottom--;
        }
        g.setColor(oldColor);
    }
}

public class MMind extends java.applet.Applet
{
  Panel messagePanel;
  Label messageLabel;
  Panel statsHeaderPanel;
  Panel resultsPanel;
  Panel resultsHeaderPanel;
  Panel statsPanel;
  Panel inputHeaderPanel;
  Panel inputPanel;
  Label guessLabel;
  Label gamesLabel;
  Label inputHeaderLabel;
  List resultsListbox;
  Label statisticsHeaderLabel;
  Label resultsHeaderLabel;
  Label gamesOutLabel;
  TextField guessEntry;
  Button okButton;
  Label triesLabel;
  Button newGameButton;
  Label triesOutLabel;
  Button cheatButton;
  Label avgTriesLabel;
  Label avgTriesOutLabel;
  Panel mainPanel;
  
  MMindNumber mmNumber;

  public void init() 
  {
    mmNumber = new MMindNumber();
    setBackground(Color.white);
    
    setLayout(new BorderLayout(0, 4));
    mainPanel = new ThreeDPanel();
    this.add("Center", mainPanel);

    // main panel
    GridBagLayout grid = new GridBagLayout();
    int rowHeights[] = {0,30,30};
    int columnWidths[] = {0,40,140,40};
    double rowWeights[] = {0.0,0.0,0.0};
    double columnWeights[] = {0.0,0.0,0.0};
    grid.rowHeights = rowHeights;
    grid.columnWidths = columnWidths;
    grid.rowWeights = rowWeights;
    grid.columnWeights = columnWeights;
    
    // container messagePanel in main panel.
    GridBagLayout messagePanel_grid = new GridBagLayout();
    int messagePanel_rowHeights[] = {0,30};
    int messagePanel_columnWidths[] = {0,250};
    double messagePanel_rowWeights[] = {0.0,0.0};
    double messagePanel_columnWeights[] = {0.0,1.0};
    messagePanel_grid.rowHeights = messagePanel_rowHeights;
    messagePanel_grid.columnWidths = messagePanel_columnWidths;
    messagePanel_grid.rowWeights = messagePanel_rowWeights;
    messagePanel_grid.columnWeights = messagePanel_columnWeights;

    messagePanel = new ThreeDPanel();
    this.add("South", messagePanel);

    // container statsHeaderPanel in main panel.
    GridBagLayout statsHeaderPanel_grid = new GridBagLayout();
    int statsHeaderPanel_rowHeights[] = {0,30};
    int statsHeaderPanel_columnWidths[] = {0,40};
    double statsHeaderPanel_rowWeights[] = {0.0,0.0};
    double statsHeaderPanel_columnWeights[] = {0.0,0.0};
    statsHeaderPanel_grid.rowHeights = statsHeaderPanel_rowHeights;
    statsHeaderPanel_grid.columnWidths = statsHeaderPanel_columnWidths;
    statsHeaderPanel_grid.rowWeights = statsHeaderPanel_rowWeights;
    statsHeaderPanel_grid.columnWeights = statsHeaderPanel_columnWeights;

    statsHeaderPanel = new ThreeDPanel();
    mainPanel.add(statsHeaderPanel);

    // container resultsPanel in main panel.
    GridBagLayout resultsPanel_grid = new GridBagLayout();
    int resultsPanel_rowHeights[] = {0,30};
    int resultsPanel_columnWidths[] = {0,94};
    double resultsPanel_rowWeights[] = {0.0,1.0};
    double resultsPanel_columnWeights[] = {0.0,1.0};
    resultsPanel_grid.rowHeights = resultsPanel_rowHeights;
    resultsPanel_grid.columnWidths = resultsPanel_columnWidths;
    resultsPanel_grid.rowWeights = resultsPanel_rowWeights;
    resultsPanel_grid.columnWeights = resultsPanel_columnWeights;

    resultsPanel = new ThreeDPanel();
    mainPanel.add(resultsPanel);

    // container resultsHeaderPanel in main panel.
    GridBagLayout resultsHeaderPanel_grid = new GridBagLayout();
    int resultsHeaderPanel_rowHeights[] = {0,30};
    int resultsHeaderPanel_columnWidths[] = {0,40};
    double resultsHeaderPanel_rowWeights[] = {0.0,0.0};
    double resultsHeaderPanel_columnWeights[] = {0.0,0.0};
    resultsHeaderPanel_grid.rowHeights = resultsHeaderPanel_rowHeights;
    resultsHeaderPanel_grid.columnWidths = resultsHeaderPanel_columnWidths;
    resultsHeaderPanel_grid.rowWeights = resultsHeaderPanel_rowWeights;
    resultsHeaderPanel_grid.columnWeights = resultsHeaderPanel_columnWeights;

    resultsHeaderPanel = new ThreeDPanel();
    mainPanel.add(resultsHeaderPanel);

    // container statsPanel in main panel.
    GridBagLayout statsPanel_grid = new GridBagLayout();
    int statsPanel_rowHeights[] = {0,30,30,30};
    int statsPanel_columnWidths[] = {0,40,40};
    double statsPanel_rowWeights[] = {0.0,0.0,0.0,0.0};
    double statsPanel_columnWeights[] = {0.0,0.0,0.0};
    statsPanel_grid.rowHeights = statsPanel_rowHeights;
    statsPanel_grid.columnWidths = statsPanel_columnWidths;
    statsPanel_grid.rowWeights = statsPanel_rowWeights;
    statsPanel_grid.columnWeights = statsPanel_columnWeights;

    statsPanel = new ThreeDPanel();
    mainPanel.add(statsPanel);

    // container inputHeaderPanel in main panel.
    GridBagLayout inputHeaderPanel_grid = new GridBagLayout();
    int inputHeaderPanel_rowHeights[] = {0,30};
    int inputHeaderPanel_columnWidths[] = {0,40};
    double inputHeaderPanel_rowWeights[] = {0.0,0.0};
    double inputHeaderPanel_columnWeights[] = {0.0,0.0};
    inputHeaderPanel_grid.rowHeights = inputHeaderPanel_rowHeights;
    inputHeaderPanel_grid.columnWidths = inputHeaderPanel_columnWidths;
    inputHeaderPanel_grid.rowWeights = inputHeaderPanel_rowWeights;
    inputHeaderPanel_grid.columnWeights = inputHeaderPanel_columnWeights;

    inputHeaderPanel = new ThreeDPanel();
    mainPanel.add(inputHeaderPanel);

    // container inputPanel in main panel.
    GridBagLayout inputPanel_grid = new GridBagLayout();
    int inputPanel_rowHeights[] = {0,30,30,30};
    int inputPanel_columnWidths[] = {0,40,40,40};
    double inputPanel_rowWeights[] = {0.0,0.0,0.0,0.0};
    double inputPanel_columnWeights[] = {0.0,0.0,0.0,0.0};
    inputPanel_grid.rowHeights = inputPanel_rowHeights;
    inputPanel_grid.columnWidths = inputPanel_columnWidths;
    inputPanel_grid.rowWeights = inputPanel_rowWeights;
    inputPanel_grid.columnWeights = inputPanel_columnWeights;

    inputPanel = new ThreeDPanel();
    mainPanel.add(inputPanel);

    guessLabel = new Label();
    guessLabel.setFont(new Font("Helvetica",Font.PLAIN + Font.BOLD , 12));
    guessLabel.setText("Your Guess:");
    inputPanel.add(guessLabel);

    gamesLabel = new Label();
    gamesLabel.setFont(new Font("Helvetica",Font.PLAIN + Font.BOLD , 12));
    gamesLabel.setText("Games:");
    statsPanel.add(gamesLabel);

    inputHeaderLabel = new Label();
    inputHeaderLabel.setFont(new Font("Helvetica",Font.PLAIN + Font.BOLD , 18));
    inputHeaderLabel.setText("Input");
    inputHeaderPanel.add(inputHeaderLabel);

    resultsListbox = new List(4,false);
    resultsListbox.setFont(new Font("Helvetica",Font.PLAIN , 12));
    resultsPanel.add(resultsListbox);

    messageLabel = new Label();
    messageLabel.setFont(new Font("Helvetica",Font.PLAIN + Font.BOLD , 12));
    messageLabel.setText("Message:");
    messagePanel.add(messageLabel);
    
    statisticsHeaderLabel = new Label();
    statisticsHeaderLabel.setFont(new Font("Helvetica",Font.PLAIN + Font.BOLD , 18));
    statisticsHeaderLabel.setText("Statistics");
    statsHeaderPanel.add(statisticsHeaderLabel);

    resultsHeaderLabel = new Label();
    resultsHeaderLabel.setFont(new Font("Helvetica",Font.PLAIN + Font.BOLD , 18));
    resultsHeaderLabel.setText("Results");
    resultsHeaderPanel.add(resultsHeaderLabel);

    gamesOutLabel = new Label();
    gamesOutLabel.setFont(new Font("Helvetica",Font.PLAIN , 12));
    gamesOutLabel.setText("label");
    statsPanel.add(gamesOutLabel);

    guessEntry = new TextField(5);
    guessEntry.setBackground(new Color(65280/256,65280/256,65280/256));
    inputPanel.add(guessEntry);

    okButton = new Button();
    okButton.setLabel("Ok");
    inputPanel.add(okButton);

    triesLabel = new Label();
    triesLabel.setFont(new Font("Helvetica",Font.PLAIN + Font.BOLD , 12));
    triesLabel.setText("Tries:");
    statsPanel.add(triesLabel);

    newGameButton = new Button();
    newGameButton.setLabel("New Game");
    inputPanel.add(newGameButton);

    triesOutLabel = new Label();
    triesOutLabel.setFont(new Font("Helvetica",Font.PLAIN , 12));
    triesOutLabel.setText("label");
    statsPanel.add(triesOutLabel);

    cheatButton = new Button();
    cheatButton.setLabel("Cheat");
    inputPanel.add(cheatButton);

    avgTriesLabel = new Label();
    avgTriesLabel.setFont(new Font("Helvetica",Font.PLAIN + Font.BOLD , 12));
    avgTriesLabel.setText("Avg. Tries:");
    statsPanel.add(avgTriesLabel);

    avgTriesOutLabel = new Label();
    avgTriesOutLabel.setFont(new Font("Helvetica",Font.PLAIN , 12));
    avgTriesOutLabel.setText("label");
    statsPanel.add(avgTriesOutLabel);

    // Geometry management
    GridBagConstraints con = new GridBagConstraints();

    reset(con);
    con.gridx = 1;
    con.gridy = 1;
    con.anchor = GridBagConstraints.CENTER;
    con.fill = GridBagConstraints.BOTH;
    con.ipadx = 4;
    con.ipady = 4;
    con.insets = new Insets(2, 2, 2, 2);
    grid.setConstraints(statsHeaderPanel, con);

    reset(con);
    con.gridx = 1;
    con.gridy = 2;
    con.anchor = GridBagConstraints.CENTER;
    con.fill = GridBagConstraints.BOTH;
    con.ipadx = 4;
    con.ipady = 4;
    con.insets = new Insets(2, 2, 2, 2);
    grid.setConstraints(statsPanel, con);

    reset(con);
    con.gridx = 3;
    con.gridy = 2;
    con.anchor = GridBagConstraints.CENTER;
    con.fill = GridBagConstraints.BOTH;
    con.ipadx = 4;
    con.ipady = 4;
    con.insets = new Insets(2, 2, 2, 2);
    grid.setConstraints(resultsPanel, con);

    reset(con);
    con.gridx = 3;
    con.gridy = 1;
    con.anchor = GridBagConstraints.CENTER;
    con.fill = GridBagConstraints.BOTH;
    con.ipadx = 4;
    con.ipady = 4;
    con.insets = new Insets(2, 2, 2, 2);
    grid.setConstraints(resultsHeaderPanel, con);

    reset(con);
    con.gridx = 2;
    con.gridy = 1;
    con.anchor = GridBagConstraints.CENTER;
    con.fill = GridBagConstraints.BOTH;
    con.ipadx = 4;
    con.ipady = 4;
    con.insets = new Insets(2, 2, 2, 2);
    grid.setConstraints(inputHeaderPanel, con);

    reset(con);
    con.gridx = 2;
    con.gridy = 2;
    con.anchor = GridBagConstraints.NORTH;
    con.fill = GridBagConstraints.BOTH;
    con.ipadx = 4;
    con.ipady = 4;
    con.insets = new Insets(2, 2, 2, 2);
    grid.setConstraints(inputPanel, con);

    reset(con);
    con.gridx = 1;
    con.gridy = 1;
    con.anchor = GridBagConstraints.CENTER;
    con.fill = GridBagConstraints.NONE;
    inputPanel_grid.setConstraints(guessLabel, con);

    reset(con);
    con.gridx = 1;
    con.gridy = 1;
    con.anchor = GridBagConstraints.EAST;
    con.fill = GridBagConstraints.NONE;
    con.insets = new Insets(2, 2, 2, 2);
    statsPanel_grid.setConstraints(gamesLabel, con);

    reset(con);
    con.gridx = 1;
    con.gridy = 1;
    con.anchor = GridBagConstraints.CENTER;
    con.fill = GridBagConstraints.BOTH;
    inputHeaderPanel_grid.setConstraints(inputHeaderLabel, con);

    reset(con);
    con.gridx = 1;
    con.gridy = 1;
    con.anchor = GridBagConstraints.CENTER;
    con.fill = GridBagConstraints.BOTH;
    resultsPanel_grid.setConstraints(resultsListbox, con);

    reset(con);
    con.gridx = 1;
    con.gridy = 1;
    con.anchor = GridBagConstraints.CENTER;
    con.fill = GridBagConstraints.BOTH;
    messagePanel_grid.setConstraints(messageLabel, con);


    reset(con);
    con.gridx = 1;
    con.gridy = 1;
    con.anchor = GridBagConstraints.CENTER;
    con.fill = GridBagConstraints.BOTH;
    statsHeaderPanel_grid.setConstraints(statisticsHeaderLabel, con);

    reset(con);
    con.gridx = 1;
    con.gridy = 1;
    con.anchor = GridBagConstraints.CENTER;
    con.fill = GridBagConstraints.BOTH;
    resultsHeaderPanel_grid.setConstraints(resultsHeaderLabel, con);

    reset(con);
    con.gridx = 2;
    con.gridy = 1;
    con.anchor = GridBagConstraints.EAST;
    con.fill = GridBagConstraints.BOTH;
    con.insets = new Insets(2, 2, 2, 2);
    statsPanel_grid.setConstraints(gamesOutLabel, con);

    reset(con);
    con.gridx = 2;
    con.gridy = 1;
    con.anchor = GridBagConstraints.WEST;
    con.fill = GridBagConstraints.NONE;
    inputPanel_grid.setConstraints(guessEntry, con);

    reset(con);
    con.gridx = 3;
    con.gridy = 1;
    con.anchor = GridBagConstraints.CENTER;
    con.fill = GridBagConstraints.BOTH;
    inputPanel_grid.setConstraints(okButton, con);

    reset(con);
    con.gridx = 1;
    con.gridy = 2;
    con.anchor = GridBagConstraints.EAST;
    con.fill = GridBagConstraints.NONE;
    con.insets = new Insets(2, 2, 2, 2);
    statsPanel_grid.setConstraints(triesLabel, con);

    reset(con);
    con.gridx = 2;
    con.gridy = 2;
    con.anchor = GridBagConstraints.CENTER;
    con.fill = GridBagConstraints.NONE;
    inputPanel_grid.setConstraints(newGameButton, con);

    reset(con);
    con.gridx = 2;
    con.gridy = 2;
    con.anchor = GridBagConstraints.EAST;
    con.fill = GridBagConstraints.BOTH;
    con.insets = new Insets(2, 2, 2, 2);
    statsPanel_grid.setConstraints(triesOutLabel, con);

    reset(con);
    con.gridx = 3;
    con.gridy = 2;
    con.anchor = GridBagConstraints.CENTER;
    con.fill = GridBagConstraints.BOTH;
    inputPanel_grid.setConstraints(cheatButton, con);

    reset(con);
    con.gridx = 1;
    con.gridy = 3;
    con.anchor = GridBagConstraints.EAST;
    con.fill = GridBagConstraints.NONE;
    con.insets = new Insets(2, 2, 2, 2);
    statsPanel_grid.setConstraints(avgTriesLabel, con);

    reset(con);
    con.gridx = 2;
    con.gridy = 3;
    con.anchor = GridBagConstraints.EAST;
    con.fill = GridBagConstraints.BOTH;
    con.insets = new Insets(2, 2, 2, 2);
    statsPanel_grid.setConstraints(avgTriesOutLabel, con);


    // Resize behavior management and parent heirarchy
    mainPanel.setLayout(grid);
    resultsPanel.setLayout(resultsPanel_grid);
    statsHeaderPanel.setLayout(statsHeaderPanel_grid);
    statsPanel.setLayout(statsPanel_grid);
    messagePanel.setLayout(messagePanel_grid);
    inputHeaderPanel.setLayout(inputHeaderPanel_grid);
    resultsHeaderPanel.setLayout(resultsHeaderPanel_grid);
    inputPanel.setLayout(inputPanel_grid);

    // Give the application a chance to do its initialization
    super.init();
    
    // Start a new game
    OnNewGame();
    MMindNumber.alertLabel = messageLabel;
  }
  
  void alert(String msg)
  {
    messageLabel.setText(msg);
  }
  
  public void changeFocus()
  {
    guessEntry.selectAll();
    guessEntry.requestFocus();
  }
  
  public void OnNewGame()
  {
    if (mmNumber.bulls == 4)
    {
      mmNumber.games++;
      mmNumber.tries += mmNumber.curtries;
    }
    mmNumber.curtries = 0;
    mmNumber.bulls = 0;
    mmNumber.cows = 0;

    gamesOutLabel.setText(Integer.toString(mmNumber.games));
    triesOutLabel.setText(Integer.toString(mmNumber.curtries));
    avgTriesOutLabel.setText(Integer.toString(mmNumber.tries > 0 ? mmNumber.tries / mmNumber.games : 0));
    guessEntry.setText("");
    resultsListbox.clear();

    mmNumber.generate();
    changeFocus();
  }
  
  public void OnCheat()
  {
    alert("The secret number is: " + mmNumber.secret);
    changeFocus();
  }
  
  public void OnOk()
  {
    alert("");
    String x = guessEntry.getText();
    if (!mmNumber.islegal(x, true))
    {
      changeFocus();
      return;
    }

    mmNumber.input = x;
    mmNumber.curtries++;
    triesOutLabel.setText(Integer.toString(mmNumber.curtries));
    mmNumber.match();

    if (mmNumber.bulls == 4)
    {
      if (mmNumber.curtries <= 3)
      {
        alert("Just " + mmNumber.curtries + " tries? That was just plain luck!");
      }
      else if (mmNumber.curtries <= 6)
      {
        alert("Just " + mmNumber.curtries + " tries? Wow! You are a Master Mind!");
      }
      else if (mmNumber.curtries <= 8)
      {
        alert(mmNumber.curtries + " tries is about average. Can you do better?");
      }
      else if (mmNumber.curtries <= 10)
      {
        alert(mmNumber.curtries + " tries. Bad break eh? Give it another shot.");
      }
      else
      {
        alert(mmNumber.curtries + " tries! Not your day, huh?");
      }
      OnNewGame();
    }
    else
    {
      String newresults = mmNumber.curtries + ". "
                          + mmNumber.input + " -"
                          + " B:" + mmNumber.bulls
                          + " C:" + mmNumber.cows;
      resultsListbox.addItem(newresults, 0);
      resultsListbox.select(0);
    }
    changeFocus();
  }  

  public boolean handleEvent(Event event) 
  {
    if (event.target == newGameButton && event.id == event.ACTION_EVENT) 
    {
      OnNewGame();
    }
    else if (event.target == cheatButton && event.id == event.ACTION_EVENT) 
    {
      OnCheat();
    }
    else if (event.target == okButton && event.id == event.ACTION_EVENT) 
    {
      OnOk();
    }
    else if (event.target == guessEntry && event.id == event.KEY_RELEASE && event.key == 10) // ENTER key
    {
      OnOk();
    }
    else
      return super.handleEvent(event);
    return true;
  }

  public static void main(String[] args) 
  {
      Frame f = new Frame("Master Mind");
      MMind win = new MMind();
      win.init();
      f.add("Center", win);
      f.pack();
      f.show();
  }

  private void reset(GridBagConstraints con) 
  {
      con.gridx = GridBagConstraints.RELATIVE;
      con.gridy = GridBagConstraints.RELATIVE;
      con.gridwidth = 1;
      con.gridheight = 1;
   
      con.weightx = 0;
      con.weighty = 0;
      con.anchor = GridBagConstraints.CENTER;
      con.fill = GridBagConstraints.NONE;
   
      con.insets = new Insets(8, 8, 8, 8);
      con.ipadx = 0;
      con.ipady = 0;
  }
}