A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

首先声明:这是一个完整2D游戏,包括打怪,升级,跑地图,开宝箱,加血,捡装备等等基本游戏元素,所有代码,都是我自己在学校的时候一行一行敲出来的,绝无雷同。
更多代码可以去看我的github,跟我论坛账号同一用户名。

接上篇 :

java完整2D游戏连载--part2 (单位基本类) http://bbs.itheima.com/thread-194622-1-1.html
map.java
  1. package project2;
  2. /*
  3. * use for loading map
  4. * author: weiqian wang<wangw>
  5. * */
  6. import org.newdawn.slick.tiled.TiledMap;


  7. public abstract class Map {
  8.        
  9.         private TiledMap map;
  10.        
  11.     /** Map width, in tiles. */
  12.     public int getMapWidth()
  13.     {
  14.         return map.getWidth();
  15.     }

  16.     /** Map height, in tiles. */
  17.     public int getMapHeight()
  18.     {
  19.         return map.getHeight();
  20.     }

  21.     /** Tile width, in pixels. */
  22.     public int getTileWidth()
  23.     {
  24.         return map.getTileWidth();
  25.     }

  26.     /** Tile height, in pixels. */
  27.     public int getTileHeight()
  28.     {
  29.         return map.getTileHeight();
  30.     }

  31.     /** Determines whether a particular map coordinate blocks movement.
  32.      * @param x Map x coordinate (in pixels).
  33.      * @param y Map y coordinate (in pixels).
  34.      * @return true if the coordinate blocks movement.
  35.      */
  36.     public boolean terrainBlocks(double x, double y)
  37.     {
  38.         int tile_x = (int) x / getTileWidth();
  39.         int tile_y = (int) y / getTileHeight();
  40.         int tileid = map.getTileId(tile_x, tile_y, 0);
  41.         String block = map.getTileProperty(tileid, "block", "0");
  42.         return !block.equals("0");
  43.     }
  44. }
复制代码

Player.java (玩家)
  1. package project2;
  2. /* 433-294 Object Oriented Software Development
  3. * RPG Game Engine
  4. * Sample Solution
  5. * Author: weiqian wang<wangw>
  6. */

  7. import org.newdawn.slick.Image;
  8. import org.newdawn.slick.SlickException;

  9. import Items.InventoryAccessory;
  10. import Items.InventoryQuest;
  11. import Items.InventoryWeapon;
  12. import Items.WorldItem;
  13. import Items.WorldQuest;
  14. import Items.WorldWeapon;
  15. import Monsters.Monster;

  16. /** The character which the user plays as.
  17. */
  18. public class Player extends Unit
  19. {


  20.     // Pixels per millisecond
  21.     private static final double SPEED = 0.25;
  22.     // pick up range
  23.     private static final float pickupRange = 30;


  24.     /** Creates a new Player.
  25.      * @param image_path Path of player's image file.
  26.      */
  27.     public Player()
  28.         throws SlickException
  29.     {

  30.                 init(756,684);

  31.         // Start off at (756,684)
  32.                 // Set the Player's avatar and physical size
  33.                 this.avatar = new Image("assets/units/player.png");

  34.         this.physHeight = 37;
  35.         this.physWidth = 47;
  36.                 //player's damage
  37.                 this.strength = 26;
  38.        
  39.     }

  40.     public void init(double ix,double iy){
  41.         this.x = ix;
  42.         this.y = iy;
  43.                 // Give the player full health
  44.                 this.health = this.getMaxHealth();
  45.                 this.cooldown = this.icooldown;
  46.     }
  47.    
  48.         public double getMaxDamage()
  49.         {
  50.                 double damage = strength;
  51.                
  52.                 InventoryWeapon weapon = (InventoryWeapon) (this.getInventory().hasItem("Sword of Strength"));

  53.                                
  54.                
  55.                 // If holding a weapon
  56.                 if (weapon != null){
  57.                         damage = weapon.getMaxDamage() * (this.strength+ 100) / 100;}
  58.                 damage += this.getBonuses().get(Bonus.Type.DAMAGE);
  59.                 return damage;
  60.         }

  61.         public void update(World world, double dir_x, double dir_y, int delta) throws SlickException{
  62.                 // Decrease the cooldown timer if necessary
  63.                                 if (this.getCooldownTimer() > 0)
  64.                                 {
  65.                                         this.cooldownTimer -= delta;
  66.                                         // If the attack is less than half cooled down, reset rotation
  67.                                         if (this.getCooldownTimer() < 0)
  68.                                         {
  69.                                                 this.getAvatar().rotate(-this.getAvatar().getRotation());
  70.                                         }
  71.                                 }
  72.                 // Calculate the player's new position on successful move
  73.                 double newX = getX() + dir_x * SPEED * delta;
  74.                 double newY = getY() + dir_y * SPEED * delta;

  75.                 // Check for items near the new position
  76.                 WorldItem item = scanForItem(world);
  77.                 if (item!=null && this.getInventory().getItems().size() < 4)
  78.                 {
  79.                         this.pickupItem(item, world);
  80.                 }
  81.                 // Check for monsters near the new position
  82.                 Monster m = scanForMonster(world);
  83.                 if (m != null)
  84.                 {
  85.                         this.attack(m);
  86.                         // If the monster was killed, add xp
  87.                         if (m.getHealth() <= 0)
  88.                         {
  89.                                 //monster die
  90.                                 m.die(world);
  91.                         }
  92.                 }
  93.                
  94.                 this.move(world, newX, newY, delta);       
  95.                
  96.                 if(this.health<=0){
  97.                         this.die();
  98.                 }
  99.         }

  100.         /**
  101.          * Scan the area around the player for monsters to attack.
  102.          *
  103.          * @param gps
  104.          *            The game world, which holds the list of monsters.
  105.          * @return The target to be attacked.
  106.          */
  107.         Monster scanForMonster(World world)
  108.         {
  109.                 // Check through every monster
  110.                 for (Monster m : world.getMonsters())
  111.                 {
  112.                         // Early failure check - if diff in either axis is too great, move
  113.                         // on
  114.                         if (Math.abs(this.getX() - m.getX()) > this.getAttackRange()
  115.                                         || Math.abs(this.getY() - m.getY()) > this.getAttackRange())
  116.                         {
  117.                                 continue;
  118.                         }

  119.                         // Find the actual distance from the player
  120.                         double monsterDist = world.distanceTo(this, m);

  121.                         // If within range, return the monster as a target
  122.                         if (monsterDist <= this.getAttackRange())
  123.                         {
  124.                                 return m;
  125.                         }
  126.                 }
  127.                 // No monsters in range, return null
  128.                 return null;
  129.         }
  130.        
  131.         /**
  132.          * Converts a WorldItem to an Item and adds it to the player's inventory.
  133.          *
  134.          * @param item
  135.          *            The WorldItem to be converted and added.
  136.          * @param world
  137.          *            The world from which to remove the WorldItem.
  138.          */
  139.         public void pickupItem(WorldItem item, World world)
  140.         {
  141.                 System.out.println(item.getType());
  142.                         // If it's an accessory
  143.                 if (item.getType() == Item.Type.ACCESSORY)
  144.                         {
  145.                                 this.getInventory()
  146.                                                 .addItem(
  147.                                                                 new InventoryAccessory(item.getName(), item.getAvatar(), item
  148.                                                                                 .getBonuses()));
  149.                                 if (item.getName() == "Amulet of Vitality"){
  150.                                         this.health += 40;
  151.                                         this.maxHealth += 40;
  152.                                 }
  153.                                 else {
  154.                                         this.icooldown -= 200;
  155.                                 }
  156.                         }
  157.                         // If it's a weapon
  158.                         else if (item.getType() == Item.Type.WEAPON)
  159.                         {
  160.                                 WorldWeapon weapon = (WorldWeapon) (item);
  161.                                 this.getInventory().addItem(
  162.                                                 new InventoryWeapon(weapon.getName(), weapon.getAvatar(), weapon
  163.                                                                 .getBonuses(), weapon.getMinDamage(), weapon.getMaxDamage()));
  164.                                 this.strength = this.getMaxDamage();
  165.                         }
  166.                
  167.                         // If it's a quest item
  168.                         else if (item.getType() == Item.Type.QUEST)
  169.                         {
  170.                                 WorldQuest quest = (WorldQuest) (item);
  171.                                 this.getInventory().addItem(
  172.                                                 new InventoryQuest(quest.getName(), quest.getAvatar(), quest.getBonuses()));
  173.                         }

  174.                
  175.                
  176.                 this.cooldown = (int) (this.icooldown + this.getBonuses().get(Bonus.Type.COOLDOWN));
  177.                 // Debug print
  178.                 System.out.println(getName() + " picked up " + item);
  179.                 // Remove the item from the world
  180.                 item.die(world);
  181.         }

  182.         /**
  183.          * Scan the area around the player for pickuppable items.
  184.          *
  185.          * @param gps
  186.          *            The game world, which holds the list of world items.
  187.          * @return The item that may be picked up.
  188.          */
  189.         WorldItem scanForItem(World world)
  190.         {
  191.                 // Check through every WorldItem
  192.                 for (WorldItem w : world.items)
  193.                 {
  194.                         // Early failure check - if diff in either axis is too great, move
  195.                         // on
  196.                         if (Math.abs(this.getX() - w.getX()) > this.getPickupRange()
  197.                                         || Math.abs(this.getY() - w.getY()) > this.getPickupRange())
  198.                         {
  199.                                 continue;
  200.                         }

  201.                         // Find the actual distance from the player
  202.                         double itemDist = world.distanceTo(this, w);

  203.                         // If within range, set the item as a pickup candidate
  204.                         if (itemDist <= pickupRange)
  205.                         {
  206.                                 return w;
  207.                         }
  208.                 }
  209.                 // No items in range, return null
  210.                 return null;
  211.         }

  212.         /**
  213.          * @return the pickupRange
  214.          */
  215.         public float getPickupRange()
  216.         {
  217.                 return pickupRange;
  218.         }
  219.        
  220.         /**
  221.          * if player die
  222.          */
  223.         public void die(){
  224.                 this.init(900,590);
  225.         }



  226. }
复制代码

Inventory.java
  1. package project2;
  2. /*
  3. * the player's inventory
  4. * author: weiqian wang<wangw>
  5. * */
  6. import java.util.ArrayList;

  7. import Items.InventoryItem;

  8. public class Inventory
  9. {
  10.         /** The max number of items the inventory can contain */
  11.         protected int capacity;
  12.         /** List of the items the unit owns */
  13.         protected ArrayList<InventoryItem> items = new ArrayList<InventoryItem>();

  14.         public Inventory(int capacity)
  15.         {
  16.                 this.capacity = capacity;
  17.         }

  18.         public Inventory()
  19.         {
  20.                 this.capacity = 4;
  21.         }

  22.         /**
  23.          * @param name
  24.          *            The name of the item to find in the inventory
  25.          * @return whether the item is present
  26.          */
  27.         public InventoryItem hasItem(String name)
  28.         {
  29.                 for (InventoryItem item : items)
  30.                 {
  31.                         if (item.getName().equals(name))
  32.                                 return item;
  33.                 }
  34.                 return null;
  35.         }

  36.         /**
  37.          * Add an inventory item to the list of items in the inventory
  38.          *
  39.          * @param item
  40.          *            the item to add
  41.          */
  42.         public void addItem(InventoryItem item)
  43.         {
  44.                 items.add(item);
  45.         }

  46.         /**
  47.          * @return the items
  48.          */
  49.         public ArrayList<InventoryItem> getItems()
  50.         {
  51.                 return items;
  52.         }
  53.         /**
  54.          * @return the capacity
  55.          */
  56.         public int getCapacity()
  57.         {
  58.                 return capacity;
  59.         }
  60. }
复制代码




3 个回复

倒序浏览
楼主威武
回复 使用道具 举报
ding .........................
回复 使用道具 举报
duang duang...........
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马