예제 #1
0
 /**
  * getTokenCreatures.
  *
  * @param cards a {@link java.util.ArrayList} object.
  * @return a {@link java.util.ArrayList} object.
  */
 public static ArrayList<Card> getTokenCreatures(ArrayList<Card> cards) {
   ArrayList<Card> ret = new ArrayList<Card>();
   for (Card c : cards) {
     if (c.isCreature() && c.isToken() && !c.isEquipped() && !c.isEnchanted()) ret.add(c);
   }
   return ret;
 }
예제 #2
0
 /**
  * getPlaneswalkers.
  *
  * @param cards a {@link java.util.ArrayList} object.
  * @return a {@link java.util.ArrayList} object.
  */
 public static ArrayList<Card> getPlaneswalkers(ArrayList<Card> cards) {
   ArrayList<Card> ret = new ArrayList<Card>();
   for (Card c : cards) {
     if (c.isPlaneswalker() && !c.isArtifact()) ret.add(c);
   }
   return ret;
 }
예제 #3
0
    /**
     * When the player click the BET button, check the input validity and process.
     *
     * @param e
     */
    @Override
    public void mouseClicked(MouseEvent e) {
      if (betButton.isEnabled()) {
        int bet = 0;
        try {
          bet = Integer.parseInt(betInput.getText());
          if (bet <= 0 || bet > player.getMoney()) throw null;
        } catch (Exception ex) {
          JOptionPane.showMessageDialog(null, "Invalid bet");
          betInput.setText(null);
          betInput.requestFocusInWindow();
          return;
        }

        int d1 = dealer.makeDecision();
        if (d1 != -1) {
          dealer.changeCard(d1, genNewCard());
          int d2 = dealer.makeDecision();
          if (d2 != -1) dealer.changeCard(d2, genNewCard());
        }

        player.makeBet(bet);
        for (Card card : player.getCards()) card.showFront();
        for (Card card : player.getCards()) card.addMouseListener(new ReplaceListener());
        betButton.setEnabled(false);
        resultButton.setEnabled(true);
        repaint();
      }
    }
예제 #4
0
 /**
  * getGlobalEnchantments.
  *
  * @param cards a {@link java.util.ArrayList} object.
  * @return a {@link java.util.ArrayList} object.
  */
 public static ArrayList<Card> getGlobalEnchantments(ArrayList<Card> cards) {
   ArrayList<Card> ret = new ArrayList<Card>();
   for (Card c : cards) {
     if (c.isGlobalEnchantment() && !c.isCreature()) ret.add(c);
   }
   return ret;
 }
예제 #5
0
  /**
   * getBasics.
   *
   * @param cards a {@link java.util.ArrayList} object.
   * @param color a {@link java.lang.String} object.
   * @return a {@link java.util.ArrayList} object.
   */
  public static ArrayList<Card> getBasics(ArrayList<Card> cards, String color) {
    ArrayList<Card> ret = new ArrayList<Card>();

    for (Card c : cards) {
      String name = c.getName();

      if (c.isEnchanted()) ; // do nothing
      else if (name.equals("Swamp") || name.equals("Bog")) {
        if (color == Constant.Color.Black) {
          ret.add(c);
        }
      } else if (name.equals("Forest") || name.equals("Grass")) {
        if (color == Constant.Color.Green) {
          ret.add(c);
        }

      } else if (name.equals("Plains") || name.equals("White Sand")) {
        if (color == Constant.Color.White) {
          ret.add(c);
        }

      } else if (name.equals("Mountain") || name.equals("Rock")) {
        if (color == Constant.Color.Red) {
          ret.add(c);
        }

      } else if (name.equals("Island") || name.equals("Underwater")) {
        if (color == Constant.Color.Blue) {
          ret.add(c);
        }
      }
    }

    return ret;
  }
예제 #6
0
 /**
  * getCard.
  *
  * @param cards a {@link java.util.ArrayList} object.
  * @param name a {@link java.lang.String} object.
  * @return a {@link java.util.ArrayList} object.
  */
 public static ArrayList<Card> getCard(ArrayList<Card> cards, String name) {
   ArrayList<Card> ret = new ArrayList<Card>();
   for (Card c : cards) {
     if (c.getName().equals(name)) ret.add(c);
   }
   return ret;
 }
예제 #7
0
  /**
   * getNonBasicLand.
   *
   * @param cards a {@link java.util.ArrayList} object.
   * @param landName a {@link java.lang.String} object.
   * @return a {@link java.util.ArrayList} object.
   */
  public static ArrayList<Card> getNonBasicLand(ArrayList<Card> cards, String landName) {
    ArrayList<Card> ret = new ArrayList<Card>();

    for (Card c : cards) if (c.getName().equals(landName)) ret.add(c);

    return ret;
  }
예제 #8
0
 /**
  * getMoxen.
  *
  * @param cards a {@link java.util.ArrayList} object.
  * @param moxName a {@link java.lang.String} object.
  * @return a {@link java.util.ArrayList} object.
  */
 public static ArrayList<Card> getMoxen(ArrayList<Card> cards, String moxName) {
   ArrayList<Card> ret = new ArrayList<Card>();
   for (Card c : cards) {
     String name = c.getName();
     if (name.equals(moxName) && !c.isCreature()) ret.add(c);
   }
   return ret;
 }
예제 #9
0
 /**
  * getTokenCreatures.
  *
  * @param cards a {@link java.util.ArrayList} object.
  * @param tokenName a {@link java.lang.String} object.
  * @return a {@link java.util.ArrayList} object.
  */
 public static ArrayList<Card> getTokenCreatures(ArrayList<Card> cards, String tokenName) {
   ArrayList<Card> ret = new ArrayList<Card>();
   for (Card c : cards) {
     String name = c.getName();
     if (c.isCreature() && c.isToken() && name.equals(tokenName)) ret.add(c);
   }
   return ret;
 }
예제 #10
0
 /**
  * devModeUntapPerm.
  *
  * @since 1.0.15
  */
 public static void devModeUntapPerm() {
   CardList play = AllZoneUtil.getCardsInPlay();
   Object o = GuiUtils.getChoiceOptional("Choose a permanent", play.toArray());
   if (null == o) return;
   else {
     Card c = (Card) o;
     c.untap();
   }
 }
예제 #11
0
 /**
  * getEnchantedLands.
  *
  * @param cards a {@link java.util.ArrayList} object.
  * @return a {@link java.util.ArrayList} object.
  */
 public static ArrayList<Card> getEnchantedLands(ArrayList<Card> cards) {
   ArrayList<Card> ret = new ArrayList<Card>();
   for (Card c : cards) {
     if (c.isLand() && c.isEnchanted()) {
       ret.addAll(c.getEnchantedBy());
       ret.add(c);
     }
   }
   return ret;
 }
예제 #12
0
 /**
  * When the player click a card for replacing, process and change the card.
  *
  * @see java.awt.event.MouseListener#mouseClicked(java.awt.event.MouseEvent)
  */
 @Override
 public void mouseClicked(MouseEvent e) {
   if (numReplaced < 2) {
     Card nCard = genNewCard();
     nCard.addMouseListener(this);
     player.changeCard(player.getCards().indexOf(e.getSource()), nCard);
     ++numReplaced;
     repaint();
   }
 }
예제 #13
0
 /** devModeGenerateMana. */
 public static void devModeGenerateMana() {
   Card dummy = new Card();
   dummy.setOwner(AllZone.getHumanPlayer());
   dummy.setController(AllZone.getHumanPlayer());
   Ability_Mana abMana =
       new Ability_Mana(dummy, "0", "W U B G R 1", 10) {
         private static final long serialVersionUID = -2164401486331182356L;
       };
   abMana.produceMana();
 }
예제 #14
0
  /**
   * formatCardType.
   *
   * @param card a {@link forge.Card} object.
   * @return a {@link java.lang.String} object.
   */
  public static String formatCardType(Card card) {
    ArrayList<String> list = card.getType();
    StringBuilder sb = new StringBuilder();

    ArrayList<String> superTypes = new ArrayList<String>();
    ArrayList<String> cardTypes = new ArrayList<String>();
    ArrayList<String> subTypes = new ArrayList<String>();
    for (String t : list) {
      if (CardUtil.isASuperType(t)) superTypes.add(t);
      if (CardUtil.isACardType(t)) cardTypes.add(t);
      if (CardUtil.isASubType(t)) subTypes.add(t);
    }

    for (String type : superTypes) {
      sb.append(type).append(" ");
    }
    for (String type : cardTypes) {
      sb.append(type).append(" ");
    }
    if (!subTypes.isEmpty()) sb.append("- ");
    for (String type : subTypes) {
      sb.append(type).append(" ");
    }

    return sb.toString();
  }
예제 #15
0
 /**
  * devModeAddCounter.
  *
  * @since 1.0.15
  */
 public static void devModeAddCounter() {
   CardList play = AllZoneUtil.getCardsInPlay();
   Object o = GuiUtils.getChoiceOptional("Add counters to which card?", play.toArray());
   if (null == o) return;
   else {
     Card c = (Card) o;
     Counters counter = GuiUtils.getChoiceOptional("Which type of counter?", Counters.values());
     if (null == counter) return;
     else {
       Integer integers[] = new Integer[99];
       for (int j = 0; j < 99; j++) integers[j] = Integer.valueOf(j);
       Integer i = GuiUtils.getChoiceOptional("How many counters?", integers);
       if (null == i) return;
       else {
         c.addCounterFromNonEffect(counter, i);
       }
     }
   }
 }
예제 #16
0
  /**
   * getEquippedEnchantedCreatures.
   *
   * @param cards a {@link java.util.ArrayList} object.
   * @return a {@link java.util.ArrayList} object.
   */
  public static ArrayList<Card> getEquippedEnchantedCreatures(ArrayList<Card> cards) {
    ArrayList<Card> ret = new ArrayList<Card>();
    for (Card c : cards) {
      if (c.isCreature() && (c.isEquipped() || c.isEnchanted())) {
        if (c.isEquipped()) ret.addAll(c.getEquippedBy());
        if (c.isEnchanted()) ret.addAll(c.getEnchantedBy());

        ret.add(c);
      }
    }
    return ret;
  }
예제 #17
0
 private void judge() {
   if (player.numOfSpecialCards() > dealer.numOfSpecialCards()) {
     player.win();
     dealer.lose();
   } else if (player.numOfSpecialCards() < dealer.numOfSpecialCards()) {
     dealer.win();
     player.lose();
   } else {
     int playerScore = 0, dealerScore = 0;
     for (Card card : player.getCards()) {
       if (!card.isSpecial()) playerScore += card.getValue();
       playerScore %= 10;
     }
     for (Card card : dealer.getCards()) {
       if (!card.isSpecial()) dealerScore += card.getValue();
       dealerScore %= 10;
     }
     if (playerScore > dealerScore) {
       player.win();
       dealer.lose();
     } else {
       dealer.win();
       player.lose();
     }
   }
 }
예제 #18
0
  /**
   * getNonBasics.
   *
   * @param cards a {@link java.util.ArrayList} object.
   * @return a {@link java.util.ArrayList} object.
   */
  public static ArrayList<Card> getNonBasics(ArrayList<Card> cards) {
    ArrayList<Card> ret = new ArrayList<Card>();

    for (Card c : cards) {
      if (!c.isLand() && !c.getName().startsWith("Mox") && !(c instanceof ManaPool)) {
        ret.add(c);
      } else {
        String name = c.getName();
        if (c.isEnchanted()
            || name.equals("Swamp")
            || name.equals("Bog")
            || name.equals("Forest")
            || name.equals("Grass")
            || name.equals("Plains")
            || name.equals("White Sand")
            || name.equals("Mountain")
            || name.equals("Rock")
            || name.equals("Island")
            || name.equals("Underwater")
            || name.equals("Badlands")
            || name.equals("Bayou")
            || name.equals("Plateau")
            || name.equals("Scrubland")
            || name.equals("Savannah")
            || name.equals("Taiga")
            || name.equals("Tropical Island")
            || name.equals("Tundra")
            || name.equals("Underground Sea")
            || name.equals("Volcanic Island")
            || name.startsWith("Mox")
            || c instanceof ManaPool) {
          // do nothing.
        } else {
          ret.add(c);
        }
      }
    }

    return ret;
  }
예제 #19
0
 /**
  * When the player click the RESULT button, update the UI and judge the game, and then restart a
  * round or a game.
  *
  * @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
  */
 @Override
 public void mouseClicked(MouseEvent e) {
   if (resultButton.isEnabled()) {
     for (Card card : dealer.getCards()) card.showFront();
     betInput.setText(null);
     judge();
     bestScore = player.getMoney() > bestScore ? player.getMoney() : bestScore;
     ++roundsPlayed;
     repaint();
     if (player.getMoney() == 0) {
       JOptionPane.showMessageDialog(null, "All money lost, starting a new game :(");
       newGame();
     } else {
       removeAll();
       if (roundsPlayed == 5) {
         roundsPlayed = 0;
         JOptionPane.showMessageDialog(null, "reshuffling...");
         cardUsed.clear();
       }
       initRound();
       repaint();
     }
   }
 }
예제 #20
0
 /**
  * getNonCreatureArtifacts.
  *
  * @param cards a {@link java.util.ArrayList} object.
  * @return a {@link java.util.ArrayList} object.
  */
 public static ArrayList<Card> getNonCreatureArtifacts(ArrayList<Card> cards) {
   ArrayList<Card> ret = new ArrayList<Card>();
   for (Card c : cards) {
     String name = c.getName();
     if (c.isArtifact()
         && !c.isCreature()
         && !c.isLand()
         && !c.isGlobalEnchantment()
         && !(c.isEquipment() && c.isEquipping())
         && !name.equals("Mox Emerald")
         && !name.equals("Mox Jet")
         && !name.equals("Mox Pearl")
         && !name.equals("Mox Ruby")
         && !name.equals("Mox Sapphire")) ret.add(c);
   }
   return ret;
 }
예제 #21
0
  /**
   * devProcessCardsForZone.
   *
   * @param data an array of {@link java.lang.String} objects.
   * @param player a {@link forge.Player} object.
   * @return a {@link forge.CardList} object.
   */
  public static CardList devProcessCardsForZone(String[] data, Player player) {
    CardList cl = new CardList();
    for (int i = 0; i < data.length; i++) {
      String cardinfo[] = data[i].trim().split("\\|");

      Card c = AllZone.getCardFactory().getCard(cardinfo[0], player);

      if (cardinfo.length != 2) c.setCurSetCode(c.getMostRecentSet());
      else c.setCurSetCode(cardinfo[1]);

      c.setImageFilename(CardUtil.buildFilename(c));
      for (Trigger trig : c.getTriggers()) {
        AllZone.getTriggerHandler().registerTrigger(trig);
      }
      cl.add(c);
    }
    return cl;
  }
예제 #22
0
  /**
   * getBorder.
   *
   * @param card a {@link forge.Card} object.
   * @return a {@link javax.swing.border.Border} object.
   */
  public static Border getBorder(Card card) {
    // color info
    if (card == null) return BorderFactory.createEmptyBorder(2, 2, 2, 2);
    java.awt.Color color;
    ArrayList<String> list = CardUtil.getColors(card);

    if (card.isFaceDown()) color = Color.gray;
    else if (list.size() > 1) color = Color.orange;
    else if (list.get(0).equals(Constant.Color.Black)) color = Color.black;
    else if (list.get(0).equals(Constant.Color.Green)) color = new Color(0, 220, 39);
    else if (list.get(0).equals(Constant.Color.White)) color = Color.white;
    else if (list.get(0).equals(Constant.Color.Red)) color = Color.red;
    else if (list.get(0).equals(Constant.Color.Blue)) color = Color.blue;
    else if (list.get(0).equals(Constant.Color.Colorless)) color = Color.gray;
    else color = new Color(200, 0, 230); // If your card has a violet border, something is wrong

    if (color != Color.gray) {

      int r = color.getRed();
      int g = color.getGreen();
      int b = color.getBlue();

      int shade = 10;

      r -= shade;
      g -= shade;
      b -= shade;

      r = Math.max(0, r);
      g = Math.max(0, g);
      b = Math.max(0, b);

      color = new Color(r, g, b);

      return BorderFactory.createLineBorder(color, 2);
    } else return BorderFactory.createLineBorder(Color.gray, 2);
  }
예제 #23
0
 @Override
 public void draw(Graphics2D g2d) {
   // After updating we will draw all the objects to the screen
   g2d.setColor(Color.WHITE);
   g2d.fillRect(0, 0, windowWidth, windowHeight);
   g2d.setColor(Color.BLACK);
   Font font = new Font("Arial", Font.BOLD, 30);
   g2d.setFont(font);
   int textWidth =
       (int)
           (font.getStringBounds("You Are Now In Battle State", g2d.getFontRenderContext())
               .getWidth());
   g2d.drawString(
       "You Are Now In Battle State", windowWidth / 2 - textWidth / 2, windowHeight / 2);
   // Draw the battle images of the enemy and MainCharacter
   g2d.drawImage(
       mainCharacterImage,
       60,
       3 * windowHeight / 4 - 2 * 60,
       mainCharacterImage.getWidth() * 2,
       mainCharacterImage.getHeight() * 2,
       null);
   g2d.drawImage(
       enemyImage,
       windowWidth - 60 - enemyImage.getWidth(),
       60,
       enemyImage.getWidth(),
       enemyImage.getHeight(),
       null);
   // Draw an action box at the bottom where we decide our actions on each turn
   g2d.setColor(Color.CYAN);
   g2d.fillRect(0, 3 * windowHeight / 4, windowWidth, windowHeight / 4 + 2);
   // Draw the hp and mp bars of the MainCharacter and the Enemy
   g2d.setColor(Color.BLACK);
   g2d.drawRect(0, 3 * windowHeight / 4, windowWidth, windowHeight / 4 + 2);
   Font hpFont = new Font("Arial", Font.BOLD, 15);
   g2d.setFont(hpFont);
   String text =
       "Health: "
           + String.valueOf(StartGameState.character.health)
           + "/"
           + String.valueOf(StartGameState.character.maxHealth);
   textWidth = (int) (hpFont.getStringBounds(text, g2d.getFontRenderContext()).getWidth());
   g2d.drawString(
       text, 60 + mainCharacterImage.getWidth() * 2 + 45, 3 * windowHeight / 4 - 30 - 15 - 20);
   text =
       "Mana:  "
           + String.valueOf(StartGameState.character.mana)
           + "/"
           + String.valueOf(StartGameState.character.maxMana);
   g2d.drawString(text, 60 + mainCharacterImage.getWidth() * 2 + 45, 3 * windowHeight / 4 - 30);
   text = MainCharacter.characterName;
   g2d.drawString(
       text,
       60 + mainCharacterImage.getWidth() * 2 + 45,
       3 * windowHeight / 4 - 30 - 2 * 15 - 2 * 20);
   g2d.setColor(Color.GRAY);
   g2d.fillRoundRect(
       60 + mainCharacterImage.getWidth() * 2 + 45 + textWidth + 20,
       3 * windowHeight / 4 - 45 - 15 - 20,
       100,
       15,
       3,
       3);
   g2d.fillRoundRect(
       60 + mainCharacterImage.getWidth() * 2 + 45 + textWidth + 20,
       3 * windowHeight / 4 - 45,
       100,
       15,
       3,
       3);
   g2d.setColor(Color.GREEN);
   g2d.fillRoundRect(
       60 + mainCharacterImage.getWidth() * 2 + 45 + textWidth + 20,
       3 * windowHeight / 4 - 45 - 15 - 20,
       (int)
           (((float) StartGameState.character.health / (float) StartGameState.character.maxHealth)
               * 100),
       15,
       3,
       3);
   g2d.setColor(Color.BLUE);
   g2d.fillRoundRect(
       60 + mainCharacterImage.getWidth() * 2 + 45 + textWidth + 20,
       3 * windowHeight / 4 - 45,
       (int)
           (((float) StartGameState.character.mana / (float) StartGameState.character.maxMana)
               * 100),
       15,
       3,
       3);
   g2d.setColor(Color.BLACK);
   g2d.drawRoundRect(
       60 + mainCharacterImage.getWidth() * 2 + 45 + textWidth + 20,
       3 * windowHeight / 4 - 45 - 15 - 20,
       100,
       15,
       3,
       3);
   g2d.drawRoundRect(
       60 + mainCharacterImage.getWidth() * 2 + 45 + textWidth + 20,
       3 * windowHeight / 4 - 45,
       100,
       15,
       3,
       3);
   // Enemy health and mana bars
   text = "Health: " + String.valueOf(enemy.health) + "/" + String.valueOf(enemy.maxHealth);
   textWidth = (int) (hpFont.getStringBounds(text, g2d.getFontRenderContext()).getWidth());
   g2d.drawString(
       text, windowWidth - 60 - enemyImage.getWidth() - 45 - 100 - 20 - textWidth, 60 + 15);
   text = "Mana:  " + String.valueOf(enemy.mana) + "/" + String.valueOf(enemy.maxMana);
   g2d.drawString(
       text,
       windowWidth - 60 - enemyImage.getWidth() - 45 - 100 - 20 - textWidth,
       60 + 2 * 15 + 20);
   text = enemy.getName();
   g2d.drawString(
       text, windowWidth - 60 - enemyImage.getWidth() - 45 - 100 - 20 - textWidth, 60 - 20);
   g2d.setColor(Color.GRAY);
   g2d.fillRoundRect(windowWidth - 60 - enemyImage.getWidth() - 45 - 100, 60, 100, 15, 3, 3);
   g2d.fillRoundRect(
       windowWidth - 60 - enemyImage.getWidth() - 45 - 100, 60 + 15 + 20, 100, 15, 3, 3);
   g2d.setColor(Color.GREEN);
   g2d.fillRoundRect(
       windowWidth - 60 - enemyImage.getWidth() - 45 - 100,
       60,
       (int) (((float) enemy.health / (float) enemy.maxHealth) * 100),
       15,
       3,
       3);
   g2d.setColor(Color.BLUE);
   g2d.fillRoundRect(
       windowWidth - 60 - enemyImage.getWidth() - 45 - 100,
       60 + 15 + 20,
       (int) (((float) enemy.mana / (float) enemy.maxMana) * 100),
       15,
       3,
       3);
   g2d.setColor(Color.BLACK);
   g2d.drawRoundRect(windowWidth - 60 - enemyImage.getWidth() - 45 - 100, 60, 100, 15, 3, 3);
   g2d.drawRoundRect(
       windowWidth - 60 - enemyImage.getWidth() - 45 - 100, 60 + 15 + 20, 100, 15, 3, 3);
   // Draw the player's hand and the current card
   int x = drawButton.getX() + drawButton.getWidth() + 40;
   int y = drawButton.getY() + 10;
   int i = 0;
   if (deckCount < MainCharacter.deck.size()) {
     g2d.drawImage(cardBack, 3 * windowWidth / 4 - 15 - cardBack.getWidth(), y, null);
   }
   if (hand.size() > 0) {
     int cardSpacing = cardWidth / hand.size();
     for (Card card : hand.values()) {
       if (i != cardScroller.getCountX() - 1) {
         card.draw(g2d, x + i * (cardSpacing), y, 0, 0);
       }
       i++;
     }
     Card current = hand.getIndexed(cardScroller.getCountX() - 1);
     current.draw(g2d, x + (cardScroller.getCountX() - 1) * (cardSpacing), y - 20, 0, 0);
     // If it is MainCharacter turn then we draw the actions in the action box
     g2d.setFont(new Font("Arial", Font.BOLD, 20));
     g2d.setColor(Color.BLACK);
     int explanationWidth = windowWidth / 4 - 25;
     g2d.drawString(current.getName(), 3 * windowWidth / 4 + 15, cardButton.getY());
     Font explanationFont = new Font("Arial", Font.BOLD, 10);
     g2d.setFont(explanationFont);
     ArrayList<String> lines = new ArrayList<>();
     // Determines width and height of only the text
     String dialog = current.getExplanation();
     int width =
         (int) (explanationFont.getStringBounds(dialog, g2d.getFontRenderContext()).getWidth());
     if (width > explanationWidth) {
       String[] split = dialog.split("\\s+");
       int tempWidth = 0;
       int maxWidth = 0;
       String line = "";
       for (i = 0; i < split.length; i++) {
         tempWidth +=
             (int)
                 (explanationFont
                     .getStringBounds(split[i] + "_", g2d.getFontRenderContext())
                     .getWidth());
         if (tempWidth > explanationWidth) {
           tempWidth =
               (int)
                   (explanationFont
                       .getStringBounds(split[i] + "_", g2d.getFontRenderContext())
                       .getWidth());
           lines.add(line);
           line = split[i] + " ";
         } else {
           line = line + split[i] + " ";
         }
         if (tempWidth > maxWidth) {
           maxWidth = tempWidth;
         }
       }
       lines.add(line);
     } else {
       lines.add(dialog);
     }
     for (i = 0; i < lines.size(); i++) {
       g2d.drawString(
           lines.get(i), 3 * windowWidth / 4 + 15, cardButton.getY() + (i + 1) * (10 + 4));
     }
     g2d.setFont(hpFont);
     String[] effects = current.getEffectStrings();
     for (i = 0; i < effects.length; i++) {
       g2d.drawString(
           effects[i],
           3 * windowWidth / 4 + 15,
           cardButton.getY() + (lines.size()) * (10 + 4) + (i + 1) * (5 + 15));
     }
     g2d.drawString(
         "Mana Cost: " + String.valueOf(current.getManaCost()),
         3 * windowWidth / 4 + 15,
         cardButton.getY() + (lines.size()) * (10 + 4) + (i + 1) * (15 + 5));
   }
   if (drawNoMana) {
     g2d.setFont(new Font("Arial", Font.BOLD, 15));
     g2d.drawString("You don't have", cardButton.getX(), cardButton.getY() + 15);
     g2d.drawString("enough mana!", cardButton.getX(), cardButton.getY() + 2 * 15 + 10);
   } else if (drawNoCards) {
     g2d.setFont(new Font("Arial", Font.BOLD, 15));
     g2d.drawString("You are out of", cardButton.getX(), cardButton.getY() + 15);
     g2d.drawString("cards to draw!", cardButton.getX(), cardButton.getY() + 2 * 15 + 10);
   } else if (drawItemUsed) {
     g2d.setFont(new Font("Arial", Font.BOLD, 15));
     g2d.drawString("You have used", cardButton.getX(), cardButton.getY() + 15);
     g2d.drawString(
         itemMenu.getLastItem().name + "!", cardButton.getX(), cardButton.getY() + 2 * 15 + 10);
   } else if (turn == 0 && drawParalyzed) {
     g2d.setFont(new Font("Arial", Font.BOLD, 15));
     g2d.drawString("You cannot move,", cardButton.getX(), cardButton.getY() + 15);
     g2d.drawString("you're paralyzed!", cardButton.getX(), cardButton.getY() + 2 * 15 + 10);
   } else if (turn == 1 && drawParalyzed) {
     Font messageFont = new Font("Arial", Font.BOLD, 15);
     g2d.setFont(messageFont);
     text = enemy.getName() + " cannot move, they're paralyzed!";
     ArrayList<String> lines = new ArrayList<>();
     int width = (int) (messageFont.getStringBounds(text, g2d.getFontRenderContext()).getWidth());
     if (width > cardButton.getWidth() * 2 + 40) {
       String[] split = text.split("\\s+");
       int tempWidth = 0;
       int maxWidth = 0;
       String line = "";
       for (i = 0; i < split.length; i++) {
         tempWidth +=
             (int)
                 (messageFont
                     .getStringBounds(split[i] + "_", g2d.getFontRenderContext())
                     .getWidth());
         if (tempWidth > cardButton.getWidth() * 2 + 40) {
           tempWidth =
               (int)
                   (messageFont
                       .getStringBounds(split[i] + "_", g2d.getFontRenderContext())
                       .getWidth());
           lines.add(line);
           line = split[i] + " ";
         } else {
           line = line + split[i] + " ";
         }
         if (tempWidth > maxWidth) {
           maxWidth = tempWidth;
         }
       }
       lines.add(line);
     } else {
       lines.add(text);
     }
     for (i = 0; i < lines.size(); i++) {
       g2d.drawString(lines.get(i), cardButton.getX(), cardButton.getY() + 15 + 30 * i);
     }
   } else if (turn == 0 && turnState == 4) {
     g2d.setFont(new Font("Arial", Font.BOLD, 15));
     g2d.drawString("You try to", cardButton.getX(), cardButton.getY() + 15);
     g2d.drawString("run away...", cardButton.getX(), cardButton.getY() + 2 * 15 + 10);
   } else if (turn == 0 && turnState == 5) {
     Font messageFont = new Font("Arial", Font.BOLD, 15);
     g2d.setFont(messageFont);
     if (drawMoveApplication) {
       text = effectMessage;
     } else {
       text = "You have used " + playedCard.getName() + " on " + enemy.getName() + "!";
     }
     ArrayList<String> lines = new ArrayList<>();
     int width = (int) (messageFont.getStringBounds(text, g2d.getFontRenderContext()).getWidth());
     if (width > cardButton.getWidth() * 2 + 40) {
       String[] split = text.split("\\s+");
       int tempWidth = 0;
       int maxWidth = 0;
       String line = "";
       for (i = 0; i < split.length; i++) {
         tempWidth +=
             (int)
                 (messageFont
                     .getStringBounds(split[i] + "_", g2d.getFontRenderContext())
                     .getWidth());
         if (tempWidth > cardButton.getWidth() * 2 + 40) {
           tempWidth =
               (int)
                   (messageFont
                       .getStringBounds(split[i] + "_", g2d.getFontRenderContext())
                       .getWidth());
           lines.add(line);
           line = split[i] + " ";
         } else {
           line = line + split[i] + " ";
         }
         if (tempWidth > maxWidth) {
           maxWidth = tempWidth;
         }
       }
       lines.add(line);
     } else {
       lines.add(text);
     }
     for (i = 0; i < lines.size(); i++) {
       g2d.drawString(lines.get(i), cardButton.getX(), cardButton.getY() + 15 + 30 * i);
     }
   } else if (turn == 0) {
     drawActionBox(g2d);
   } else if (turn == 1) {
     drawEnemyMessage(g2d);
   } else if (turn == 2) {
     drawVictoryMessage(g2d);
   } else if (turn == 3) {
     drawLossMessage(g2d);
   }
 }
예제 #24
0
 @Override
 public void update(float elapsedTime, boolean[][] keyboardstate) {
   // All the main battle logic will go here
   if (turn == 0) { // If it's the MainCharacter turn we do something
     if (StartGameState.character.isParalyzed()) {
       if (drawParalyzed) {
         StartGameState.character.paralyzeCount -= 1;
         turn = 1;
         try {
           Thread.sleep(2000);
         } catch (InterruptedException ex) {
         }
         drawParalyzed = false;
       } else {
         drawParalyzed = true;
       }
     } else {
       if (turnState == 0) {
         if (keyboardstate[KeyEvent.VK_ENTER][1]) {
           if (actionScroller.getCountX() == 1 && actionScroller.getCountY() == 1) {
             turnState = 1;
             System.out.println(turnState);
           } else if (actionScroller.getCountX() == 1 && actionScroller.getCountY() == 2) {
             turnState = 2;
             System.out.println(turnState);
           } else if (actionScroller.getCountX() == 2 && actionScroller.getCountY() == 1) {
             turnState = 3;
             System.out.println(turnState);
           } else if (actionScroller.getCountX() == 2 && actionScroller.getCountY() == 2) {
             turnState = 4;
             System.out.println(turnState);
           }
         } else {
           if (!keyboardstate[KeyEvent.VK_S][0]
               && !keyboardstate[KeyEvent.VK_W][0]
               && !keyboardstate[KeyEvent.VK_A][0]
               && !keyboardstate[KeyEvent.VK_D][0]) { // Handle the absence of scrolling
             // Reset the scroller action variables
             actionScroller.scrollDirection = -1;
             actionScroller.scrollTimer = 0;
           } else {
             if (keyboardstate[KeyEvent.VK_S][0] && keyboardstate[KeyEvent.VK_W][0]) {
               actionScroller.scrollDirection = -1;
               actionScroller.scrollTimer = 0;
             } else if (keyboardstate[KeyEvent.VK_S][1]) {
               if (actionScroller.scrollDirection
                   == 0) { // If the scroller was already scrolling down...
                 actionScroller.scrollTimer +=
                     elapsedTime; // We add the elapsed time to the scroll timer...
                 if (actionScroller.scrollTimer
                     > actionScroller
                         .TIMER_MAX) { // And determine if we've waited to long enough ...
                   actionScroller.scrollTimer -=
                       actionScroller
                           .TIMER_MAX; // To justify a scroll. We reset the scrollTimer...
                   actionScroller.scrollDown(); // And finally we scroll down.
                 }
               } else { // If the scroller was not already scrolling down...
                 actionScroller.scrollDown(); // We scroll down...
                 actionScroller.scrollDirection = 0; // Set the scroll direction to down...
                 actionScroller.scrollTimer = 0; // And reset the scrollTimer.
               }
             } else if (keyboardstate[KeyEvent.VK_W][1]) {
               if (actionScroller.scrollDirection
                   == 3) { // If the scroller was already scrolling up...
                 actionScroller.scrollTimer +=
                     elapsedTime; // We add the elapsed time to the scroll timer...
                 if (actionScroller.scrollTimer
                     > actionScroller
                         .TIMER_MAX) { // And determine if we've waited to long enough ...
                   actionScroller.scrollTimer -=
                       actionScroller
                           .TIMER_MAX; // To justify a scroll. We reset the scrollTimer...
                   actionScroller.scrollUp(); // And finally we scroll up.
                 }
               } else { // If the scroller was not already scrolling up...
                 actionScroller.scrollUp(); // We scroll up...
                 actionScroller.scrollDirection = 3; // Set the scroll direction to up...
                 actionScroller.scrollTimer = 0; // And reset the scrollTimer.
               }
             }
             if (keyboardstate[KeyEvent.VK_A][0] && keyboardstate[KeyEvent.VK_D][0]) {
               actionScroller.scrollDirection = -1;
               actionScroller.scrollTimer = 0;
             } else if (keyboardstate[KeyEvent.VK_A][1]) {
               if (actionScroller.scrollDirection
                   == 1) { // If the scroller was already scrolling down...
                 actionScroller.scrollTimer +=
                     elapsedTime; // We add the elapsed time to the scroll timer...
                 if (actionScroller.scrollTimer
                     > actionScroller
                         .TIMER_MAX) { // And determine if we've waited to long enough ...
                   actionScroller.scrollTimer -=
                       actionScroller
                           .TIMER_MAX; // To justify a scroll. We reset the scrollTimer...
                   actionScroller.scrollLeft(); // And finally we scroll down.
                 }
               } else { // If the scroller was not already scrolling down...
                 actionScroller.scrollLeft(); // We scroll down...
                 actionScroller.scrollDirection = 1; // Set the scroll direction to down...
                 actionScroller.scrollTimer = 0; // And reset the scrollTimer.
               }
             } else if (keyboardstate[KeyEvent.VK_D][1]) {
               if (actionScroller.scrollDirection
                   == 2) { // If the scroller was already scrolling up...
                 actionScroller.scrollTimer +=
                     elapsedTime; // We add the elapsed time to the scroll timer...
                 if (actionScroller.scrollTimer
                     > actionScroller
                         .TIMER_MAX) { // And determine if we've waited to long enough ...
                   actionScroller.scrollTimer -=
                       actionScroller
                           .TIMER_MAX; // To justify a scroll. We reset the scrollTimer...
                   actionScroller.scrollRight(); // And finally we scroll up.
                 }
               } else { // If the scroller was not already scrolling up...
                 actionScroller.scrollRight(); // We scroll up...
                 actionScroller.scrollDirection = 2; // Set the scroll direction to up...
                 actionScroller.scrollTimer = 0; // And reset the scrollTimer.
               }
             }
           }
         }
       } else if (turnState == 1) {
         if (drawNoMana) {
           try {
             Thread.sleep(2000);
           } catch (InterruptedException ex) {
           }
           drawNoMana = false;
         } else {
           if (keyboardstate[KeyEvent.VK_BACK_SPACE][1]) {
             turnState = 0;
           } else if (keyboardstate[KeyEvent.VK_ENTER][1]) {
             playedCard = hand.getIndexed(cardScroller.getCountX() - 1);
             if (StartGameState.character.mana < playedCard.getManaCost()) {
               drawNoMana = true;
             } else {
               turnState = 5;
               hand.remove(hand.getIndexedKey(cardScroller.getCountX() - 1));
               cardScroller.setMenuCountX(hand.size());
               cardScroller.setCountX(cardScroller.getCountX() - 1);
               if (cardScroller.getCountX() <= 0) {
                 cardScroller.setCountX(1);
               }
               if (hand.size() > 0) {
                 cardScroller.setMenuSpacingX(cardWidth / hand.size());
               }
             }
           } else {
             if (!keyboardstate[KeyEvent.VK_S][0]
                 && !keyboardstate[KeyEvent.VK_W][0]
                 && !keyboardstate[KeyEvent.VK_A][0]
                 && !keyboardstate[KeyEvent.VK_D][0]) { // Handle the absence of scrolling
               // Reset the scroller action variables
               cardScroller.scrollDirection = -1;
               cardScroller.scrollTimer = 0;
             } else {
               if (keyboardstate[KeyEvent.VK_S][0] && keyboardstate[KeyEvent.VK_W][0]) {
                 cardScroller.scrollDirection = -1;
                 cardScroller.scrollTimer = 0;
               } else if (keyboardstate[KeyEvent.VK_S][1]) {
                 if (cardScroller.scrollDirection
                     == 0) { // If the scroller was already scrolling down...
                   cardScroller.scrollTimer +=
                       elapsedTime; // We add the elapsed time to the scroll timer...
                   if (cardScroller.scrollTimer
                       > cardScroller
                           .TIMER_MAX) { // And determine if we've waited to long enough ...
                     cardScroller.scrollTimer -=
                         cardScroller
                             .TIMER_MAX; // To justify a scroll. We reset the scrollTimer...
                     cardScroller.scrollDown(); // And finally we scroll down.
                   }
                 } else { // If the scroller was not already scrolling down...
                   cardScroller.scrollDown(); // We scroll down...
                   cardScroller.scrollDirection = 0; // Set the scroll direction to down...
                   cardScroller.scrollTimer = 0; // And reset the scrollTimer.
                 }
               } else if (keyboardstate[KeyEvent.VK_W][1]) {
                 if (cardScroller.scrollDirection
                     == 3) { // If the scroller was already scrolling up...
                   cardScroller.scrollTimer +=
                       elapsedTime; // We add the elapsed time to the scroll timer...
                   if (cardScroller.scrollTimer
                       > cardScroller
                           .TIMER_MAX) { // And determine if we've waited to long enough ...
                     cardScroller.scrollTimer -=
                         cardScroller
                             .TIMER_MAX; // To justify a scroll. We reset the scrollTimer...
                     cardScroller.scrollUp(); // And finally we scroll up.
                   }
                 } else { // If the scroller was not already scrolling up...
                   cardScroller.scrollUp(); // We scroll up...
                   cardScroller.scrollDirection = 3; // Set the scroll direction to up...
                   cardScroller.scrollTimer = 0; // And reset the scrollTimer.
                 }
               }
               if (keyboardstate[KeyEvent.VK_A][0] && keyboardstate[KeyEvent.VK_D][0]) {
                 cardScroller.scrollDirection = -1;
                 cardScroller.scrollTimer = 0;
               } else if (keyboardstate[KeyEvent.VK_A][1]) {
                 if (cardScroller.scrollDirection
                     == 1) { // If the scroller was already scrolling down...
                   cardScroller.scrollTimer +=
                       elapsedTime; // We add the elapsed time to the scroll timer...
                   if (cardScroller.scrollTimer
                       > cardScroller
                           .TIMER_MAX) { // And determine if we've waited to long enough ...
                     cardScroller.scrollTimer -=
                         cardScroller
                             .TIMER_MAX; // To justify a scroll. We reset the scrollTimer...
                     cardScroller.scrollLeft(); // And finally we scroll down.
                   }
                 } else { // If the scroller was not already scrolling down...
                   cardScroller.scrollLeft(); // We scroll down...
                   cardScroller.scrollDirection = 1; // Set the scroll direction to down...
                   cardScroller.scrollTimer = 0; // And reset the scrollTimer.
                 }
               } else if (keyboardstate[KeyEvent.VK_D][1]) {
                 if (cardScroller.scrollDirection
                     == 2) { // If the scroller was already scrolling up...
                   cardScroller.scrollTimer +=
                       elapsedTime; // We add the elapsed time to the scroll timer...
                   if (cardScroller.scrollTimer
                       > cardScroller
                           .TIMER_MAX) { // And determine if we've waited to long enough ...
                     cardScroller.scrollTimer -=
                         cardScroller
                             .TIMER_MAX; // To justify a scroll. We reset the scrollTimer...
                     cardScroller.scrollRight(); // And finally we scroll up.
                   }
                 } else { // If the scroller was not already scrolling up...
                   cardScroller.scrollRight(); // We scroll up...
                   cardScroller.scrollDirection = 2; // Set the scroll direction to up...
                   cardScroller.scrollTimer = 0; // And reset the scrollTimer.
                 }
               }
             }
           }
         }
       } else if (turnState == 2) {
         if (shouldWait) {
           if (itemMenu.isActive()) {
             itemMenu.update(elapsedTime, keyboardstate);
             if (keyboardstate[KeyEvent.VK_ENTER][1]) {
               itemMenu.setActive(false);
               drawItemUsed = true;
             }
           } else {
             shouldWait = false;
             drawItemUsed = false;
             try {
               // Waits a little on the enemy turn, this is just for testing and will be removed
               // when AI is written
               Thread.sleep(1500);
             } catch (InterruptedException ex) {
             }
             turnState = 0;
             turn = 1;
           }
         } else {
           itemMenu.setActive(true);
           if (keyboardstate[KeyEvent.VK_BACK_SPACE][1]) {
             turnState = 0;
             itemMenu.setActive(false);
           } else {
             itemMenu.update(elapsedTime, keyboardstate);
             if (keyboardstate[KeyEvent.VK_ENTER][1]) {
               if (itemMenu.state == 1 && itemMenu.error == false) {
                 shouldWait = true;
               }
             }
           }
         }
       } else if (turnState == 3) {
         if (shouldWait) {
           try {
             // Waits a little on the enemy turn, this is just for testing and will be removed when
             // AI is written
             Thread.sleep(2000);
           } catch (InterruptedException ex) {
           }
           drawNoCards = false;
           shouldWait = false;
           turnState = 0;
         } else {
           if (keyboardstate[KeyEvent.VK_BACK_SPACE][1]) {
             turnState = 0;
           } else if (keyboardstate[KeyEvent.VK_ENTER][1]) {
             if (deckCount >= MainCharacter.deck.size()) {
               drawNoCards = true;
               shouldWait = true;
             } else {
               hand.put(
                   hand.getIndexedKey(hand.size() - 1) + 1, MainCharacter.deck.get(deckCount));
               cardScroller.setMenuCountX(hand.size());
               cardScroller.setMenuSpacingX(cardWidth / hand.size());
               deckCount++;
               turn = 1;
               turnState = 0;
             }
           }
         }
       } else if (turnState == 4) {
         if (keyboardstate[KeyEvent.VK_BACK_SPACE][1]) {
           turnState = 0;
         }
       } else if (turnState == 5) {
         try {
           if (drawMoveApplication) {
             Thread.sleep(1800);
             if (enemy.health > 0) {
               turn = 1;
               turnState = 0;
             } else {
               turn = 2;
             }
             drawMoveApplication = false;
           } else {
             Thread.sleep(1800);
             effectMessage = playedCard.applyEffect(StartGameState.character, enemy);
             drawMoveApplication = true;
           }
         } catch (InterruptedException ex) {
         }
       }
     }
   } else if (turn
       == 1) { // If it's the Enemy's turn we can't do anything, and the AI decides what to do
     try {
       if (enemy.isParalyzed()) {
         if (drawParalyzed) {
           enemy.paralyzeCount -= 1;
           turn = 0;
           try {
             Thread.sleep(2000);
           } catch (InterruptedException ex) {
           }
           drawParalyzed = false;
         } else {
           drawParalyzed = true;
         }
       } else {
         // Waits a little on the enemy turn, this is just for testing and will be removed when AI
         // is written
         if (enemyMoveChosen) {
           Thread.sleep(1800);
           if (drawMoveApplication) {
             turn = 0;
             enemyMoveChosen = false;
             drawMoveApplication = false;
           } else {
             drawMoveApplication = true;
           }
         } else {
           if (enemy.getClass().equals(Creature.class)) {
             Creature creature = (Creature) enemy;
             int moveCount = creature.battleMoves.length;
             Random rand = new Random();
             double r = rand.nextDouble();
             int i = 1;
             while (r > (double) i / moveCount) {
               i++;
             }
             lastEnemyMove = MoveCache.getMove(creature.battleMoves[i - 1]);
             effectMessage = lastEnemyMove.applyEffect(creature, StartGameState.character);
             enemyMoveChosen = true;
           }
           Thread.sleep(1500);
         }
       }
     } catch (InterruptedException ex) {
     }
   } else if (turn == 2) {
     try {
       // Waits a little when the battle is won
       Thread.sleep(2000);
     } catch (InterruptedException ex) {
     }
     endEvent();
   } else if (turn == 3) {
     try {
       // Waits a little when the battle is lost
       Thread.sleep(2000);
     } catch (InterruptedException ex) {
     }
     endEvent();
   }
 }
예제 #25
0
  /**
   * isStackable.
   *
   * @param c a {@link forge.Card} object.
   * @return a boolean.
   */
  public static boolean isStackable(Card c) {

    /*String name = c.getName();
    if( name.equals("Swamp") || name.equals("Bog") ||
        name.equals("Forest") || name.equals("Grass") ||
        name.equals("Plains") || name.equals("White Sand") ||
        name.equals("Mountain") || name.equals("Rock") ||
        name.equals("Island") || name.equals("Underwater")) {
      return true;
    }
    */
    if (c.isLand()
        || (c.getName().startsWith("Mox") && !c.getName().equals("Mox Diamond"))
        || (c.isLand() && c.isEnchanted())
        || (c.isAura() && c.isEnchanting())
        || (c.isToken() && CardFactoryUtil.multipleControlled(c))
        || (c.isCreature() && (c.isEquipped() || c.isEnchanted()))
        || (c.isEquipment() && c.isEquipping())
        || (c.isEnchantment())
        || (c instanceof ManaPool && c.isSnow())) return true;

    return false;
  }
예제 #26
0
  /**
   * setupPlayZone.
   *
   * @param p a {@link arcane.ui.PlayArea} object.
   * @param c an array of {@link forge.Card} objects.
   */
  public static void setupPlayZone(PlayArea p, Card c[]) {
    List<Card> tmp, diff;
    tmp = new ArrayList<Card>();
    for (arcane.ui.CardPanel cpa : p.cardPanels) tmp.add(cpa.gameCard);
    diff = new ArrayList<Card>(tmp);
    diff.removeAll(Arrays.asList(c));
    if (diff.size() == p.cardPanels.size()) p.clear();
    else {
      for (Card card : diff) {
        p.removeCardPanel(p.getCardPanel(card.getUniqueNumber()));
      }
    }
    diff = new ArrayList<Card>(Arrays.asList(c));
    diff.removeAll(tmp);

    arcane.ui.CardPanel toPanel = null;
    for (Card card : diff) {
      toPanel = p.addCard(card);
      Animation.moveCard(toPanel);
    }

    for (Card card : c) {
      toPanel = p.getCardPanel(card.getUniqueNumber());
      if (card.isTapped()) {
        toPanel.tapped = true;
        toPanel.tappedAngle = arcane.ui.CardPanel.TAPPED_ANGLE;
      } else {
        toPanel.tapped = false;
        toPanel.tappedAngle = 0;
      }
      toPanel.attachedPanels.clear();
      if (card.isEnchanted()) {
        ArrayList<Card> enchants = card.getEnchantedBy();
        for (Card e : enchants) {
          arcane.ui.CardPanel cardE = p.getCardPanel(e.getUniqueNumber());
          if (cardE != null) toPanel.attachedPanels.add(cardE);
        }
      }

      if (card.isEquipped()) {
        ArrayList<Card> enchants = card.getEquippedBy();
        for (Card e : enchants) {
          arcane.ui.CardPanel cardE = p.getCardPanel(e.getUniqueNumber());
          if (cardE != null) toPanel.attachedPanels.add(cardE);
        }
      }

      if (card.isEnchanting()) {
        toPanel.attachedToPanel = p.getCardPanel(card.getEnchanting().get(0).getUniqueNumber());
      } else if (card.isEquipping()) {
        toPanel.attachedToPanel = p.getCardPanel(card.getEquipping().get(0).getUniqueNumber());
      } else toPanel.attachedToPanel = null;

      toPanel.setCard(toPanel.gameCard);
    }
    p.invalidate();
    p.repaint();
  }
예제 #27
0
  /** devSetupGameState. */
  public static void devSetupGameState() {
    String t_humanLife = "-1";
    String t_computerLife = "-1";
    String t_humanSetupCardsInPlay = "NONE";
    String t_computerSetupCardsInPlay = "NONE";
    String t_humanSetupCardsInHand = "NONE";
    String t_computerSetupCardsInHand = "NONE";
    String t_humanSetupGraveyard = "NONE";
    String t_computerSetupGraveyard = "NONE";
    String t_humanSetupLibrary = "NONE";
    String t_computerSetupLibrary = "NONE";
    String t_humanSetupExile = "NONE";
    String t_computerSetupExile = "NONE";
    String t_changePlayer = "NONE";
    String t_changePhase = "NONE";

    String wd = ".";
    JFileChooser fc = new JFileChooser(wd);
    int rc = fc.showDialog(null, "Select Game State File");
    if (rc != JFileChooser.APPROVE_OPTION) return;

    try {
      FileInputStream fstream = new FileInputStream(fc.getSelectedFile().getAbsolutePath());
      DataInputStream in = new DataInputStream(fstream);
      BufferedReader br = new BufferedReader(new InputStreamReader(in));

      String temp = "";

      while ((temp = br.readLine()) != null) {
        String[] temp_data = temp.split("=");

        if (temp_data.length < 2) continue;
        if (temp_data[0].toCharArray()[0] == '#') continue;

        String categoryName = temp_data[0];
        String categoryValue = temp_data[1];

        if (categoryName.toLowerCase().equals("humanlife")) t_humanLife = categoryValue;
        else if (categoryName.toLowerCase().equals("ailife")) t_computerLife = categoryValue;
        else if (categoryName.toLowerCase().equals("humancardsinplay"))
          t_humanSetupCardsInPlay = categoryValue;
        else if (categoryName.toLowerCase().equals("aicardsinplay"))
          t_computerSetupCardsInPlay = categoryValue;
        else if (categoryName.toLowerCase().equals("humancardsinhand"))
          t_humanSetupCardsInHand = categoryValue;
        else if (categoryName.toLowerCase().equals("aicardsinhand"))
          t_computerSetupCardsInHand = categoryValue;
        else if (categoryName.toLowerCase().equals("humancardsingraveyard"))
          t_humanSetupGraveyard = categoryValue;
        else if (categoryName.toLowerCase().equals("aicardsingraveyard"))
          t_computerSetupGraveyard = categoryValue;
        else if (categoryName.toLowerCase().equals("humancardsinlibrary"))
          t_humanSetupLibrary = categoryValue;
        else if (categoryName.toLowerCase().equals("aicardsinlibrary"))
          t_computerSetupLibrary = categoryValue;
        else if (categoryName.toLowerCase().equals("humancardsinexile"))
          t_humanSetupExile = categoryValue;
        else if (categoryName.toLowerCase().equals("aicardsinexile"))
          t_computerSetupExile = categoryValue;
        else if (categoryName.toLowerCase().equals("activeplayer")) t_changePlayer = categoryValue;
        else if (categoryName.toLowerCase().equals("activephase")) t_changePhase = categoryValue;
      }

      in.close();
    } catch (FileNotFoundException fnfe) {
      JOptionPane.showMessageDialog(
          null, "File not found: " + fc.getSelectedFile().getAbsolutePath());
    } catch (Exception e) {
      JOptionPane.showMessageDialog(null, "Error loading battle setup file!");
      return;
    }

    int setHumanLife = Integer.parseInt(t_humanLife);
    int setComputerLife = Integer.parseInt(t_computerLife);

    String humanSetupCardsInPlay[] = t_humanSetupCardsInPlay.split(";");
    String computerSetupCardsInPlay[] = t_computerSetupCardsInPlay.split(";");
    String humanSetupCardsInHand[] = t_humanSetupCardsInHand.split(";");
    String computerSetupCardsInHand[] = t_computerSetupCardsInHand.split(";");
    String humanSetupGraveyard[] = t_humanSetupGraveyard.split(";");
    String computerSetupGraveyard[] = t_computerSetupGraveyard.split(";");
    String humanSetupLibrary[] = t_humanSetupLibrary.split(";");
    String computerSetupLibrary[] = t_computerSetupLibrary.split(";");
    String humanSetupExile[] = t_humanSetupExile.split(";");
    String computerSetupExile[] = t_computerSetupExile.split(";");

    CardList humanDevSetup = new CardList();
    CardList computerDevSetup = new CardList();
    CardList humanDevHandSetup = new CardList();
    CardList computerDevHandSetup = new CardList();
    CardList humanDevGraveyardSetup = new CardList();
    CardList computerDevGraveyardSetup = new CardList();
    CardList humanDevLibrarySetup = new CardList();
    CardList computerDevLibrarySetup = new CardList();
    CardList humanDevExileSetup = new CardList();
    CardList computerDevExileSetup = new CardList();

    if (!t_changePlayer.trim().toLowerCase().equals("none")) {
      if (t_changePlayer.trim().toLowerCase().equals("human")) {
        AllZone.getPhase().setPlayerTurn(AllZone.getHumanPlayer());
      }
      if (t_changePlayer.trim().toLowerCase().equals("ai")) {
        AllZone.getPhase().setPlayerTurn(AllZone.getComputerPlayer());
      }
    }

    if (!t_changePhase.trim().toLowerCase().equals("none")) {
      AllZone.getPhase().setDevPhaseState(t_changePhase);
    }

    if (!t_humanSetupCardsInPlay.trim().toLowerCase().equals("none"))
      humanDevSetup = devProcessCardsForZone(humanSetupCardsInPlay, AllZone.getHumanPlayer());

    if (!t_humanSetupCardsInHand.trim().toLowerCase().equals("none"))
      humanDevHandSetup = devProcessCardsForZone(humanSetupCardsInHand, AllZone.getHumanPlayer());

    if (!t_computerSetupCardsInPlay.trim().toLowerCase().equals("none"))
      computerDevSetup =
          devProcessCardsForZone(computerSetupCardsInPlay, AllZone.getComputerPlayer());

    if (!t_computerSetupCardsInHand.trim().toLowerCase().equals("none"))
      computerDevHandSetup =
          devProcessCardsForZone(computerSetupCardsInHand, AllZone.getComputerPlayer());

    if (!t_computerSetupGraveyard.trim().toLowerCase().equals("none"))
      computerDevGraveyardSetup =
          devProcessCardsForZone(computerSetupGraveyard, AllZone.getComputerPlayer());

    if (!t_humanSetupGraveyard.trim().toLowerCase().equals("none"))
      humanDevGraveyardSetup =
          devProcessCardsForZone(humanSetupGraveyard, AllZone.getHumanPlayer());

    if (!t_humanSetupLibrary.trim().toLowerCase().equals("none"))
      humanDevLibrarySetup = devProcessCardsForZone(humanSetupLibrary, AllZone.getHumanPlayer());

    if (!t_computerSetupLibrary.trim().toLowerCase().equals("none"))
      computerDevLibrarySetup =
          devProcessCardsForZone(computerSetupLibrary, AllZone.getComputerPlayer());

    if (!t_humanSetupExile.trim().toLowerCase().equals("none"))
      humanDevExileSetup = devProcessCardsForZone(humanSetupExile, AllZone.getHumanPlayer());

    if (!t_computerSetupExile.trim().toLowerCase().equals("none"))
      computerDevExileSetup =
          devProcessCardsForZone(computerSetupExile, AllZone.getComputerPlayer());

    AllZone.getTriggerHandler().suppressMode("ChangesZone");

    for (Card c : humanDevSetup) {
      AllZone.getHumanHand().add(c);
      AllZone.getGameAction().moveToPlay(c);
      c.setSickness(false);
    }

    for (Card c : computerDevSetup) {
      AllZone.getComputerHand().add(c);
      AllZone.getGameAction().moveToPlay(c);
      c.setSickness(false);
    }

    if (computerDevGraveyardSetup.size() > 0)
      AllZone.getComputerGraveyard().setCards(computerDevGraveyardSetup.toArray());
    if (humanDevGraveyardSetup.size() > 0)
      AllZone.getHumanGraveyard().setCards(humanDevGraveyardSetup.toArray());

    if (computerDevHandSetup.size() > 0)
      AllZone.getComputerHand().setCards(computerDevHandSetup.toArray());
    if (humanDevHandSetup.size() > 0) AllZone.getHumanHand().setCards(humanDevHandSetup.toArray());

    if (humanDevLibrarySetup.size() > 0)
      AllZone.getHumanLibrary().setCards(humanDevLibrarySetup.toArray());
    if (computerDevLibrarySetup.size() > 0)
      AllZone.getComputerLibrary().setCards(computerDevLibrarySetup.toArray());

    if (humanDevExileSetup.size() > 0)
      AllZone.getHumanExile().setCards(humanDevExileSetup.toArray());
    if (computerDevExileSetup.size() > 0)
      AllZone.getComputerExile().setCards(computerDevExileSetup.toArray());

    AllZone.getTriggerHandler().clearSuppression("ChangesZone");

    if (setComputerLife > 0) AllZone.getComputerPlayer().setLife(setComputerLife, null);
    if (setHumanLife > 0) AllZone.getHumanPlayer().setLife(setHumanLife, null);

    AllZone.getGameAction().checkStateEffects();
    AllZone.getPhase().updateObservers();
    AllZone.getHumanExile().updateObservers();
    AllZone.getComputerExile().updateObservers();
    AllZone.getHumanHand().updateObservers();
    AllZone.getComputerHand().updateObservers();
    AllZone.getHumanGraveyard().updateObservers();
    AllZone.getComputerGraveyard().updateObservers();
    AllZone.getHumanBattlefield().updateObservers();
    AllZone.getComputerBattlefield().updateObservers();
    AllZone.getHumanLibrary().updateObservers();
    AllZone.getComputerLibrary().updateObservers();
  }
예제 #28
0
  /**
   * setupPanel.
   *
   * @param p a {@link javax.swing.JPanel} object.
   * @param list a {@link java.util.ArrayList} object.
   * @param stack a boolean.
   */
  private static void setupPanel(JPanel p, ArrayList<Card> list, boolean stack) {

    int maxY = 0;
    int maxX = 0;
    // remove all local enchantments

    Card c;
    /*
    for(int i = 0; i < list.size(); i++)
    {
      c = (Card)list.get(i);
      if(c.isLocalEnchantment())
        list.remove(i);
    }

    //add local enchantments to the permanents
    //put local enchantments "next to" the permanent they are enchanting
    //the inner for loop is backward so permanents with more than one local enchantments are in the right order
    Card ca[];
    for(int i = 0; i < list.size(); i++)
    {
      c = (Card)list.get(i);
      if(c.hasAttachedCards())
      {
        ca = c.getAttachedCards();
        for(int inner = ca.length - 1; 0 <= inner; inner--)
          list.add(i + 1, ca[inner]);
      }
    }
    */

    if (stack) {
      // add all Cards in list to the GUI, add arrows to Local Enchantments

      ArrayList<Card> manaPools = getManaPools(list);
      ArrayList<Card> enchantedLands = getEnchantedLands(list);
      ArrayList<Card> basicBlues = getBasics(list, Constant.Color.Blue);
      ArrayList<Card> basicReds = getBasics(list, Constant.Color.Red);
      ArrayList<Card> basicBlacks = getBasics(list, Constant.Color.Black);
      ArrayList<Card> basicGreens = getBasics(list, Constant.Color.Green);
      ArrayList<Card> basicWhites = getBasics(list, Constant.Color.White);
      ArrayList<Card> badlands = getNonBasicLand(list, "Badlands");
      ArrayList<Card> bayou = getNonBasicLand(list, "Bayou");
      ArrayList<Card> plateau = getNonBasicLand(list, "Plateau");
      ArrayList<Card> scrubland = getNonBasicLand(list, "Scrubland");
      ArrayList<Card> savannah = getNonBasicLand(list, "Savannah");
      ArrayList<Card> taiga = getNonBasicLand(list, "Taiga");
      ArrayList<Card> tropicalIsland = getNonBasicLand(list, "Tropical Island");
      ArrayList<Card> tundra = getNonBasicLand(list, "Tundra");
      ArrayList<Card> undergroundSea = getNonBasicLand(list, "Underground Sea");
      ArrayList<Card> volcanicIsland = getNonBasicLand(list, "Volcanic Island");

      ArrayList<Card> nonBasics = getNonBasics(list);

      ArrayList<Card> moxEmerald = getMoxen(list, "Mox Emerald");
      ArrayList<Card> moxJet = getMoxen(list, "Mox Jet");
      ArrayList<Card> moxPearl = getMoxen(list, "Mox Pearl");
      ArrayList<Card> moxRuby = getMoxen(list, "Mox Ruby");
      ArrayList<Card> moxSapphire = getMoxen(list, "Mox Sapphire");
      // ArrayList<Card> moxDiamond = getMoxen(list, "Mox Diamond");

      list = new ArrayList<Card>();
      list.addAll(manaPools);
      list.addAll(enchantedLands);
      list.addAll(basicBlues);
      list.addAll(basicReds);
      list.addAll(basicBlacks);
      list.addAll(basicGreens);
      list.addAll(basicWhites);
      list.addAll(badlands);
      list.addAll(bayou);
      list.addAll(plateau);
      list.addAll(scrubland);
      list.addAll(savannah);
      list.addAll(taiga);
      list.addAll(tropicalIsland);
      list.addAll(tundra);
      list.addAll(undergroundSea);
      list.addAll(volcanicIsland);

      list.addAll(nonBasics);

      list.addAll(moxEmerald);
      list.addAll(moxJet);
      list.addAll(moxPearl);
      list.addAll(moxRuby);
      list.addAll(moxSapphire);
      // list.addAll(moxDiamond);

      int atInStack = 0;

      int marginX = 5;
      int marginY = 5;

      int x = marginX;

      int cardOffset = Constant.Runtime.stackOffset[0];

      String color = "";
      ArrayList<JPanel> cards = new ArrayList<JPanel>();

      ArrayList<CardPanel> connectedCards = new ArrayList<CardPanel>();

      boolean nextEnchanted = false;
      Card prevCard = null;
      int nextXIfNotStacked = 0;
      for (int i = 0; i < list.size(); i++) {
        JPanel addPanel;
        c = list.get(i);

        addPanel = new CardPanel(c);

        boolean startANewStack = false;

        if (!isStackable(c)) {
          startANewStack = true;
        } else {
          String newColor = c.getName(); // CardUtil.getColor(c);

          if (!newColor.equals(color)) {
            startANewStack = true;
            color = newColor;
          }
        }

        if (i == 0) {
          startANewStack = false;
        }

        if (!startANewStack && atInStack == Constant.Runtime.stackSize[0]) {
          startANewStack = true;
        }

        if (c.isAura() && c.isEnchanting() && !nextEnchanted) startANewStack = false;
        else if (c.isAura() && c.isEnchanting()) {
          startANewStack = true;
          nextEnchanted = false;
        }

        if (c.isLand() && c.isEnchanted()) {
          startANewStack = false;
          nextEnchanted = true;
        }

        // very hacky, but this is to ensure enchantment stacking occurs correctly when a land is
        // enchanted, and there are more lands of that same name

        else if ((prevCard != null
            && c.isLand()
            && prevCard.isLand()
            && prevCard.isEnchanted()
            && prevCard.getName().equals(c.getName()))) startANewStack = true;
        else if (prevCard != null
            && c.isLand()
            && prevCard.isLand()
            && !prevCard.getName().equals(c.getName())) startANewStack = true;

        /*
        if (c.getName().equals("Squirrel Nest")) {
            startANewStack = true;
            System.out.println("startANewStack: " + startANewStack);
        }
        */
        if (c.isAura() && c.isEnchanting() && prevCard != null && prevCard instanceof ManaPool)
          startANewStack = true;
        if (c instanceof ManaPool && prevCard instanceof ManaPool && prevCard.isSnow())
          startANewStack = false;

        if (startANewStack) {
          setupConnectedCards(connectedCards);
          connectedCards.clear();

          // Fixed distance if last was a stack, looks a bit nicer
          if (atInStack > 1) {
            x +=
                Math.max(addPanel.getPreferredSize().width, addPanel.getPreferredSize().height)
                    + marginX;
          } else {
            x = nextXIfNotStacked;
          }

          atInStack = 0;
        } else {
          if (i != 0) {
            x += cardOffset;
          }
        }

        nextXIfNotStacked = x + marginX + addPanel.getPreferredSize().width;

        int xLoc = x;

        int yLoc = marginY;
        yLoc += atInStack * cardOffset;

        addPanel.setLocation(new Point(xLoc, yLoc));
        addPanel.setSize(addPanel.getPreferredSize());

        cards.add(addPanel);

        connectedCards.add((CardPanel) addPanel);

        atInStack++;
        prevCard = c;
      }

      setupConnectedCards(connectedCards);
      connectedCards.clear();

      for (int i = cards.size() - 1; i >= 0; i--) {
        JPanel card = cards.get(i);
        // maxX = Math.max(maxX, card.getLocation().x + card.getSize().width + marginX);
        maxY = Math.max(maxY, card.getLocation().y + card.getSize().height + marginY);
        p.add(card);
      }

      maxX = nextXIfNotStacked;

      // System.out.println("x:" + maxX + ", y:" + maxY);
      if (maxX > 0 && maxY > 0) { // p.getSize().width || maxY > p.getSize().height) {
        //        p.setSize(new Dimension(maxX, maxY));
        p.setPreferredSize(new Dimension(maxX, maxY));
      }

    } else {
      // add all Cards in list to the GUI, add arrows to Local Enchantments
      JPanel addPanel;
      for (int i = 0; i < list.size(); i++) {
        c = list.get(i);
        /*if(c.isLocalEnchantment())
          addPanel = getCardPanel(c, "<< " +c.getName());
        else
          addPanel = getCardPanel(c);
          */
        addPanel = new CardPanel(c);

        p.add(addPanel);
      }
    }
  } // setupPanel()
예제 #29
0
  /**
   * setupNoLandPermPanel.
   *
   * @param p a {@link javax.swing.JPanel} object.
   * @param list a {@link java.util.ArrayList} object.
   * @param stack a boolean.
   */
  private static void setupNoLandPermPanel(JPanel p, ArrayList<Card> list, boolean stack) {

    int maxY = 0;
    int maxX = 0;

    Card c;

    if (stack) {
      // add all Cards in list to the GUI, add arrows to Local Enchantments

      ArrayList<Card> planeswalkers = getPlaneswalkers(list);
      ArrayList<Card> equippedEnchantedCreatures =
          getEquippedEnchantedCreatures(
              list); // this will also fetch the equipment and/or enchantment
      ArrayList<Card> nonTokenCreatures = getNonTokenCreatures(list);
      ArrayList<Card> tokenCreatures = getTokenCreatures(list);

      // sort tokenCreatures by name (TODO: fix the warning message somehow)
      Collections.sort(
          tokenCreatures,
          new Comparator<Card>() {
            public int compare(Card c1, Card c2) {
              return c1.getName().compareTo(c2.getName());
            }
          });

      ArrayList<Card> artifacts = getNonCreatureArtifacts(list);
      ArrayList<Card> enchantments = getGlobalEnchantments(list);
      // ArrayList<Card> nonBasics = getNonBasics(list);

      list = new ArrayList<Card>();
      list.addAll(planeswalkers);
      list.addAll(equippedEnchantedCreatures);
      list.addAll(nonTokenCreatures);
      list.addAll(tokenCreatures);
      list.addAll(artifacts);
      list.addAll(enchantments);

      int atInStack = 0;

      int marginX = 5;
      int marginY = 5;

      int x = marginX;

      int cardOffset = Constant.Runtime.stackOffset[0];

      String color = "";
      ArrayList<JPanel> cards = new ArrayList<JPanel>();

      ArrayList<CardPanel> connectedCards = new ArrayList<CardPanel>();

      boolean nextEquippedEnchanted = false;
      int nextXIfNotStacked = 0;
      Card prevCard = null;
      for (int i = 0; i < list.size(); i++) {
        JPanel addPanel;
        c = list.get(i);
        addPanel = new CardPanel(c);

        boolean startANewStack = false;

        if (!isStackable(c)) {
          startANewStack = true;
        } else {
          String newColor = c.getName(); // CardUtil.getColor(c);

          if (!newColor.equals(color)) {
            startANewStack = true;
            color = newColor;
          }
        }

        if (i == 0) {
          startANewStack = false;
        }

        if (!startANewStack && atInStack == Constant.Runtime.stackSize[0]) {
          startANewStack = true;
        }

        if ((c.isEquipment() || c.isAura())
            && (c.isEquipping() || c.isEnchanting())
            && !nextEquippedEnchanted) startANewStack = false;
        else if ((c.isEquipment() || c.isAura()) && (c.isEquipping() || c.isEnchanting())) {
          startANewStack = true;
          nextEquippedEnchanted = false;
        }

        if (c.isCreature() && (c.isEquipped() || c.isEnchanted())) {
          startANewStack = false;
          nextEquippedEnchanted = true;
        }
        // very hacky, but this is to ensure equipment stacking occurs correctly when a token is
        // equipped/enchanted, and there are more tokens of that same name
        else if ((prevCard != null
            && c.isCreature()
            && prevCard.isCreature()
            && (prevCard.isEquipped() || prevCard.isEnchanted())
            && prevCard.getName().equals(c.getName()))) startANewStack = true;
        else if (prevCard != null
            && c.isCreature()
            && prevCard.isCreature()
            && !prevCard.getName().equals(c.getName())) startANewStack = true;

        if (((c.isAura() && c.isEnchanting()) || (c.isEquipment() && c.isEquipping()))
            && prevCard != null
            && prevCard.isPlaneswalker()) startANewStack = true;

        if (startANewStack) {
          setupConnectedCards(connectedCards);
          connectedCards.clear();

          // Fixed distance if last was a stack, looks a bit nicer
          if (atInStack > 1) {
            x +=
                Math.max(addPanel.getPreferredSize().width, addPanel.getPreferredSize().height)
                    + marginX;
          } else {
            x = nextXIfNotStacked;
          }

          atInStack = 0;
        } else {
          if (i != 0) {
            x += cardOffset;
          }
        }

        nextXIfNotStacked = x + marginX + addPanel.getPreferredSize().width;

        int xLoc = x;

        int yLoc = marginY;
        yLoc += atInStack * cardOffset;

        addPanel.setLocation(new Point(xLoc, yLoc));
        addPanel.setSize(addPanel.getPreferredSize());

        cards.add(addPanel);

        connectedCards.add((CardPanel) addPanel);

        atInStack++;
        prevCard = c;
      }

      setupConnectedCards(connectedCards);
      connectedCards.clear();

      for (int i = cards.size() - 1; i >= 0; i--) {
        JPanel card = cards.get(i);
        // maxX = Math.max(maxX, card.getLocation().x + card.getSize().width + marginX);
        maxY = Math.max(maxY, card.getLocation().y + card.getSize().height + marginY);
        p.add(card);
      }

      maxX = nextXIfNotStacked;

      if (maxX > 0 && maxY > 0) { // p.getSize().width || maxY > p.getSize().height) {
        p.setPreferredSize(new Dimension(maxX, maxY));
      }

    } else {
      JPanel addPanel;
      for (int i = 0; i < list.size(); i++) {
        c = list.get(i);
        addPanel = new CardPanel(c);

        p.add(addPanel);
      }
    }
  } // setupPanel()