Want more features on Pastebin? Sign Up, it's FREE!
Guest

Untitled

By: a guest on Feb 26th, 2012  |  syntax: Java  |  size: 18.85 KB  |  views: 21  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1.  
  2. import java.awt.Color;
  3. import java.awt.event.ActionEvent;
  4. import java.awt.event.ActionListener;
  5. import java.io.*;
  6. import java.util.Random;
  7. import java.util.StringTokenizer;
  8. import java.lang.String;
  9. import javax.swing.JButton;
  10. import javax.swing.JFrame;
  11. import javax.swing.JLabel;
  12. import javax.swing.JOptionPane;
  13. import javax.swing.JPanel;
  14.  
  15. public class Skill {
  16.  
  17.     String type;
  18.     String name;
  19.     String desc;
  20.     int cool;
  21.     int targets;
  22.  
  23.     public Skill(int typeNo) {
  24.         // TODO Auto-generated constructor stub
  25.  
  26.         Random rand;
  27.         int n = 0;
  28.         switch (typeNo) {
  29.             case 0:
  30.                 /*
  31.                  * GLOBAL
  32.                  */
  33.                 rand = new Random();
  34.                 n = rand.nextInt(10);
  35.                 this.setSkill(this.getSkill(n, "skills_global.txt"));
  36.                 break;
  37.             case 1:
  38.                 /*
  39.                  * DAMAGE
  40.                  */
  41.                 rand = new Random();
  42.                 n = rand.nextInt(5);
  43.                 this.setSkill(this.getSkill(n, "skills_damage.txt"));
  44.                 break;
  45.             case 2:
  46.                 /*
  47.                  * POSITION
  48.                  */
  49.                 rand = new Random();
  50.                 n = rand.nextInt(6);
  51.                 this.setSkill(this.getSkill(n, "skills_position.txt"));
  52.                 break;
  53.             case 3:
  54.                 /*
  55.                  * PASSIVE
  56.                  */
  57.                 rand = new Random();
  58.                 n = rand.nextInt(5);
  59.                 this.setSkill(this.getSkill(n, "skills_passive.txt"));
  60.                 break;
  61.         }
  62.  
  63.     }
  64.  
  65.     public String getSkill(int n, String filename) {
  66.  
  67.         String str = "";
  68.         try {
  69.  
  70.             FileInputStream fs = new FileInputStream(filename);
  71.             DataInputStream in = new DataInputStream(fs);
  72.             BufferedReader br = new BufferedReader(new InputStreamReader(in));
  73.             for (int i = 1; i < n; i++) {
  74.                 br.readLine();
  75.             }
  76.             str += br.readLine();
  77.  
  78.         } catch (Exception e) {
  79.             // TODO Auto-generated catch block
  80.             e.printStackTrace();
  81.         }
  82.  
  83.         return str;
  84.     }
  85.  
  86.     public void setSkill(String str) {
  87.         StringTokenizer token = new StringTokenizer(str, ";");
  88.         this.type = token.nextToken();
  89.         this.name = token.nextToken().substring(1);
  90.         this.desc = token.nextToken().substring(1);
  91.         this.cool = Integer.parseInt(token.nextToken().substring(1));
  92.         this.targets = Integer.parseInt(token.nextToken().substring(1));
  93.        
  94.         /*
  95.          * Cooldown -1 For skill Copy = use once 0 For passive skills = use
  96.          * always >0 For other skills
  97.          */
  98.     }
  99.  
  100.     public void setCooldown(Sheep s, int cd) {
  101.         // s.cd = cd;
  102.     }
  103.  
  104.     public void effect(Sheep me, Sheep[] targets, int allActions, Board board) {
  105.         int r;
  106.         int t;
  107.         int cnt;
  108.         int cntr;
  109.         /*
  110.         Sheep targets[] = new Sheep[3];
  111.         targets[0] = targets[0];
  112.         targets[1] = s1;
  113.         targets[2] = s2;
  114.         */
  115.         // Check for extra action to modify;
  116.        
  117.         System.out.println("Effect ng skill");
  118.        
  119.         switch (name) {
  120.             case "Decreased Cost":
  121.                 // oks na. nakaintegrate na sa pagbabawas.
  122.                 break;
  123.             case "Sure Shot":
  124.                 // if current tile chance > 0, set chance to 90
  125.                 // Could be removed. integrated already in fire();
  126.                 if (me.getLocation().getProperty() == 5) // Set the chance tiles!!!
  127.                 {
  128.                     me.chance = 90;
  129.                 }
  130.                 break;
  131.             case "Immolate":
  132.                
  133.                 // UHHHHH
  134.                
  135.                 // get current tile and damage any sheep in the surrounding area
  136.                 for (cnt = 0; cnt < 3; cnt++) {
  137.                     if (me.r < 6 || me.r > 10) {
  138.                         if (targets[cnt].r == (me.r + 1)
  139.                                 && targets[cnt].t == Math.ceil(me.t / 2)) {
  140.                             targets[cnt].damage(1);
  141.                         } else if (targets[cnt].r == me.r
  142.                                 && Math.abs(targets[cnt].t - me.t) == 1) {
  143.                             targets[cnt].damage(1);
  144.                         } else if (targets[cnt].r == (me.r - 1)
  145.                                 && me.t == (int) Math.ceil(targets[cnt].t / 2)) {
  146.                             targets[cnt].damage(1);
  147.                         }
  148.                     } else {
  149.                         if (me.r == (targets[cnt].r + 1)
  150.                                 && targets[cnt].t == Math.ceil(me.t / 2)) {
  151.                             targets[cnt].damage(1);
  152.                         } else if (targets[cnt].r == me.r
  153.                                 && Math.abs(targets[cnt].t - me.t) == 1) {
  154.                             targets[cnt].damage(1);
  155.                         } else if (me.r == (targets[cnt].r - 1)
  156.                                 && me.t == (int) Math.ceil(targets[cnt].t / 2)) {
  157.                             targets[cnt].damage(1);
  158.                         }
  159.                     }
  160.                 }
  161.                 break;
  162.             case "Diagonal Move":
  163.                 // ???
  164.                 String horizontal;
  165.                 String vertical;
  166.                 do {
  167.                     horizontal = JOptionPane.showInputDialog("Left / Right?");
  168.                 } while (!horizontal.toLowerCase().equals("left")
  169.                         && !horizontal.toLowerCase().equals("right"));
  170.                 me.mover(horizontal);
  171.                 do {
  172.                     vertical = JOptionPane.showInputDialog("Forward / Backward?");
  173.                 } while (!horizontal.toLowerCase().equals("forward")
  174.                         && !horizontal.toLowerCase().equals("backward"));
  175.                 me.mover(vertical);
  176.                 me.move(null, 0);
  177.                 break;
  178.             case "Extra Action":
  179.                 // implemented sa ibang class
  180.                 // activate register[4]
  181.                 break;
  182.             case "Tree Cut":
  183.                 // set a tree tile to normal, or damage a sheep
  184.                 TreeSkill(board,targets); // OK NA. set or damage! check! :)
  185.                 break;
  186.             case "Gravity Sphere":
  187.                 // move a sheep with damage (10)
  188.                 // ???????
  189.                 // 1 TARGET ONLY
  190.                 targets[0].damage(10);
  191.                 String d = "";
  192.                 do {
  193.                     d = JOptionPane.showInputDialog("Left / Right?");
  194.                 } while (!d.toLowerCase().equals("left")
  195.                         && !d.toLowerCase().equals("right"));
  196.                 targets[0].move(d, 1);
  197.                
  198.                 break;
  199.             case "Volcano":
  200.                
  201.                 // ???????????????
  202.                
  203.                 // set tiles around the sheep to volcano and damage others
  204.                 // errorchecking here - add.
  205.                 for (cnt = 0; cnt < 3; cnt++) {
  206.                     if (me.r < 6 || me.r > 10) {
  207.                         board.b[me.r + 1].row[(int) Math.ceil(me.r / 2.0)].setProperty(7);
  208.                         board.b[me.r].row[me.t - 1].setProperty(7);
  209.                         board.b[me.r].row[me.t + 1].setProperty(7);
  210.                         board.b[me.r - 1].row[2 * me.r].setProperty(7);
  211.                         board.b[me.r - 1].row[(2 * me.r) - 1].setProperty(7);
  212.                     } else {
  213.                         board.b[me.r - 1].row[(int) Math.ceil(me.r / 2.0)].setProperty(7);
  214.                         board.b[me.r].row[me.t - 1].setProperty(7);
  215.                         board.b[me.r].row[me.t + 1].setProperty(7);
  216.                         board.b[me.r + 1].row[2 * me.r].setProperty(7);
  217.                         board.b[me.r + 1].row[(2 * me.r) - 1].setProperty(7);
  218.                     }
  219.                 }
  220.                 break;
  221.             case "Mana Flare":
  222.                 // ALL OTHER PLAYERS = 3
  223.                 // if other sheep useSkill(), damage them, divide damage equally
  224.                 for (cntr = 0; cntr < 3; cntr++) {
  225.                     for (cnt = 0; cnt < allActions; cnt++) {
  226.                         if (targets[cntr].actions[cnt] == 9) {
  227.                             targets[cntr].damage(1);
  228.                         }
  229.                     }
  230.                 }
  231.                
  232.                 JOptionPane.showMessageDialog(null, "MANA FLAAAAAARE!");
  233.                
  234.                 break;
  235.             case "Mana Burn":
  236.                 // 1 TARGET ONLY
  237.                 targets[0].lastmp = targets[0].mp;
  238.                 targets[0].mp -= 40;
  239.                 break;
  240.             case "Silence":
  241.                 // 1 TARGET ONLY
  242.                 // cannot change an opponents next action; with chances
  243.                 break;
  244.             case "Freeze":
  245.                 // set other actions to null
  246.                 // EDIT: NG LAHAT NG PLAYERS = 4 (including me sa targets)
  247.                 for (cntr = 0; cntr < 4; cntr++) {
  248.                     for (cnt = 0; cnt < allActions; cnt++) {
  249.                         targets[cntr].lastactions[cnt] = targets[cntr].actions[cnt];
  250.                         targets[cntr].actions[cnt] = 10;
  251.                     }
  252.                 }
  253.                 break;
  254.             case "Minimize":
  255.                 // LAHAT NG PLAYERS = 4 (including me sa targets)
  256.                 // set move actions to move 1, skill to null
  257.                 for (cnt = 0; cnt < 4; cnt++) {
  258.                     for (cntr = 0; cntr < allActions; cntr++) {
  259.                         targets[cnt].lastactions[cntr] = targets[cnt].actions[cntr];
  260.                         targets[cnt].lastmp = targets[cnt].mp;
  261.                         switch (targets[cnt].actions[cntr]) {
  262.                             case 5:
  263.                                 targets[cnt].actions[cntr] = 1;
  264.                                 targets[cnt].mp -= 20;
  265.                                 break;
  266.                             case 6:
  267.                                 targets[cnt].actions[cntr] = 2;
  268.                                 targets[cnt].mp -= 20;
  269.                                 break;
  270.                             case 7:
  271.                                 targets[cnt].actions[cntr] = 3;
  272.                                 targets[cnt].mp -= 20;
  273.                                 break;
  274.                             case 8:
  275.                                 targets[cnt].actions[cntr] = 4;
  276.                                 targets[cnt].mp -= 20;
  277.                                 break;
  278.                             case 9:
  279.                                 targets[cnt].actions[cntr] = 10;
  280.                                 targets[cnt].mp -= 40;
  281.                                 break;
  282.                         }
  283.                     }
  284.                 }
  285.                
  286.                 JOptionPane.showMessageDialog(null, "MINIMIZE!!!");
  287.                
  288.                 break;
  289.             case "Sleep":
  290.                 // LAHAT NG PLAYERS = 4 (including me sa targets)
  291.                 for(cnt = 0; cnt < 4; cnt++)
  292.                     targets[cnt].sleep = true;
  293.                
  294.                 JOptionPane.showMessageDialog(null, "Matulog kayo. zzzzzzzz");
  295.                
  296.                 break;
  297.             case "Exchange":
  298.                 // 1 PLAYER ONLY
  299.                 me.lastskill = me.skill;
  300.                 targets[0].lastskill = targets[0].skill;
  301.                 me.skill = targets[0].skill;
  302.                 targets[0].skill.setSkill("Global Spells; Exchange; Exchange this skill for an opponent's skill; 1");
  303.                 break;
  304.             case "Copy":
  305.                 // 1 PLAYER ONLY
  306.                 me.lastskill = me.skill;
  307.                 me.skill = targets[0].skill;
  308.                 break;
  309.             case "Negate":
  310.                 // reverse skill effect on the user
  311.                 break;
  312.             case "Undo":
  313.                 // LAHAT NG PLAYERS = 4 (including me)
  314.                 for (cnt = 0; cnt < 4; cnt++) {
  315.                     if (targets[cnt].lastmp == 500
  316.                             && targets[cnt].lasthp == 500
  317.                             && targets[cnt].lastr == 500
  318.                             && targets[cnt].lastt == 500) {
  319.                         JOptionPane.showMessageDialog(null,
  320.                                 "Nothing to undo. This is the first turn.",
  321.                                 "Undo.", JOptionPane.ERROR_MESSAGE);
  322.                         break;
  323.                     }
  324.                     targets[cnt].mp = targets[cnt].lastmp;
  325.                     targets[cnt].hp = targets[cnt].lasthp;
  326.                     targets[cnt].r = targets[cnt].lastr;
  327.                     targets[cnt].t = targets[cnt].lastt;
  328.                     for (cntr = 0; cntr < allActions; cntr++) {
  329.                         targets[cnt].actions[cntr] = targets[cnt].lastactions[cntr];
  330.                     }
  331.  
  332.                     targets[cnt].move(null, 0);
  333.                    
  334.                     JOptionPane.showMessageDialog(null, "Undo~");
  335.                    
  336.                 }
  337.                 // reverse all actions
  338.                 break;
  339.             case "Mirror":
  340.                 // reflect damage
  341.                 break;
  342.             case "Switch":
  343.                 // 1 TARGET ONLY
  344.                 // switch actions with an opponent
  345.                 int reg;
  346.                 do {
  347.                     reg = Integer.parseInt(JOptionPane.showInputDialog("Which register do you want to switch?"));
  348.                 } while (reg > 3 || reg < 1);
  349.                 me.lastactions[reg] = me.actions[reg];
  350.                 targets[0].lastactions[reg] = targets[0].actions[reg];
  351.                 int temp;
  352.                 temp = targets[0].actions[reg];
  353.                 targets[0].actions[reg] = me.actions[reg];
  354.                 me.actions[reg] = temp;
  355.                 break;
  356.             case "Plant Tree":
  357.                 // 1 TARGET ONLY (TILE OR SHEEP)
  358.                 // turn a tile into a tree
  359.                 do {
  360.                     r = Integer.parseInt(JOptionPane.showInputDialog("Plant Trees: Row number?"));
  361.                 } while (r < 1 || r > 16);
  362.                 do {
  363.                     t = Integer.parseInt(JOptionPane.showInputDialog("Plant Trees: Tile Number?"));
  364.                 } while (t < 1 || t >= board.b[r].size);
  365.                 board.b[r].row[t].setProperty(6);
  366.                 break;
  367.             case "Set Trap":
  368.                 // TILE TARGET
  369.                 // turn a tile into a trap
  370.                 do {
  371.                     r = Integer.parseInt(JOptionPane.showInputDialog("Set Trap: Row number?"));
  372.                 } while (r < 1 || r > 16);
  373.                 do {
  374.                     t = Integer.parseInt(JOptionPane.showInputDialog("Set Trap: Tile Number?"));
  375.                 } while (t < 1 || t >= board.b[r].size);
  376.                 board.b[r].row[t].setProperty(9);
  377.                 break;
  378.             case "Blink":
  379.                 // move 2 squares
  380.                 // Manhattan distance
  381.                 me.lastr = me.r;
  382.                 me.lastt = me.t;
  383.                 board.b[me.r].row[me.t].leave();
  384.                 do {
  385.                     r = Integer.parseInt(JOptionPane.showInputDialog("Blink! : Row number?"));
  386.                     t = Integer.parseInt(JOptionPane.showInputDialog("Blink! : Tile number?"));
  387.                     if (!board.b[r].row[t].occupy()) {
  388.                         JOptionPane.showMessageDialog(null, "Occupied!",
  389.                                 "Error in Blink.", JOptionPane.ERROR_MESSAGE);
  390.                     }
  391.                 } while (((Math.abs(me.r - r) + Math.abs(me.t - t)) > 2)
  392.                         && !board.b[r].row[t].occupy());
  393.                 me.move(null, 0);
  394.                 break;
  395.             case "Magic Tunnel":
  396.                 // 1 TARGET ONLY
  397.                 // move a sheep behind you
  398.                 targets[0].teleport(me.r);
  399.                 break;
  400.             case "Swap":
  401.                 // 1 TARGET ONLY
  402.                 me.lastr = me.r;
  403.                 me.lastt = me.t;
  404.                 targets[0].lastr = targets[0].r;
  405.                 targets[0].lastt = targets[0].t;
  406.                 r = me.r;
  407.                 me.r = targets[0].r;
  408.                 targets[0].r = r;
  409.                 t = me.t;
  410.                 me.t = targets[0].t;
  411.                 targets[0].t = t;
  412.                 me.move(null, 0);
  413.                 targets[0].move(null, 0);
  414.                 break;
  415.             case "Return to Start":
  416.                 // 1 TARGET ONLY
  417.                 targets[0].lastr = targets[0].chance;
  418.                 targets[0].lastt = targets[0].t;
  419.                 targets[0].r = 0;
  420.                 targets[0].t = 4;
  421.                 targets[0].move(null, 0);
  422.                 break;
  423.         }
  424.     }
  425.  
  426.     public JPanel TreeSkill(final Board board, final Sheep[] targets) {
  427.  
  428.         JPanel panel = new JPanel();
  429.         JLabel treeCutSkillLabel = new JLabel();
  430.         JButton clearTreeButton = new JButton();
  431.         JButton damageOpponentButton = new JButton();
  432.         panel.setBackground(new Color(204, 255, 204));
  433.         panel.setBounds(0, 0, 285, 150);
  434.         panel.setLayout(null);
  435.         panel.add(treeCutSkillLabel);
  436.         treeCutSkillLabel.setText("Tree Cut Skill");
  437.         treeCutSkillLabel.setBounds(100, 15, 85, 30);
  438.         panel.add(clearTreeButton);
  439.         clearTreeButton.setForeground(new Color(255, 255, 153));
  440.         clearTreeButton.setBackground(new Color(204, 102, 51));
  441.         clearTreeButton.setText("Clear Tree");
  442.         clearTreeButton.setBounds(10, 59, 106, 61);
  443.         panel.add(damageOpponentButton);
  444.         damageOpponentButton.setForeground(new Color(255, 255, 153));
  445.         damageOpponentButton.setBackground(new Color(204, 102, 51));
  446.         damageOpponentButton.setText("Damage");
  447.         damageOpponentButton.setBounds(155, 55, 119, 61);
  448.  
  449.         clearTreeButton.addActionListener(new ActionListener() {
  450.  
  451.             public void actionPerformed(ActionEvent e) {
  452.                 int rownum = Integer.parseInt(JOptionPane.showInputDialog("Row number?"));
  453.                 int tilenum = Integer.parseInt(JOptionPane.showInputDialog("Tile Number?"));
  454.                 board.b[rownum].row[tilenum].setProperty(0);
  455.             }
  456.         });
  457.        
  458.         damageOpponentButton.addActionListener(new ActionListener() {
  459.  
  460.             public void actionPerformed(ActionEvent e) {
  461.                 int cnt;
  462.                 String whoToDamage = JOptionPane.showInputDialog("Who do you want to damage? :>");
  463.                 for(cnt = 0; cnt < 4; cnt++) {
  464.                     if(targets[cnt].sheepName.toLowerCase().equals(whoToDamage.toLowerCase())) {
  465.                         targets[cnt].damage(1);
  466.                     }
  467.                 }
  468.                
  469.             }
  470.         });
  471.  
  472.         return panel;
  473.     }
  474. }
clone this paste RAW Paste Data