1188 lines
36 KiB
ActionScript
1188 lines
36 KiB
ActionScript
package net.pixvi.myr.center
|
|
{
|
|
import net.pixvi.common.driver.SecondDriver;
|
|
import net.pixvi.common.system.language.lang;
|
|
import net.pixvi.common.utils.Alert;
|
|
import net.pixvi.myr.CP;
|
|
import net.pixvi.myr.GameMath;
|
|
import net.pixvi.myr.battle.view.BattleMon;
|
|
import net.pixvi.myr.element.achi.AchiType;
|
|
import net.pixvi.myr.element.bag.EquipVo;
|
|
import net.pixvi.myr.element.bag.ItemVo;
|
|
import net.pixvi.myr.element.battle.BattleMonVo;
|
|
import net.pixvi.myr.element.mon.EggVo;
|
|
import net.pixvi.myr.element.mon.MonsterVo;
|
|
import net.pixvi.myr.element.mon.SkinVo;
|
|
import net.pixvi.myr.element.stack.StackVo;
|
|
import net.pixvi.myr.element.team.TeamVo;
|
|
import net.pixvi.myr.event.MYREvent;
|
|
import net.pixvi.myr.net.NetEquip;
|
|
import net.pixvi.myr.net.NetMonster;
|
|
import net.pixvi.myr.net.NetStack;
|
|
import net.pixvi.myr.panel.storeground.StoreGroundPanel;
|
|
import net.pixvi.pfw.event.PiEvent;
|
|
import net.pixvi.pfw.utils.ArrayUtil;
|
|
import net.pixvi.pfw.utils.Caller;
|
|
import net.pixvi.pfw.utils.Oncer;
|
|
import net.pixvi.pfw.utils.Paster;
|
|
import net.pixvi.pfw.utils.Random;
|
|
import net.pixvi.pfw.utils.broadcast.GlobalBroadcast;
|
|
import net.pixvi.pfw.utils.core.Singleton;
|
|
import net.pixvi.pfw.utils.json.Json;
|
|
|
|
public class MonsterCenter extends Singleton
|
|
{
|
|
|
|
private var onAddCzComplete:Function;
|
|
|
|
private var addCz_buff_monid:Number;
|
|
|
|
public var prevAddParaName:String = "";
|
|
|
|
private var onFeedMonsterComplete:Function;
|
|
|
|
private var feedMonster_para:Object;
|
|
|
|
private var onGiftComplete:Function;
|
|
|
|
private var gift_para:Object;
|
|
|
|
private var moveMonFromRoom_para:Object;
|
|
|
|
private var onMoveMonFromRoomComplete:Function;
|
|
|
|
private var onSellMonstersComplete:Function;
|
|
|
|
private var onSellMonsters_para:Object;
|
|
|
|
private var onCheckGrowUpComplete:Function;
|
|
|
|
private var checkGrowUp_para:Object;
|
|
|
|
private var onSwitchGrowthComplete:Function;
|
|
|
|
private var switchGrowth_para:Object;
|
|
|
|
private var onEquipOnComplete:Function;
|
|
|
|
private var equipOn_para:Object;
|
|
|
|
private var onEquipOffComplete:Function;
|
|
|
|
private var equipOff_para:Object;
|
|
|
|
private var onAddPotentialComplete:Function;
|
|
|
|
private var onUpStarComplete:Function;
|
|
|
|
private var onUpStar_mon:MonsterVo;
|
|
|
|
public function MonsterCenter()
|
|
{
|
|
super();
|
|
}
|
|
|
|
public static function getIns() : MonsterCenter
|
|
{
|
|
return Singleton.getInstanceOrCreate(MonsterCenter) as MonsterCenter;
|
|
}
|
|
|
|
public static function getMonsterImgSrc(type:String, mode:String) : String
|
|
{
|
|
return "data/img/monster/mon" + type + "_" + mode + ".png";
|
|
}
|
|
|
|
public static function getMonByMonData(monData:Object) : MonsterVo
|
|
{
|
|
var mon:MonsterVo = new MonsterVo(monData.typeId);
|
|
mon.id = monData.id;
|
|
mon.level = monData.level;
|
|
mon.exp = monData.exp;
|
|
mon.tplevel = monData.tpLevel;
|
|
if(mon.tplevel > GameMath.maxTpLevel)
|
|
{
|
|
mon.tplevel = GameMath.maxTpLevel;
|
|
}
|
|
mon.tpexp = monData.tpExp;
|
|
mon.feel = monData.feel;
|
|
if(monData.upStar != null)
|
|
{
|
|
mon.upStar = monData.upStar;
|
|
}
|
|
mon.process = monData.process;
|
|
mon.mode = monData.mode;
|
|
mon.g_atk.val = monData.gAtk;
|
|
mon.g_def.val = monData.gDef;
|
|
mon.g_hp.val = monData.gHp;
|
|
mon.g_dex.val = monData.gDex;
|
|
mon.lock = monData.lock == 1;
|
|
mon.sysLock = monData.sysLock == 1;
|
|
mon.nicName = monData.nicName;
|
|
mon.timeGet = monData.timeGet / 1000;
|
|
mon.timeStart = monData.timeStart / 1000;
|
|
mon.roomId = monData.roomId;
|
|
mon.inExploreTeam = monData.inExploreTeam == 1;
|
|
mon.equip1 = monData.equip1;
|
|
mon.equip2 = monData.equip2;
|
|
mon.equip3 = monData.equip3;
|
|
mon.equip4 = monData.equip4;
|
|
mon.equip5 = monData.equip5;
|
|
mon.potential_atk.val = monData.pAtk;
|
|
mon.potential_def.val = monData.pDef;
|
|
mon.potential_hp.val = monData.pHp;
|
|
mon.potential_dex.val = monData.pDex;
|
|
mon.potentialLevel = monData.potentialLevel;
|
|
mon.giftTime = monData.giftTime / 1000;
|
|
if(monData.skin != null)
|
|
{
|
|
mon.skin = monData.skin;
|
|
if(mon.skin > 0)
|
|
{
|
|
mon.skinVo = new SkinVo(mon.skin);
|
|
}
|
|
}
|
|
mon.buildQuality();
|
|
mon.buildSkill();
|
|
if(monData.entangleSkills == null)
|
|
{
|
|
mon.entangleSkill = {};
|
|
}
|
|
else
|
|
{
|
|
mon.entangleSkill = Json.decode(monData.entangleSkills);
|
|
}
|
|
mon.entangle = monData.entangle;
|
|
mon.entangleLevel = monData.entangleLevel;
|
|
mon.skin = monData.skin;
|
|
return mon;
|
|
}
|
|
|
|
public static function getHurtestMon(arr:Array) : BattleMon
|
|
{
|
|
var cm:BattleMon = null;
|
|
for each(var m:BattleMon in arr)
|
|
{
|
|
if(cm == null)
|
|
{
|
|
cm = m;
|
|
}
|
|
else if(cm.monVo.hp / cm.monVo.hpMax > m.monVo.hp / m.monVo.hpMax)
|
|
{
|
|
cm = m;
|
|
}
|
|
}
|
|
return cm;
|
|
}
|
|
|
|
public function addCz(monId:Number, onComplete:Function = null) : void
|
|
{
|
|
onAddCzComplete = onComplete;
|
|
addCz_buff_monid = monId;
|
|
NetMonster.getIns().addCz(monId,addCzHandler);
|
|
}
|
|
|
|
private function addCzHandler(re:Object) : void
|
|
{
|
|
var mon:MonsterVo = getMonById(addCz_buff_monid);
|
|
prevAddParaName = "";
|
|
if(mon.g_atk.val != re.atk)
|
|
{
|
|
prevAddParaName = "atk";
|
|
}
|
|
else if(mon.g_def.val != re.def)
|
|
{
|
|
prevAddParaName = "def";
|
|
}
|
|
else if(mon.g_hp.val != re.hp)
|
|
{
|
|
prevAddParaName = "hp";
|
|
}
|
|
else if(mon.g_dex.val != re.dex)
|
|
{
|
|
prevAddParaName = "dex";
|
|
}
|
|
else
|
|
{
|
|
prevAddParaName = "";
|
|
}
|
|
mon.g_atk.val = re.atk;
|
|
mon.g_def.val = re.def;
|
|
mon.g_hp.val = re.hp;
|
|
mon.g_dex.val = re.dex;
|
|
mon.buildQuality();
|
|
if(prevAddParaName != "")
|
|
{
|
|
BagCenter.getIns().subNumByType(Table.game_setting.czPotion,1,true,"",true);
|
|
}
|
|
else
|
|
{
|
|
Alert.showMsg(lang("无法继续强化,已达到最高资质!"));
|
|
}
|
|
if(onAddCzComplete != null)
|
|
{
|
|
onAddCzComplete(re);
|
|
onAddCzComplete = null;
|
|
}
|
|
}
|
|
|
|
public function reset() : void
|
|
{
|
|
SecondDriver.getIns().remove(secondHandler);
|
|
}
|
|
|
|
public function startSecondListener() : void
|
|
{
|
|
SecondDriver.getInstance().regist(secondHandler);
|
|
}
|
|
|
|
public function pauseSecondListener() : void
|
|
{
|
|
SecondDriver.getIns().remove(secondHandler);
|
|
}
|
|
|
|
public function canEntangle(vo:MonsterVo) : Boolean
|
|
{
|
|
if(vo.entangle)
|
|
{
|
|
return true;
|
|
}
|
|
if(getEntangleMonByType(vo.type) != null)
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public function idsToMons(monIds:Array) : Array
|
|
{
|
|
var mon:MonsterVo = null;
|
|
var i:int = 0;
|
|
var mons:Array = [];
|
|
for(i = 0; i < monIds.length; )
|
|
{
|
|
mon = getMonById(monIds[i]);
|
|
if(mon == null)
|
|
{
|
|
throw new Error("这里有问题");
|
|
}
|
|
mons.push(mon);
|
|
i++;
|
|
}
|
|
return mons;
|
|
}
|
|
|
|
public function removeLocalMonsters(mons:Array, eventType:String = "task") : void
|
|
{
|
|
var i:int = 0;
|
|
var equipvo:EquipVo = null;
|
|
for each(var m:MonsterVo in mons)
|
|
{
|
|
if(m.process != 1)
|
|
{
|
|
if(m.process == 2)
|
|
{
|
|
StackCenter.getIns().cleanLocalStackByMonId(m.id);
|
|
}
|
|
else if(m.process == 3)
|
|
{
|
|
for(i = 1; i <= GameMath.equipNum; )
|
|
{
|
|
if(m["equip" + i] > 0)
|
|
{
|
|
equipvo = BagCenter.getIns().getById(m["equip" + i]) as EquipVo;
|
|
if(equipvo != null)
|
|
{
|
|
equipvo.isUsed = false;
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
ArrayUtil.remove(Master.monsters,m);
|
|
if(m.process == 2)
|
|
{
|
|
GlobalBroadcast.dispatchEvent(new MYREvent(MYREvent.MONSTER_REMOVE_STACK,{
|
|
"mon":m,
|
|
"type":"sell"
|
|
}));
|
|
}
|
|
else
|
|
{
|
|
GlobalBroadcast.dispatchEvent(new MYREvent(MYREvent.MONSTER_REMOVE,{
|
|
"mon":m,
|
|
"type":"sell"
|
|
}));
|
|
}
|
|
}
|
|
Oncer.lastRun(StoreGroundPanel.getIns().ground.autoCheckMon);
|
|
}
|
|
|
|
public function getTaskMonsterMode0(type:int, num:int = 0) : Array
|
|
{
|
|
var eggs:Array = [];
|
|
var count:int = num == 0 ? 2147483647 : num;
|
|
for each(var egg:EggVo in Master.bag.items)
|
|
{
|
|
if(egg.type == egg.type)
|
|
{
|
|
eggs.push(egg);
|
|
count--;
|
|
}
|
|
if(count == 0)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
return eggs;
|
|
}
|
|
|
|
public function getTaskMonsterMode2(type:int, num:int = 0) : Array
|
|
{
|
|
var i:int = 0;
|
|
var mons:Array = [];
|
|
for each(var m:MonsterVo in Master.monsters)
|
|
{
|
|
if(m.type == type && m.mode == 2 && m.level == 1 && m.inteam == 0 && !m.isLock() && !m.inExploreTeam)
|
|
{
|
|
mons.push(m);
|
|
}
|
|
}
|
|
mons.sortOn("qualityNum",16);
|
|
var ids:Array = [];
|
|
mons = mons.slice(0,num);
|
|
for(i = 0; i < mons.length; )
|
|
{
|
|
ids.push(mons[i].id);
|
|
i++;
|
|
}
|
|
return ids;
|
|
}
|
|
|
|
public function getMonByType(type:int, lv:int = 1, mode:int = -1, process:int = -1, isCanRemove:Boolean = false) : MonsterVo
|
|
{
|
|
for each(var m:MonsterVo in Master.monsters)
|
|
{
|
|
if(m.type == type && m.level == lv && (mode == -1 || m.mode == mode) && (process == -1 || m.process == process) && (!isCanRemove || m.canRemove()))
|
|
{
|
|
return m;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public function getBattleMonVoByMid(mid:Number) : BattleMonVo
|
|
{
|
|
if(mid <= 0)
|
|
{
|
|
return null;
|
|
}
|
|
var monVo:MonsterVo = getMonById(mid);
|
|
var battleMonVo:BattleMonVo = new BattleMonVo();
|
|
battleMonVo.ai = 0;
|
|
battleMonVo.ai_search = 2;
|
|
battleMonVo.equips = monVo.getEquipTypes();
|
|
battleMonVo.buildByMonster(monVo);
|
|
battleMonVo.buildSpecialByMonster(monVo);
|
|
battleMonVo.mid = monVo.id;
|
|
return battleMonVo;
|
|
}
|
|
|
|
public function dropMonster(mons:Array) : void
|
|
{
|
|
var mon:MonsterVo = null;
|
|
var i:int = 0;
|
|
for(i = 0; i < mons.length; )
|
|
{
|
|
mon = mons[i];
|
|
StackCenter.getIns().getStackByMonster(mon.id).monsterId = 0;
|
|
ArrayUtil.remove(Master.monsters,mon);
|
|
GlobalBroadcast.dispatchEvent(new MYREvent(MYREvent.MONSTER_REMOVE_STACK,{
|
|
"mon":mon,
|
|
"type":"drop"
|
|
}));
|
|
i++;
|
|
}
|
|
}
|
|
|
|
public function getFeedExp(feedsMon:Array) : int
|
|
{
|
|
var m:MonsterVo = null;
|
|
var i:int = 0;
|
|
var totalexp:int = 0;
|
|
for(i = 0; i < feedsMon.length; )
|
|
{
|
|
m = feedsMon[i];
|
|
totalexp += m.feed_exp;
|
|
i++;
|
|
}
|
|
return totalexp;
|
|
}
|
|
|
|
public function getTPExp(feedsMon:Array, type:int) : int
|
|
{
|
|
var m:MonsterVo = null;
|
|
var i:int = 0;
|
|
var totalexp:int = 0;
|
|
for(i = 0; i < feedsMon.length; )
|
|
{
|
|
m = feedsMon[i];
|
|
if(m.type == type || m.type.toString() == Table.game_setting.specialFood || m.type.toString() == Table.game_setting.specialFood14 && MonsterVo.getStar(type) < 5)
|
|
{
|
|
totalexp++;
|
|
}
|
|
i++;
|
|
}
|
|
return totalexp;
|
|
}
|
|
|
|
public function feedMonster(monVo:MonsterVo, foodsMonVo:Array, onComplete:Function) : void
|
|
{
|
|
var m:* = null;
|
|
var i:int = 0;
|
|
onFeedMonsterComplete = onComplete;
|
|
var foodsMonId:Array = [];
|
|
var totalexp:int = getFeedExp(foodsMonVo);
|
|
var tupoexp:int = 0;
|
|
for(i = 0; i < foodsMonVo.length; )
|
|
{
|
|
foodsMonId.push(foodsMonVo[i].id);
|
|
i++;
|
|
}
|
|
feedMonster_para = {
|
|
"monVo":monVo,
|
|
"foodsMonVo":foodsMonVo
|
|
};
|
|
NetMonster.getIns().feedMonster(monVo.id,foodsMonId,feedMonsterOverHandler);
|
|
}
|
|
|
|
private function feedMonsterOverHandler(newTotalExp:int, newTotalTpExp:int, level:int, tpLevel:int) : void
|
|
{
|
|
var mon:MonsterVo = feedMonster_para.monVo;
|
|
trace("增量exp:",newTotalExp - mon.exp);
|
|
trace("增量tpexp:",newTotalTpExp - mon.tpexp);
|
|
mon.exp = newTotalExp;
|
|
mon.tpexp = newTotalTpExp;
|
|
mon.level = level;
|
|
if(tpLevel > GameMath.maxTpLevel)
|
|
{
|
|
tpLevel = GameMath.maxTpLevel;
|
|
}
|
|
mon.tplevel = tpLevel;
|
|
removeLocalMonsters(feedMonster_para.foodsMonVo,"food");
|
|
GlobalBroadcast.dispatchEvent(new MYREvent(MYREvent.MONSTER_NUM_CHANGE,{"mon":feedMonster_para.monVo}));
|
|
feedMonster_para = null;
|
|
if(onFeedMonsterComplete != null)
|
|
{
|
|
onFeedMonsterComplete(newTotalExp,newTotalTpExp);
|
|
onFeedMonsterComplete = null;
|
|
}
|
|
}
|
|
|
|
public function gift(mid:Number, itemid:Number, show:Boolean = true, onComplete:Function = null) : void
|
|
{
|
|
onGiftComplete = onComplete;
|
|
var mon:MonsterVo = getMonById(mid);
|
|
var item:ItemVo = BagCenter.getIns().getById(itemid);
|
|
gift_para = {
|
|
"mon":mon,
|
|
"item":item,
|
|
"show":show
|
|
};
|
|
NetMonster.getIns().gift(mid,itemid,giftHandler);
|
|
}
|
|
|
|
public function giftHandler(newFeel:int, giftTime:uint, addFeel:int) : void
|
|
{
|
|
var point:int = addFeel;
|
|
var mon:MonsterVo = gift_para.mon;
|
|
mon.feel = newFeel;
|
|
mon.giftTime = giftTime;
|
|
BagCenter.getIns().subNum(gift_para.item.id,1);
|
|
if(gift_para.show)
|
|
{
|
|
if(point > 0)
|
|
{
|
|
Alert.showMsg(gift_para.mon.name + lang("增长了 {0} 好感度!",point));
|
|
}
|
|
else if(point == 0)
|
|
{
|
|
Alert.showMsg(lang("{0}对 {1} 并没有什么兴趣...",gift_para.mon.name,CP.item(gift_para.item.name)));
|
|
}
|
|
else if(point < 0)
|
|
{
|
|
Alert.showMsg(Paster.font(lang("{0}丢掉了 {1} 并露出厌恶的表情...",gift_para.mon.name,CP.item(gift_para.item.name)),null,21));
|
|
}
|
|
}
|
|
gift_para = null;
|
|
if(onGiftComplete != null)
|
|
{
|
|
onGiftComplete(point);
|
|
onGiftComplete = null;
|
|
}
|
|
}
|
|
|
|
public function moveMonFromRoom(monId:Number, roomId:int, onComplete:Function) : void
|
|
{
|
|
onMoveMonFromRoomComplete = onComplete;
|
|
moveMonFromRoom_para = {
|
|
"monId":monId,
|
|
"roomId":roomId
|
|
};
|
|
NetMonster.getIns().moveMonFromRoom(monId,roomId,moveMonFromRoomHandler);
|
|
}
|
|
|
|
private function moveMonFromRoomHandler() : void
|
|
{
|
|
var mon:MonsterVo = getMonById(moveMonFromRoom_para.monId);
|
|
mon.roomId = moveMonFromRoom_para.roomId;
|
|
GlobalBroadcast.dispatchEvent(new MYREvent(MYREvent.MONSTER_CHANGE_ROOM,{"mon":mon}));
|
|
moveMonFromRoom_para = null;
|
|
if(onMoveMonFromRoomComplete != null)
|
|
{
|
|
onMoveMonFromRoomComplete();
|
|
onMoveMonFromRoomComplete = null;
|
|
}
|
|
}
|
|
|
|
public function autoSell(onComplete:Function = null) : Boolean
|
|
{
|
|
var i:int = 0;
|
|
var s:StackVo = null;
|
|
var m:MonsterVo = null;
|
|
var specialmon:Array = Table.monster_setting.AvoidAutoSellMons;
|
|
if(specialmon == null)
|
|
{
|
|
specialmon = [];
|
|
}
|
|
var money:int = 0;
|
|
var monsters:Array = [];
|
|
for(i = 0; i < Master.stacks.length; )
|
|
{
|
|
s = Master.stacks[i];
|
|
m = s.getMon();
|
|
if(!s.isEmpty && m != null && m.mode == 2 && m.process == 2 && m.star <= 2 && !m.lock && !m.sysLock)
|
|
{
|
|
if(specialmon.indexOf(m.type) == -1)
|
|
{
|
|
monsters.push(m);
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
if(monsters.length == 0)
|
|
{
|
|
return false;
|
|
}
|
|
sellMonsters(monsters,onComplete);
|
|
return true;
|
|
}
|
|
|
|
public function sellMonsters(mons:Array, onComplete:Function = null) : void
|
|
{
|
|
var mon:* = null;
|
|
var i:int = 0;
|
|
onSellMonstersComplete = onComplete;
|
|
var monIds:Array = [];
|
|
for(i = 0; i < mons.length; )
|
|
{
|
|
monIds.push(mons[i].id);
|
|
i++;
|
|
}
|
|
onSellMonsters_para = {"mons":mons};
|
|
NetMonster.getIns().sellMonsters(monIds,sellMonstersHandler);
|
|
}
|
|
|
|
private function sellMonstersHandler(sellMoney:int) : void
|
|
{
|
|
MasterCenter.getIns().addMoney(sellMoney,true);
|
|
removeLocalMonsters(onSellMonsters_para.mons);
|
|
onSellMonsters_para = null;
|
|
if(onSellMonstersComplete != null)
|
|
{
|
|
onSellMonstersComplete();
|
|
onSellMonstersComplete = null;
|
|
}
|
|
}
|
|
|
|
public function numStoreMonster() : int
|
|
{
|
|
var num:int = 0;
|
|
for each(var m:MonsterVo in Master.monsters)
|
|
{
|
|
if(m.process == 3)
|
|
{
|
|
num++;
|
|
}
|
|
}
|
|
return num;
|
|
}
|
|
|
|
public function numNewGrowUp() : int
|
|
{
|
|
var i:int = 0;
|
|
for each(var m:MonsterVo in Master.monsters)
|
|
{
|
|
if(m.process == 2 && m.recModeChange && m.mode == 2)
|
|
{
|
|
i++;
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
|
|
public function resetNewGrowUp() : void
|
|
{
|
|
for each(var m:MonsterVo in Master.monsters)
|
|
{
|
|
if(m.process == 2 && m.recModeChange && m.mode == 2)
|
|
{
|
|
m.recModeChange = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
public function getStoreMon(foreTeam:Boolean = true) : Array
|
|
{
|
|
var sm:Array = [];
|
|
for each(var m:MonsterVo in Game.getIns().master.monsters)
|
|
{
|
|
if(m.process == 3)
|
|
{
|
|
sm.push(m);
|
|
}
|
|
}
|
|
if(foreTeam)
|
|
{
|
|
sm.sortOn("inteam",0x10 | 2);
|
|
}
|
|
return sm;
|
|
}
|
|
|
|
public function getExploreMons(level:int, maxLevel:int, exceptMonIds:Array) : Array
|
|
{
|
|
var arr:Array = [];
|
|
for each(var m:MonsterVo in Master.monsters)
|
|
{
|
|
if(m.process == 3 && !m.inExploreTeam && exceptMonIds.indexOf(m.id) == -1 && m.level >= level && m.level <= maxLevel)
|
|
{
|
|
arr.push(m);
|
|
}
|
|
}
|
|
return arr;
|
|
}
|
|
|
|
public function getTeamSelectMonsters(teamName:String, exceptMonsterType:int = 0) : Array
|
|
{
|
|
var typeSelect:Array = null;
|
|
var montype:int = 0;
|
|
var typeSelectBoolean:Boolean = false;
|
|
var arr:Array = [];
|
|
if(Table.team_info.teamMonTypes != null && Table.team_info.teamMonTypes[teamName] != null)
|
|
{
|
|
typeSelect = Table.team_info.teamMonTypes[teamName];
|
|
}
|
|
var teamMonster:Array = [];
|
|
var teamMonsterType:Array = [];
|
|
var curTeam:TeamVo = TeamCenter.getIns().getTeamByTeamName(teamName);
|
|
for each(var monId:Number in curTeam.monsters)
|
|
{
|
|
if(monId > 0)
|
|
{
|
|
teamMonster.push(monId);
|
|
montype = getMonById(monId).type;
|
|
teamMonsterType.push(montype);
|
|
if(Table.setting.linkType != null && exceptMonsterType != montype && Table.setting.linkType[montype] != null)
|
|
{
|
|
teamMonsterType.push(int(Table.setting.linkType[montype]));
|
|
}
|
|
}
|
|
}
|
|
ArrayUtil.remove(teamMonsterType,exceptMonsterType);
|
|
for each(var m:MonsterVo in Master.monsters)
|
|
{
|
|
typeSelectBoolean = true;
|
|
if(typeSelect != null)
|
|
{
|
|
if(typeSelect.indexOf(m.type) == -1)
|
|
{
|
|
typeSelectBoolean = false;
|
|
}
|
|
else
|
|
{
|
|
typeSelectBoolean = true;
|
|
}
|
|
}
|
|
if(typeSelectBoolean && !m.inExploreTeam && m.process == 3 && teamMonster.indexOf(m.id) == -1 && teamMonsterType.indexOf(m.type) == -1)
|
|
{
|
|
arr.push(m);
|
|
}
|
|
}
|
|
return arr;
|
|
}
|
|
|
|
public function getMonById(mid:Number) : MonsterVo
|
|
{
|
|
var i:int = 0;
|
|
var len:int = int(Master.monsters.length);
|
|
for(i = 0; i < len; )
|
|
{
|
|
if(Master.monsters[i].id == mid)
|
|
{
|
|
return Master.monsters[i];
|
|
}
|
|
i++;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public function getMonByIds(mids:Array) : Array
|
|
{
|
|
var i:int = 0;
|
|
var len:int = int(Master.monsters.length);
|
|
var mons:Array = [];
|
|
for(i = 0; i < len; )
|
|
{
|
|
if(mids.indexOf(Master.monsters[i].id) != -1)
|
|
{
|
|
mons.push(Master.monsters[i]);
|
|
}
|
|
i++;
|
|
}
|
|
return mons;
|
|
}
|
|
|
|
public function getMons(mode:int = -1, process:int = -1) : Array
|
|
{
|
|
var i:int = 0;
|
|
var arr:Array = [];
|
|
var len:int = int(Master.monsters.length);
|
|
for(i = 0; i < len; )
|
|
{
|
|
if((mode == -1 || Master.monsters[i].mode == mode) && (process == -1 || Master.monsters[i].process == process))
|
|
{
|
|
arr.push(Master.monsters[i]);
|
|
}
|
|
i++;
|
|
}
|
|
return arr;
|
|
}
|
|
|
|
public function getBattleGroundMonsters(teamName:String = "") : Array
|
|
{
|
|
var i:int = 0;
|
|
var m:MonsterVo = null;
|
|
var mons:Array = [];
|
|
var teamVo:TeamVo = TeamCenter.getIns().getTeamByTeamName(teamName);
|
|
for(i = 0; i < teamVo.monsters.length; )
|
|
{
|
|
if(teamVo.monsters[i] > 0)
|
|
{
|
|
m = MonsterCenter.getIns().getMonById(teamVo.monsters[i]);
|
|
mons.push(m);
|
|
}
|
|
i++;
|
|
}
|
|
return mons;
|
|
}
|
|
|
|
public function gacha(type:String) : EggVo
|
|
{
|
|
var mon:* = null;
|
|
var machine:Object = Table.gacha_machine[type];
|
|
var eggdata:Object = Random.elementWithChance(machine.eggs,"value");
|
|
var egg:EggVo = new EggVo();
|
|
egg.type = eggdata.type;
|
|
return egg;
|
|
}
|
|
|
|
public function getFeeds(exceptId:Number) : Array
|
|
{
|
|
var i:int = 0;
|
|
var mon:MonsterVo = null;
|
|
var feeds:Array = [];
|
|
var len:int = int(Master.monsters.length);
|
|
var monIdInTeam:Array = TeamCenter.getIns().getAllTeamMonsterId();
|
|
for(i = 0; i < len; )
|
|
{
|
|
mon = Master.monsters[i];
|
|
if(!mon.inExploreTeam && mon.id != exceptId && !mon.isLock() && !mon.sysLock && mon.mode == 2 && monIdInTeam.indexOf(mon.id) == -1)
|
|
{
|
|
feeds.push(mon);
|
|
}
|
|
i++;
|
|
}
|
|
return feeds;
|
|
}
|
|
|
|
public function getLocalMonster(mon:MonsterVo) : void
|
|
{
|
|
Master.monsters.push(mon);
|
|
mon.recNewGet = true;
|
|
if(mon.mode == 2)
|
|
{
|
|
checkLocalNewLibMon(mon);
|
|
}
|
|
TaskCenter.getIns().activityMonsterNum(mon.type);
|
|
}
|
|
|
|
private function checkLocalNewLibMon(mon:MonsterVo) : void
|
|
{
|
|
if(!LibCenter.getIns().checkUnlock(mon.type))
|
|
{
|
|
LibCenter.getIns().unlockLib(mon.type,true);
|
|
AchiCenter.getIns().autoCheck(AchiType.COLLECTION);
|
|
}
|
|
}
|
|
|
|
public function secondHandler(checkLevelUp:Boolean = true) : void
|
|
{
|
|
var i:int = 0;
|
|
var vo:MonsterVo = null;
|
|
var len:int = int(Master.monsters.length);
|
|
var growupMon:Array = [];
|
|
for(i = 0; i < len; )
|
|
{
|
|
vo = Master.monsters[i];
|
|
if(vo.process == 2 && vo.mode != vo.checkMode())
|
|
{
|
|
growupMon.push(vo);
|
|
}
|
|
i++;
|
|
}
|
|
if(growupMon.length > 0)
|
|
{
|
|
checkGrowUp(growupMon,checkLevelUp);
|
|
}
|
|
}
|
|
|
|
public function checkGrowUp(mons:Array, checkLevelUp:Boolean = true, onComplete:Function = null) : void
|
|
{
|
|
onCheckGrowUpComplete = onComplete;
|
|
pauseSecondListener();
|
|
checkGrowUp_para = {"checkLevelUp":checkLevelUp};
|
|
NetStack.getIns().checkGrowth(checkGrowUpHandler);
|
|
}
|
|
|
|
private function checkGrowUpHandler(datas:Array, stackMonsterInfos:Array, allExp:int) : void
|
|
{
|
|
var j:int = 0;
|
|
var i:int = 0;
|
|
var newMode:Object = null;
|
|
var vo:MonsterVo = null;
|
|
var has4c:Boolean = false;
|
|
var paradic:Object = {};
|
|
if(stackMonsterInfos != null)
|
|
{
|
|
for(j = 0; j < stackMonsterInfos.length; )
|
|
{
|
|
paradic[stackMonsterInfos[j].monsterId] = stackMonsterInfos[j];
|
|
j++;
|
|
}
|
|
}
|
|
for(i = 0; i < datas.length; )
|
|
{
|
|
newMode = datas[i];
|
|
vo = getMonById(newMode.monsterId);
|
|
vo.preMode = vo.mode;
|
|
vo.mode = newMode.mode;
|
|
vo.recModeChange = true;
|
|
if(vo.mode == 2)
|
|
{
|
|
if(paradic[vo.id] != null)
|
|
{
|
|
vo.g_atk.val = paradic[vo.id].gAtk;
|
|
vo.g_def.val = paradic[vo.id].gDef;
|
|
vo.g_hp.val = paradic[vo.id].gHp;
|
|
vo.g_dex.val = paradic[vo.id].gDex;
|
|
}
|
|
vo.buildQuality();
|
|
}
|
|
GlobalBroadcast.dispatchEvent(new PiEvent(MYREvent.MONSTER_MODE_CHANGE,vo));
|
|
if(vo.mode == 2)
|
|
{
|
|
checkLocalNewLibMon(vo);
|
|
if(Master.history.numFeedMonsters[vo.type] == null)
|
|
{
|
|
Master.history.numFeedMonsters[vo.type] = 1;
|
|
}
|
|
else
|
|
{
|
|
Master.history.numFeedMonsters[vo.type]++;
|
|
}
|
|
}
|
|
TaskCenter.getIns().activityMonsterNum(vo.type);
|
|
i++;
|
|
}
|
|
AchiCenter.getIns().autoCheck(AchiType.FEED);
|
|
if(allExp > 0)
|
|
{
|
|
MasterCenter.getIns().addExp(allExp,true);
|
|
if(checkGrowUp_para.checkLevelUp)
|
|
{
|
|
MasterCenter.getIns().autoCheckLevelUp();
|
|
}
|
|
}
|
|
if(onCheckGrowUpComplete != null)
|
|
{
|
|
onCheckGrowUpComplete();
|
|
onCheckGrowUpComplete = null;
|
|
}
|
|
checkGrowUp_para = null;
|
|
Caller.delayCall(startSecondListener,100);
|
|
}
|
|
|
|
public function taskHasMonster(type:int, mode:int = -1) : Array
|
|
{
|
|
var m:MonsterVo = null;
|
|
var i:int = 0;
|
|
var arr:Array = [];
|
|
var len:int = int(Master.monsters.length);
|
|
for(i = 0; i < len; )
|
|
{
|
|
m = Master.monsters[i];
|
|
if(m.type == type)
|
|
{
|
|
if(m.canRemove())
|
|
{
|
|
if(m.level <= 1)
|
|
{
|
|
if(mode == 0)
|
|
{
|
|
if(m.process == 1 && m.mode == mode && !m.isLock())
|
|
{
|
|
arr.push(m);
|
|
}
|
|
}
|
|
else if(mode == 2)
|
|
{
|
|
if(m.process >= 2 && m.type == type && m.mode == mode)
|
|
{
|
|
arr.push(m);
|
|
}
|
|
}
|
|
else if(mode == -1)
|
|
{
|
|
if(!m.isLock() && !m.inExploreTeam)
|
|
{
|
|
arr.push(m);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
return arr;
|
|
}
|
|
|
|
public function taskHasEggNum(type:int) : int
|
|
{
|
|
return BagCenter.getIns().getNum(type);
|
|
}
|
|
|
|
public function switchGrowth(mid1:Number, mid2:Number, onComplete:Function) : void
|
|
{
|
|
onSwitchGrowthComplete = onComplete;
|
|
var mon1:MonsterVo = getMonById(mid1);
|
|
var mon2:MonsterVo = getMonById(mid2);
|
|
switchGrowth_para = {
|
|
"mon1":mon1,
|
|
"mon2":mon2
|
|
};
|
|
NetMonster.getIns().switchGrowth(mid1,mid2,switchGrowthHandler);
|
|
}
|
|
|
|
private function switchGrowthHandler() : void
|
|
{
|
|
var o:Object = {};
|
|
var mon1:MonsterVo = switchGrowth_para.mon1;
|
|
var mon2:MonsterVo = switchGrowth_para.mon2;
|
|
o.g_atk = mon1.g_atk;
|
|
o.g_def = mon1.g_def;
|
|
o.g_hp = mon1.g_hp;
|
|
o.g_dex = mon1.g_dex;
|
|
mon1.g_atk = mon2.g_atk;
|
|
mon1.g_def = mon2.g_def;
|
|
mon1.g_hp = mon2.g_hp;
|
|
mon1.g_dex = mon2.g_dex;
|
|
mon2.g_atk = o.g_atk;
|
|
mon2.g_def = o.g_def;
|
|
mon2.g_hp = o.g_hp;
|
|
mon2.g_dex = o.g_dex;
|
|
mon1.buildQuality();
|
|
mon2.buildQuality();
|
|
MasterCenter.getIns().addMoney(-GameMath.getSwitchMoney(mon1.star),false);
|
|
if(onSwitchGrowthComplete != null)
|
|
{
|
|
onSwitchGrowthComplete();
|
|
onSwitchGrowthComplete = null;
|
|
}
|
|
switchGrowth_para = null;
|
|
}
|
|
|
|
public function equipOn(mid:Number, equipid:Number) : void
|
|
{
|
|
var monvo:MonsterVo = getMonById(mid);
|
|
var equipvo:EquipVo = BagCenter.getIns().getById(equipid) as EquipVo;
|
|
equipvo.hideo = false;
|
|
equipOn_para = {
|
|
"equipvo":equipvo,
|
|
"monvo":monvo,
|
|
"part":equipvo.part
|
|
};
|
|
NetEquip.getIns().equipOn(mid,equipid,euipOnHandler);
|
|
}
|
|
|
|
private function euipOnHandler(monAdd:Object) : void
|
|
{
|
|
var pullOffEquip:EquipVo = null;
|
|
var ornamentChange:Boolean = false;
|
|
if(equipOn_para.monvo["equip" + equipOn_para.equipvo.part] > 0)
|
|
{
|
|
pullOffEquip = BagCenter.getIns().getById(equipOn_para.monvo["equip" + equipOn_para.equipvo.part]) as EquipVo;
|
|
pullOffEquip.isUsed = false;
|
|
if(pullOffEquip.position.position > 0 || pullOffEquip.effectMovs.length > 0)
|
|
{
|
|
ornamentChange = true;
|
|
}
|
|
}
|
|
equipOn_para.monvo["equip" + equipOn_para.equipvo.part] = equipOn_para.equipvo.id;
|
|
equipOn_para.equipvo.isUsed = true;
|
|
if(equipOn_para.equipvo.position.position > 0 || equipOn_para.equipvo.effectMovs.length > 0)
|
|
{
|
|
ornamentChange = true;
|
|
}
|
|
(equipOn_para.monvo as MonsterVo).abilityAdd.update(monAdd);
|
|
if(onEquipOnComplete != null)
|
|
{
|
|
onEquipOnComplete();
|
|
onEquipOnComplete = null;
|
|
}
|
|
GlobalBroadcast.dispatchEvent(new MYREvent(MYREvent.MONSTER_EQUIP_CHANGE,{
|
|
"part":equipOn_para.part,
|
|
"ornamentChange":ornamentChange,
|
|
"mon":equipOn_para.monvo
|
|
}));
|
|
equipOn_para = null;
|
|
}
|
|
|
|
public function equipOff(mid:Number, part:int) : void
|
|
{
|
|
var monvo:MonsterVo = getMonById(mid);
|
|
equipOff_para = {
|
|
"monvo":monvo,
|
|
"part":part
|
|
};
|
|
NetEquip.getIns().equipOff(monvo.id,part,equipOffHandler);
|
|
}
|
|
|
|
private function equipOffHandler(monAdd:Object) : void
|
|
{
|
|
var equipvo:EquipVo = null;
|
|
equipvo = BagCenter.getIns().getById(equipOff_para.monvo["equip" + equipOff_para.part]) as EquipVo;
|
|
equipvo.isUsed = false;
|
|
equipOff_para.monvo["equip" + equipOff_para.part] = 0;
|
|
(equipOff_para.monvo as MonsterVo).abilityAdd.update(monAdd);
|
|
var ornamentChange:Boolean = false;
|
|
if(equipvo.position.position > 0 || equipvo.effectMovs.length > 0)
|
|
{
|
|
ornamentChange = true;
|
|
}
|
|
if(onEquipOffComplete != null)
|
|
{
|
|
onEquipOffComplete();
|
|
onEquipOffComplete = null;
|
|
}
|
|
GlobalBroadcast.dispatchEvent(new MYREvent(MYREvent.MONSTER_EQUIP_CHANGE,{
|
|
"mon":equipOff_para.monvo,
|
|
"part":equipOff_para.part,
|
|
"ornamentChange":ornamentChange
|
|
}));
|
|
equipOff_para = null;
|
|
}
|
|
|
|
public function addPotential(monId:Number, addType:String = "atk", onComplete:Function = null) : void
|
|
{
|
|
onAddPotentialComplete = onComplete;
|
|
var mon:MonsterVo = getMonById(monId);
|
|
var itemVo:ItemVo = BagCenter.getIns().getByType(Table.potential_info.potentialElementItem[mon.element]);
|
|
NetMonster.getIns().addPotential(monId,itemVo.id,addType,addPotentialHandler);
|
|
}
|
|
|
|
private function addPotentialHandler(re:Object) : void
|
|
{
|
|
if(onAddPotentialComplete != null)
|
|
{
|
|
onAddPotentialComplete();
|
|
onAddPotentialComplete = null;
|
|
}
|
|
}
|
|
|
|
public function upStar(monVo:MonsterVo, onComplete:Function = null) : void
|
|
{
|
|
onUpStarComplete = onComplete;
|
|
onUpStar_mon = monVo;
|
|
var targetStar:int = monVo.upStar + 1;
|
|
if(monVo.upStartTask == null || monVo.upStartTask[targetStar] == null)
|
|
{
|
|
trace("不存在");
|
|
return;
|
|
}
|
|
if(Master.history.passTask[monVo.upStartTask[targetStar]] == null)
|
|
{
|
|
trace("未完成对应任务");
|
|
return;
|
|
}
|
|
NetMonster.getIns().upStar(monVo.id,upStarHandler);
|
|
}
|
|
|
|
private function upStarHandler(re:Object) : void
|
|
{
|
|
onUpStar_mon.upStar += 1;
|
|
GlobalBroadcast.dispatchEvent(new MYREvent(MYREvent.MONSTER_NUM_CHANGE,{"mon":onUpStar_mon}));
|
|
if(onUpStarComplete != null)
|
|
{
|
|
onUpStarComplete(re);
|
|
onUpStarComplete = null;
|
|
}
|
|
}
|
|
|
|
public function countAndGetNewMid() : int
|
|
{
|
|
return 1000000 + Master.history.countMonster++;
|
|
}
|
|
|
|
public function getEntangleMonByType(montype:int) : MonsterVo
|
|
{
|
|
for each(var mon:MonsterVo in Master.monsters)
|
|
{
|
|
if(mon.entangle && mon.type == montype)
|
|
{
|
|
return mon;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public function getAiByAiType(aiType:int) : int
|
|
{
|
|
if(aiType == 0)
|
|
{
|
|
return 4;
|
|
}
|
|
return 4;
|
|
}
|
|
|
|
public function getAiSearchByAiType(aiType:int) : int
|
|
{
|
|
if(aiType == 0)
|
|
{
|
|
return 4;
|
|
}
|
|
return 4;
|
|
}
|
|
}
|
|
}
|
|
|