黑马程序员技术交流社区

标题: java完整2D游戏连载--part2 (单位基本类) [打印本页]

作者: 2666fff    时间: 2015-5-7 23:21
标题: java完整2D游戏连载--part2 (单位基本类)
接第一篇 java完整2D游戏连载--part1(所有代码均为自主完成)
http://bbs.itheima.com/thread-194611-1-1.html
Unit.java(单位基本类,包括怪物 人物 NPC)
  1. package project2;
  2. /*
  3. * Ab class for all units
  4. * author: weiqian wang<wangw>
  5. * */

  6. import java.util.EnumMap;

  7. import org.newdawn.slick.Color;
  8. import org.newdawn.slick.Graphics;
  9. import org.newdawn.slick.Image;






  10. public abstract class Unit implements GameObject {
  11.         /** The item's position in the world */
  12.         protected double x, y;
  13.         /** The unit's name */
  14.         protected String name;

  15.         // Unit STATS
  16.         /** 100% of the unit's health */
  17.         protected double maxHealth = 100;
  18.         /** The unit's current health */
  19.         protected double health = maxHealth;
  20.         /** The unit's strength, determines damage */
  21.         protected double strength;
  22.         /** The minimum time between attacks (ms) */
  23.         protected int cooldown;
  24.         /** The time until the next attack can be made (ms) */
  25.         protected int cooldownTimer = 0;
  26.         /** The minimum time between attacks (ms) */
  27.         protected int icooldown = 600;

  28.         /** The unit's movement speed */
  29.         protected double SPEED = 0.25;
  30.         /** The range in which the unit can attack enemies */
  31.         protected int attackRange = 50;
  32.         // RENDERING
  33.         /** The Image object representing the object in the world */
  34.         protected Image avatar = null;
  35.         /** The physical width of the avatar (trimmed avatar width) */
  36.         protected int physWidth;
  37.         /** The physical height of the avatar (trimmed avatar height) */
  38.         protected int physHeight;

  39.         /** The width of the floating health bar */
  40.         protected float healthBarWidth;
  41.         /** The height of the floating health bar */
  42.         protected final float healthBarHeight = 16;

  43.         /** Whether to flip the image or not. */
  44.         private boolean face_left = false;

  45.         /** Mapping of types of bonuses to the unit's current value for that bonus */
  46.         protected EnumMap<Bonus.Type, Double> bonuses;
  47.        
  48.         // ITEMS
  49.         /** The inventory held by the unit */
  50.         protected Inventory inventory = new Inventory();
  51.        
  52.     private double dirx;
  53.     private double diry;

  54.     /** Move the player in a given direction.
  55.      * Prevents the player from moving outside the map space, and also updates
  56.      * the direction the player is facing.
  57.      * @param world The world the player is on (to check blocking).
  58.      * @param dir_x The player's movement in the x axis (-1, 0 or 1).
  59.      * @param dir_y The player's movement in the y axis (-1, 0 or 1).
  60.      * @param delta Time passed since last frame (milliseconds).
  61.      */
  62.         public Unit(){
  63.             // Initilialise the bonuses
  64.                 this.bonuses = new EnumMap<Bonus.Type, Double>(Bonus.Type.class);
  65.                 for (Bonus.Type type : Bonus.Type.values())
  66.                 {
  67.                         this.bonuses.put(type, 0.0);
  68.                 }
  69.         }
  70.     public void move(World world, double newX, double newY, double delta)
  71.     {
  72.                 // Check for collisions only if clipping is on
  73.                 //if (!noclip)
  74.                 {
  75.                         // Move the unit only if the new tile is unblocked
  76.                         if (!world.terrainBlocks(newX, this.y)
  77.                                         && !world.isUnitBlocked(this, newX, this.y))
  78.                         {
  79.                                
  80.                                 // Check if the player has changed direction
  81.                                 double dirX = (newX - this.getX());
  82.                                 dirx = dirX;
  83.                                 diry = (newY - this.getY());
  84.                                 // If last move was to the left and now moving right
  85.                                 if (face_left && dirX > 0)
  86.                                 {
  87.                                         face_left = false;
  88.                                         // Set the avatar back to unflipped
  89.                                         this.avatar = (this.getAvatar().getFlippedCopy(true, false));
  90.                                 }
  91.                                 // If last move was to the right and now moving left
  92.                                 else if (!face_left && dirX < 0)
  93.                                 {
  94.                                         face_left = true;
  95.                                         // Set the avatar back to unflipped
  96.                                         this.avatar = (this.getAvatar().getFlippedCopy(true, false));
  97.                                 }

  98.                                 // Update position
  99.                                 this.x = newX;
  100.                         }

  101.                         if (!world.terrainBlocks(this.x, newY)
  102.                                         && !world.isUnitBlocked(this, this.x, newY))
  103.                         {
  104.                                 // Update position
  105.                                 this.y = newY;
  106.                         }
  107.                 }
  108.     }

  109.         /**
  110.          * @return the avatar
  111.          */
  112.         public Image getAvatar() {
  113.                 return avatar;
  114.         }

  115.         /**
  116.          * Render the unit in the game world, reflecting his new state.
  117.          *
  118.          * @param g
  119.          *            The Slick graphics object, used for drawing.
  120.          */
  121.         // @Override
  122.         public void render(Graphics g) {
  123.                 // Draw the player at his real world co-ordinates (translated graphics)
  124.                 if (face_left) {
  125.                         this.getAvatar().draw(
  126.                                         (float) (getX() - this.getAvatar().getWidth() / 2),
  127.                                         (float) (getY() - this.getAvatar().getHeight() / 2));
  128.                 } else {
  129.                         this.getAvatar().draw(
  130.                                         (float) getX() - this.getAvatar().getWidth() / 2,
  131.                                         (float) getY() - this.getAvatar().getHeight() / 2);
  132.                 }
  133.         }

  134.         /**
  135.          * @return the x
  136.          */
  137.         public double getX() {
  138.                 return x;
  139.         }

  140.         /**
  141.          * @return the y
  142.          */
  143.         public double getY() {
  144.                 return y;
  145.         }

  146.         /**
  147.          * Render non-avatar details (health bar)
  148.          *
  149.          * @param g
  150.          *            The graphics device to draw with
  151.          */
  152.         public void renderSecondary(Graphics g) {
  153.                 if (!(this instanceof Player)) {
  154.                         renderHealthBox(g);
  155.                 }
  156.         }

  157.         /**
  158.          * Renders a floating health box above the unit with the unit's name and
  159.          * health representation
  160.          *
  161.          * @param g
  162.          *            The graphics object to draw with.
  163.          */
  164.         public void renderHealthBox(Graphics g) {
  165.                 // Colours for drawing
  166.                 // Color LABEL = new Color(0.9f, 0.9f, 0.4f); // Gold
  167.                 Color VALUE = new Color(1.0f, 1.0f, 1.0f); // White
  168.                 Color BAR_BG = new Color(0.0f, 0.0f, 0.0f, 0.8f); // Black, transp
  169.                 Color BAR = new Color(0.8f, 0.0f, 0.0f, 0.8f); // Red, transp

  170.                 // Font for drawing
  171.                 // g.setFont(world.getLabelFont());
  172.                 // Set the width of the health bar based on the unit's name
  173.                 this.healthBarWidth = Math.max(70,
  174.                                 g.getFont().getWidth(this.getName()) + 6);

  175.                 // Draw the health bar
  176.                 float barX = (float) this.getX() - healthBarWidth / 2;
  177.                 float barY = (float) this.getY() - this.getPhysHeight() / 2
  178.                                 - healthBarHeight - 5;

  179.                 g.setColor(BAR_BG);
  180.                 g.fillRect(barX, barY, healthBarWidth, healthBarHeight);
  181.                 g.setColor(BAR);
  182.                 g.fillRect(barX, barY,
  183.                                 (healthBarWidth * ((float) getHealth() / getMaxHealth())),
  184.                                 healthBarHeight);

  185.                 // Draw name text (in white)
  186.                 g.setColor(VALUE);
  187.                 float textX = barX
  188.                                 + (healthBarWidth - g.getFont().getWidth(this.getName())) / 2;
  189.                 float textY = barY
  190.                                 + (healthBarHeight - g.getFont().getHeight(this.getName())) / 2;
  191.                 g.drawString(this.getName(), textX, textY);
  192.         }

  193.         /**
  194.          * @return the maxHealth
  195.          */
  196.         public int getMaxHealth() {
  197.                 return (int) (maxHealth + bonuses.get(Bonus.Type.MAXHP));
  198.         }

  199.         /**
  200.          * @return the health
  201.          */
  202.         public int getHealth() {
  203.                 return (int) (health);
  204.         }

  205.         /**
  206.          * @return the bonuses
  207.          */
  208.         public EnumMap<Bonus.Type, Double> getBonuses() {
  209.                 return bonuses;
  210.         }

  211.         /**
  212.          * @return the physWidth
  213.          */
  214.         public int getPhysWidth() {
  215.                 return physWidth;
  216.         }

  217.         /**
  218.          * @return the physHeight
  219.          */
  220.         public int getPhysHeight() {
  221.                 return physHeight;
  222.         }

  223.         /**
  224.          * @return the name
  225.          */
  226.         public String getName() {
  227.                 return name;
  228.         }

  229.         /**
  230.          * @param health
  231.          *            the health to set
  232.          */
  233.         public void setHealth(double health) {
  234.                 this.health = health;
  235.         }

  236.         /**
  237.          * @return the cooldownTimer
  238.          */
  239.         public int getCooldownTimer() {
  240.                 return cooldownTimer;
  241.         }

  242.         /**
  243.          * Attack another unit, dealing damage and resetting the cooldown timer
  244.          *
  245.          * @param target
  246.          *            The unit to attack
  247.          */
  248.         public void attack(Unit target) {
  249.                 if (cooldownTimer <= 0) {

  250.                         // Calculate how much damage to do
  251.                         double min, max, damage;

  252.                         min = 0;
  253.                         max = this.getMaxDamage();
  254.                         damage = min + (int) (Math.random() * (max - min));

  255.                         // Deal the damage
  256.                         target.damage(damage);

  257.                         if (this.face_left) {
  258.                                 this.getAvatar().rotate(-10);
  259.                         } else {
  260.                                 this.getAvatar().rotate(10);
  261.                         }
  262.                         // Reduce cooldown
  263.                         this.cooldownTimer = this.cooldown;
  264.                 }
  265.         }

  266.         /**
  267.          * Gets the maximum damage done by the unit's weapon.
  268.          *
  269.          * @return The maximum damage done by the unit's weapon
  270.          */
  271.         public double getMaxDamage() {
  272.                 double damage = this.strength+ this.getBonuses().get(Bonus.Type.DAMAGE);;

  273.                 return damage;
  274.         }

  275.         /**
  276.          * Deal damage to the unit
  277.          *
  278.          * @param damage
  279.          *            Amount of health to subtract
  280.          */
  281.         public void damage(double damage) {
  282.                 this.health -= damage;
  283.         }

  284.         /**
  285.          * @param cooldown
  286.          *            the cooldown to add
  287.          */
  288.         public void increaseCooldown(int cooldown)
  289.         {
  290.                 this.cooldown += cooldown;
  291.         }
  292.         /**
  293.          * @return the attackRange
  294.          */
  295.         public double getAttackRange()
  296.         {
  297.                 return attackRange;
  298.         }
  299.         /**
  300.          * @return the inventory
  301.          */
  302.         public Inventory getInventory()
  303.         {
  304.                 return inventory;
  305.         }
  306.        
  307.         /**
  308.          * Adjust the value of one of the unit's bonuses
  309.          *
  310.          * @param type
  311.          *            The bonus to adjust
  312.          * @param amount
  313.          *            How much to adjust the bonus by
  314.          */
  315.         public void adjustBonus(Bonus.Type type, double amount)
  316.         {
  317.                 this.getBonuses().put(type, this.getBonuses().get(type) + amount);
  318.                 if (type == Bonus.Type.MAXHP && getHealth() > getMaxHealth())
  319.                 {
  320.                         setHealth(getMaxHealth());
  321.                 }
  322.                 System.out.println(getName() + " adjusted " + type + " by " + amount);
  323.         }


  324.         public double getdir_x(){
  325.                 return dirx;
  326.         }
  327.         public double getdir_y(){
  328.                 return diry;
  329.         }


  330. }
复制代码
字符限制,连载中








欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2