开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Java编程 > Applet > 游戏 > 查看源码
MobSkill.java
资源名称：src.rar　[点击查看]
上传用户：gwt600
上传日期：2021-06-03
资源大小：704k
文件大小：13k
源码类别：

游戏

开发平台：

Java

MobSkill.java：源码内容
  1.     /*
  2.         This file is part of the OdinMS Maple Story Server
  3.         Copyright (C) 2008 Patrick Huy <patrick.huy@frz.cc>
  4.         Matthias Butz <matze@odinms.de>
  5.         Jan Christian Meyer <vimes@odinms.de>
  7.         This program is free software: you can redistribute it and/or modify
  8.         it under the terms of the GNU Affero General Public License version 3
  9.         as published by the Free Software Foundation. You may not use, modify
  10.         or distribute this program under any other version of the
  11.         GNU Affero General Public License.
  13.         This program is distributed in the hope that it will be useful,
  14.         but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.         GNU Affero General Public License for more details.
  18.         You should have received a copy of the GNU Affero General Public License
  19.         along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20.  */
  21. package net.sf.odinms.server.life;
  23. import java.awt.Point;
  24. import java.awt.Rectangle;
  25. import java.util.ArrayList;
  26. import java.util.Collections;
  27. import java.util.List;
  28. import java.util.Random;
  29. import net.sf.odinms.client.MapleCharacter;
  30. import net.sf.odinms.client.MapleDisease;
  31. import net.sf.odinms.client.status.MonsterStatus;
  32. import net.sf.odinms.server.MaplePortal;
  33. import net.sf.odinms.server.maps.MapleMap;
  34. import net.sf.odinms.server.maps.MapleMapObject;
  35. import net.sf.odinms.server.maps.MapleMapObjectType;
  37. /**
  38.  *
  39.  * @author Danny (Leifde)
  40.  */
  41. public class MobSkill {
  43.     private int skillId;
  44.     private int skillLevel;
  45.     private int mpCon;
  46.     private List<Integer> toSummon = new ArrayList<Integer>();
  47.     private int spawnEffect;
  48.     private int hp;
  49.     private int x;
  50.     private int y;
  51.     private long duration;
  52.     private long cooltime;
  53.     private float prop;
  54.     private Point lt,  rb;
  55.     private int limit;
  57.     public MobSkill(int skillId, int level) {
  58.         this.skillId = skillId;
  59.         this.skillLevel = level;
  60.     }
  62.     public void setMpCon(int mpCon) {
  63.         this.mpCon = mpCon;
  64.     }
  66.     public void addSummons(List<Integer> toSummon) {
  67.         for (Integer summon : toSummon) {
  68.             this.toSummon.add(summon);
  69.         }
  70.     }
  72.     public void setSpawnEffect(int spawnEffect) {
  73.         this.spawnEffect = spawnEffect;
  74.     }
  76.     public void setHp(int hp) {
  77.         this.hp = hp;
  78.     }
  80.     public void setX(int x) {
  81.         this.x = x;
  82.     }
  84.     public void setY(int y) {
  85.         this.y = y;
  86.     }
  88.     public void setDuration(long duration) {
  89.         this.duration = duration;
  90.     }
  92.     public void setCoolTime(long cooltime) {
  93.         this.cooltime = cooltime;
  94.     }
  96.     public void setProp(float prop) {
  97.         this.prop = prop;
  98.     }
  100.     public void setLtRb(Point lt, Point rb) {
  101.         this.lt = lt;
  102.         this.rb = rb;
  103.     }
  105.     public void setLimit(int limit) {
  106.         this.limit = limit;
  107.     }
  109.     public void applyEffect(MapleCharacter player, MapleMonster monster, boolean skill) {
  110.         MonsterStatus monStat = null;
  111.         MapleDisease disease = null;
  112.         boolean heal = false;
  113.         boolean dispel = false;
  114.         boolean seduce = false;
  115.         boolean banish = false;
  116.                 if (skillId > 119 && skillId < 140 && player.isGM()) {
  117.             return;
  118.         }
  119.         switch (skillId) {
  120.             case 100:
  121.             case 110:
  122.                 monStat = MonsterStatus.WEAPON_ATTACK_UP;
  123.                 break;
  124.             case 101:
  125.             case 111:
  126.                 monStat = MonsterStatus.MAGIC_ATTACK_UP;
  127.                 break;
  128.             case 102:
  129.             case 112:
  130.                 monStat = MonsterStatus.WEAPON_DEFENSE_UP;
  131.                 break;
  132.             case 103:
  133.             case 113:
  134.                 monStat = MonsterStatus.MAGIC_DEFENSE_UP;
  135.                 break;
  136.             case 114: // Heal
  137.                 heal = true;
  138.                 break;
  139.             case 120:
  140.                 disease = MapleDisease.SEAL;
  141.                 break;
  142.             case 121:
  143.                 disease = MapleDisease.DARKNESS;
  144.                 break;
  145.             case 122:
  146.                 disease = MapleDisease.WEAKEN;
  147.                 break;
  148.             case 123:
  149.                 disease = MapleDisease.STUN;
  150.                 break;
  151.             case 124: // Curse TODO
  152.                 break;
  153.             case 125:
  154.                 disease = MapleDisease.POISON;
  155.                 break;
  156.             case 126: // Slow
  157.                 disease = MapleDisease.SLOW;
  158.                 break;
  159.             case 127:
  160.                 dispel = true;
  161.                 break;
  162.             case 128: // Seduce
  163.                 seduce = true;
  164.                 break;
  165.             case 129: // Banish
  166.                 banish = true; // player gets dmg = send to town... needs to be fixed
  167.                 break;
  168.             case 140:
  169.                 if (makeChanceResult() && !monster.isBuffed(MonsterStatus.MAGIC_IMMUNITY)) {
  170.                     monStat = MonsterStatus.WEAPON_IMMUNITY;
  171.                 }
  172.                 break;
  173.             case 141:
  174.                 if (makeChanceResult() && !monster.isBuffed(MonsterStatus.WEAPON_IMMUNITY)) {
  175.                     monStat = MonsterStatus.MAGIC_IMMUNITY;
  176.                 }
  177.                 break;
  178.             case 200:
  179.                 if (monster.getMap().getSpawnedMonstersOnMap() < 80) {
  180.                     for (Integer mobId : getSummons()) {
  181.                         MapleMonster toSpawn = MapleLifeFactory.getMonster(mobId);
  182.                         toSpawn.setPosition(monster.getPosition());
  183.                         int ypos, xpos;
  184.                         xpos = (int) monster.getPosition().getX();
  185.                         ypos = (int) monster.getPosition().getY();
  186.                         switch (mobId) {
  187.                             case 8500003: // Pap bomb high
  188.                                 toSpawn.setFh((int) Math.ceil(Math.random() * 19.0));
  189.                                 ypos = -590;
  190.                             case 8500004: // Pap bomb
  191.                                 //Spawn between -500 and 500 from the monsters X position
  192.                                 xpos = (int) (monster.getPosition().getX() + Math.ceil(Math.random() * 1000.0) - 500);
  193.                                 if (ypos != -590) {
  194.                                     ypos = (int) monster.getPosition().getY();
  195.                                 }
  196.                                 break;
  197.                             case 8510100: //Pianus bomb
  198.                                 if (Math.ceil(Math.random() * 5) == 1) {
  199.                                     ypos = 78;
  200.                                     xpos = (int) (0 + Math.ceil(Math.random() * 5)) + ((Math.ceil(Math.random() * 2) == 1) ? 180 : 0);
  201.                                 } else {
  202.                                     xpos = (int) (monster.getPosition().getX() + Math.ceil(Math.random() * 1000.0) - 500);
  203.                                 }
  204.                                 break;
  205.                         }
  206.                         // Get spawn coordinates (This fixes monster lock)
  207.                         // TODO get map left and right wall. Any suggestions? PM TheRamon
  208.                         switch (monster.getMap().getId()) {
  209.                             case 220080001: //Pap map
  210.                                 if (xpos < -890) {
  211.                                     xpos = (int) (-890 + Math.ceil(Math.random() * 150));
  212.                                 } else if (xpos > 230) {
  213.                                     xpos = (int) (230 - Math.ceil(Math.random() * 150));
  214.                                 }
  215.                                 break;
  216.                             case 230040420: // Pianus map
  217.                                 if (xpos < -239) {
  218.                                     xpos = (int) (-239 + Math.ceil(Math.random() * 150));
  219.                                 } else if (xpos > 371) {
  220.                                     xpos = (int) (371 - Math.ceil(Math.random() * 150));
  221.                                 }
  222.                                 break;
  223.                         }
  224.                         toSpawn.setPosition(new Point(xpos, ypos));
  225.                         monster.getMap().spawnMonsterWithEffect(toSpawn, getSpawnEffect(), toSpawn.getPosition());
  226.                     }
  227.                 }
  228.                 break;
  229.         }
  230.         if (monStat != null || heal) {
  231.             if (lt != null && rb != null && skill) {
  232.                 List<MapleMapObject> objects = getObjectsInRange(monster, MapleMapObjectType.MONSTER);
  233.                 if (heal) {
  234.                     for (MapleMapObject mons : objects) {
  235.                         ((MapleMonster) mons).heal(getX(), getY());
  236.                     }
  237.                 } else {
  238.                     for (MapleMapObject mons : objects) {
  239.                         if (!monster.isBuffed(monStat)) {
  240.                             ((MapleMonster) mons).applyMonsterBuff(monStat, getX(), getSkillId(), getDuration(), this);
  241.                         }
  242.                     }
  243.                 }
  244.             } else {
  245.                 if (heal) {
  246.                     monster.heal(getX(), getY());
  247.                 } else {
  248.                     if (!monster.isBuffed(monStat)) {
  249.                         monster.applyMonsterBuff(monStat, getX(), getSkillId(), getDuration(), this);
  250.                     }
  251.                 }
  252.             }
  253.         }
  254.         if (disease != null || dispel || seduce || banish) {
  255.             if (new Random().nextInt(6) < 4) { // makes a number between 0 - 5. If 0, 1, 2, or 3 then give desiease
  256.                 if (skill && lt != null && rb != null) {
  257.                     int i = 0;
  258.                     List<MapleCharacter> characters = getPlayersInRange(monster, player);
  259.                     for (MapleCharacter character : characters) {
  260.                         if (dispel) {
  261.                             character.dispel();
  262.                         } else if (banish) {
  263.                             MapleMap to = player.getMap().getReturnMap();
  264.                             MaplePortal pto = to.getPortal(new Random().nextInt(to.getPortals().size()));
  265.                             character.changeMap(to, pto);
  266.                         } else if (seduce && i < 10) {
  267.                             character.giveDebuff(MapleDisease.SEDUCE, this);
  268.                             i++;
  269.                         } else {
  270.                             character.giveDebuff(disease, this);
  271.                         }
  272.                     }
  273.                 } else {
  274.                     if (dispel) {
  275.                         player.dispel();
  276.                     } else {
  277.                         player.giveDebuff(disease, this);
  278.                     }
  279.                 }
  280.             }
  281.         }
  282.         monster.usedSkill(skillId, skillLevel, cooltime);
  283.         monster.setMp(monster.getMp() - getMpCon());
  284.     }
  286.     public int getSkillId() {
  287.         return skillId;
  288.     }
  290.     public int getSkillLevel() {
  291.         return skillLevel;
  292.     }
  294.     public int getMpCon() {
  295.         return mpCon;
  296.     }
  298.     public List<Integer> getSummons() {
  299.         return Collections.unmodifiableList(toSummon);
  300.     }
  302.     public int getSpawnEffect() {
  303.         return spawnEffect;
  304.     }
  306.     public int getHP() {
  307.         return hp;
  308.     }
  310.     public int getX() {
  311.         return x;
  312.     }
  314.     public int getY() {
  315.         return y;
  316.     }
  318.     public long getDuration() {
  319.         return duration;
  320.     }
  322.     public long getCoolTime() {
  323.         return cooltime;
  324.     }
  326.     public Point getLt() {
  327.         return lt;
  328.     }
  330.     public Point getRb() {
  331.         return rb;
  332.     }
  334.     public int getLimit() {
  335.         return limit;
  336.     }
  338.     public boolean makeChanceResult() {
  339.         return prop == 1.0 || Math.random() < prop;
  340.     }
  342.     private Rectangle calculateBoundingBox(Point posFrom, boolean facingLeft) {
  343.         Point mylt;
  344.         Point myrb;
  345.         if (facingLeft) {
  346.             mylt = new Point(lt.x + posFrom.x, lt.y + posFrom.y);
  347.             myrb = new Point(rb.x + posFrom.x, rb.y + posFrom.y);
  348.         } else {
  349.             myrb = new Point(lt.x * -1 + posFrom.x, rb.y + posFrom.y);
  350.             mylt = new Point(rb.x * -1 + posFrom.x, lt.y + posFrom.y);
  351.         }
  352.         Rectangle bounds = new Rectangle(mylt.x, mylt.y, myrb.x - mylt.x, myrb.y - mylt.y);
  353.         return bounds;
  354.     }
  356.     private List<MapleCharacter> getPlayersInRange(MapleMonster monster, MapleCharacter player) {
  357.         Rectangle bounds = calculateBoundingBox(monster.getPosition(), monster.isFacingLeft());
  358.         List<MapleCharacter> players = new ArrayList<MapleCharacter>();
  359.         players.add(player);
  360.         return monster.getMap().getPlayersInRect(bounds, players);
  361.     }
  363.     private List<MapleMapObject> getObjectsInRange(MapleMonster monster, MapleMapObjectType objectType) {
  364.         Rectangle bounds = calculateBoundingBox(monster.getPosition(), monster.isFacingLeft());
  365.         List<MapleMapObjectType> objectTypes = new ArrayList<MapleMapObjectType>();
  366.         objectTypes.add(objectType);
  367.         return monster.getMap().getMapObjectsInRect(bounds, objectTypes);
  368.     }
  369. }