480 lines
14 KiB
ActionScript
480 lines
14 KiB
ActionScript
package net.pixvi.myr.center
|
|
{
|
|
import net.pixvi.myr.GameMath;
|
|
import net.pixvi.myr.element.bag.ItemVo;
|
|
import net.pixvi.myr.element.mon.EggVo;
|
|
import net.pixvi.myr.element.mon.MonsterVo;
|
|
import net.pixvi.myr.element.stack.StackOpenType;
|
|
import net.pixvi.myr.element.stack.StackVo;
|
|
import net.pixvi.myr.event.MYREvent;
|
|
import net.pixvi.myr.net.NetStack;
|
|
import net.pixvi.pfw.utils.broadcast.GlobalBroadcast;
|
|
import net.pixvi.pfw.utils.core.Singleton;
|
|
|
|
public class StackCenter
|
|
{
|
|
|
|
private var onAddQuality:Function;
|
|
|
|
private var addQuality_buffStackId:Number;
|
|
|
|
private var addQuality_buffAddPara:String;
|
|
|
|
private var speedEgg_para:Object;
|
|
|
|
private var onSpeedEggComplete:Function;
|
|
|
|
private var onBuyStackComplete:Function;
|
|
|
|
private var buyStack_para:Object;
|
|
|
|
private var onBuyKeStackComplete:Function;
|
|
|
|
private var buyKeStack_para:Object;
|
|
|
|
private var fillEggsToStack_para:Object;
|
|
|
|
private var onFillEggsToStackComplete:Function;
|
|
|
|
private var autoFilling:Boolean = false;
|
|
|
|
private var onAutoFillEggToStackComplete:Function;
|
|
|
|
private var onMoveMonsToRoomComplete:Function;
|
|
|
|
private var moveMonsToRoom_datas:Object;
|
|
|
|
public function StackCenter()
|
|
{
|
|
super();
|
|
}
|
|
|
|
public static function getIns() : StackCenter
|
|
{
|
|
return Singleton.getInstanceOrCreate(StackCenter) as StackCenter;
|
|
}
|
|
|
|
public static function getStackByStackData(stackData:Object) : StackVo
|
|
{
|
|
var stack:StackVo = new StackVo();
|
|
stack.id = stackData.id;
|
|
stack.position = stackData.position;
|
|
stack.openType = stackData.openType;
|
|
stack.monsterId = stackData.monsterId;
|
|
stack.hpNum = stackData.hpNum;
|
|
stack.atkNum = stackData.atkNum;
|
|
stack.defNum = stackData.defNum;
|
|
stack.dexNum = stackData.dexNum;
|
|
return stack;
|
|
}
|
|
|
|
public function addQuality(stackId:Number, addPara:String, onComplete:Function) : void
|
|
{
|
|
onAddQuality = onComplete;
|
|
addQuality_buffStackId = stackId;
|
|
addQuality_buffAddPara = addPara;
|
|
NetStack.getIns().addQuality(stackId,addPara,addQualityHandler);
|
|
}
|
|
|
|
private function addQualityHandler(re:Object) : void
|
|
{
|
|
var addStack:StackVo = getStackById(addQuality_buffStackId);
|
|
BagCenter.getIns().subNumByType(addStack.getMon().getJxhItemType(),1);
|
|
addStack[addQuality_buffAddPara + "Num"]++;
|
|
if(onAddQuality != null)
|
|
{
|
|
onAddQuality(re);
|
|
onAddQuality = null;
|
|
}
|
|
}
|
|
|
|
public function speedEgg(mid:Number, itemNum:int, onComplete:Function) : void
|
|
{
|
|
onSpeedEggComplete = onComplete;
|
|
var vo:MonsterVo = MonsterCenter.getIns().getMonById(mid);
|
|
speedEgg_para = {
|
|
"mon":vo,
|
|
"num":itemNum
|
|
};
|
|
NetStack.getIns().speedMonsters(mid,itemNum,speedEggHandler);
|
|
}
|
|
|
|
private function speedEggHandler(newStartTime:uint) : void
|
|
{
|
|
speedEgg_para.mon.timeStart = newStartTime;
|
|
var itemvo:ItemVo = BagCenter.getIns().getByType(GameMath.speedItemId);
|
|
BagCenter.getIns().subNum(itemvo.id,speedEgg_para.num,true);
|
|
if(onSpeedEggComplete != null)
|
|
{
|
|
onSpeedEggComplete();
|
|
onSpeedEggComplete = null;
|
|
}
|
|
}
|
|
|
|
public function countEmptyStack() : int
|
|
{
|
|
var i:int = 0;
|
|
for each(var s:StackVo in Master.stacks)
|
|
{
|
|
if(s.isEmpty)
|
|
{
|
|
i++;
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
|
|
public function buyStack(position:int, onComplete:Function) : void
|
|
{
|
|
onBuyStackComplete = onComplete;
|
|
var val:Object = Table.stack_price[Master.history.numAddStack];
|
|
buyStack_para = {"money":val.money};
|
|
NetStack.getIns().addStack(StackOpenType.GOLD,position,buyStackHandler);
|
|
}
|
|
|
|
private function buyStackHandler(reStackData:Object) : void
|
|
{
|
|
var stackvo:StackVo = StackCenter.getStackByStackData(reStackData);
|
|
addStack(stackvo);
|
|
MasterCenter.getIns().addMoney(-buyStack_para.money,true);
|
|
GlobalBroadcast.dispatchEvent(new MYREvent(MYREvent.STACK_ADD,stackvo));
|
|
if(onBuyStackComplete != null)
|
|
{
|
|
onBuyStackComplete();
|
|
onBuyStackComplete = null;
|
|
buyStack_para = null;
|
|
}
|
|
}
|
|
|
|
public function buyKeStack(position:int, onComplet:Function) : void
|
|
{
|
|
onBuyKeStackComplete = onComplet;
|
|
var val:Object = Table.stack_price[Master.history.numKeAddStack];
|
|
buyKeStack_para = {"ke":val.ke};
|
|
NetStack.getIns().addStack(StackOpenType.KE,position,buyKeStackHandler);
|
|
}
|
|
|
|
private function buyKeStackHandler(reStackData:Object) : void
|
|
{
|
|
var stackvo:StackVo = StackCenter.getStackByStackData(reStackData);
|
|
addStack(stackvo);
|
|
MasterCenter.getIns().addKe(-buyKeStack_para.ke,true);
|
|
GlobalBroadcast.dispatchEvent(new MYREvent(MYREvent.STACK_ADD,stackvo));
|
|
if(onBuyKeStackComplete != null)
|
|
{
|
|
onBuyKeStackComplete();
|
|
onBuyKeStackComplete = null;
|
|
buyKeStack_para = null;
|
|
}
|
|
}
|
|
|
|
public function getStackByMonster(mid:Number) : StackVo
|
|
{
|
|
for each(var s:StackVo in Master.stacks)
|
|
{
|
|
if(s.monsterId == mid)
|
|
{
|
|
return s;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public function addStack(stackvo:StackVo) : StackVo
|
|
{
|
|
Master.stacks.push(stackvo);
|
|
return stackvo;
|
|
}
|
|
|
|
public function fillEggsToStack(pushs:Array, sendEvent:Boolean = true, onComplete:Function = null) : void
|
|
{
|
|
onFillEggsToStackComplete = onComplete;
|
|
fillEggsToStack_para = {
|
|
"sendEvent":sendEvent,
|
|
"pushs":pushs
|
|
};
|
|
NetStack.getIns().pushEgg(pushs,fillEggsToStackHandler);
|
|
}
|
|
|
|
private function fillEggsToStackHandler(gets:Array) : void
|
|
{
|
|
var i:int = 0;
|
|
var stackId:int = 0;
|
|
var monster:MonsterVo = null;
|
|
var j:int = 0;
|
|
var push:Object = null;
|
|
for(i = 0; i < gets.length; )
|
|
{
|
|
stackId = int(gets[i].stackId);
|
|
monster = MonsterCenter.getMonByMonData(gets[i].monster);
|
|
getStackById(stackId).monsterId = monster.id;
|
|
MonsterCenter.getIns().getLocalMonster(monster);
|
|
if(fillEggsToStack_para.sendEvent)
|
|
{
|
|
GlobalBroadcast.dispatchEvent(new MYREvent(MYREvent.MONSTER_ADD_STACK,monster));
|
|
}
|
|
i++;
|
|
}
|
|
for(j = 0; j < fillEggsToStack_para.pushs.length; )
|
|
{
|
|
push = fillEggsToStack_para.pushs[j];
|
|
BagCenter.getIns().subNum(push.itemId,1);
|
|
j++;
|
|
}
|
|
fillEggsToStack_para = null;
|
|
if(onFillEggsToStackComplete != null)
|
|
{
|
|
onFillEggsToStackComplete();
|
|
onFillEggsToStackComplete = null;
|
|
}
|
|
}
|
|
|
|
public function autoFillEggToStack(mode:int = 1, onComplete:Function = null, eggvo:EggVo = null) : int
|
|
{
|
|
var eggs:Array = null;
|
|
var k:int = 0;
|
|
var eg:EggVo = null;
|
|
var eggnum:int = 0;
|
|
var j:int = 0;
|
|
var count:int = 0;
|
|
var pushs:Array = null;
|
|
var numcountDic:Object = null;
|
|
var eggflag:int = 0;
|
|
var i:int = 0;
|
|
onAutoFillEggToStackComplete = onComplete;
|
|
if(autoFilling == false)
|
|
{
|
|
autoFilling = true;
|
|
var emptyStack:Array = [];
|
|
var isVip:Boolean = MasterCenter.getIns().getVipDay() > 0;
|
|
for each(var s:StackVo in Master.stacks)
|
|
{
|
|
if(!(!isVip && s.position == 3))
|
|
{
|
|
if(s.isEmpty)
|
|
{
|
|
emptyStack.push(s);
|
|
}
|
|
}
|
|
}
|
|
if(emptyStack.length > 0)
|
|
{
|
|
if(eggvo == null)
|
|
{
|
|
eggs = getAutoFillEggs(mode);
|
|
}
|
|
else
|
|
{
|
|
eggs = [eggvo];
|
|
}
|
|
k = 0;
|
|
while(k < eggs.length)
|
|
{
|
|
eg = eggs[k];
|
|
if(eg.feedLock)
|
|
{
|
|
eggs.splice(k,1);
|
|
k--;
|
|
}
|
|
k++;
|
|
}
|
|
eggnum = 0;
|
|
for(j = 0; j < eggs.length; )
|
|
{
|
|
eggnum += eggs[j].num;
|
|
j++;
|
|
}
|
|
count = Math.min(eggnum,emptyStack.length);
|
|
if(count == 0)
|
|
{
|
|
autoFilling = false;
|
|
return 0;
|
|
}
|
|
pushs = [];
|
|
numcountDic = {};
|
|
eggflag = 0;
|
|
for(i = 0; i < count; )
|
|
{
|
|
if(numcountDic[eggs[eggflag].id] != null && numcountDic[eggs[eggflag].id] >= eggs[eggflag].num)
|
|
{
|
|
eggflag++;
|
|
}
|
|
pushs.push({
|
|
"itemId":eggs[eggflag].id,
|
|
"stackId":emptyStack[i].id
|
|
});
|
|
if(numcountDic[eggs[eggflag].id] == null)
|
|
{
|
|
numcountDic[eggs[eggflag].id] = 1;
|
|
}
|
|
else
|
|
{
|
|
numcountDic[eggs[eggflag].id]++;
|
|
}
|
|
i++;
|
|
}
|
|
fillEggsToStack(pushs,true,autoFillEggToStackHandler);
|
|
return count;
|
|
}
|
|
autoFilling = false;
|
|
return 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
private function autoFillEggToStackHandler() : void
|
|
{
|
|
autoFilling = false;
|
|
if(onAutoFillEggToStackComplete != null)
|
|
{
|
|
onAutoFillEggToStackComplete();
|
|
onAutoFillEggToStackComplete = null;
|
|
}
|
|
}
|
|
|
|
public function moveMonsToRoom(datas:Array, onComplete:Function) : void
|
|
{
|
|
onMoveMonsToRoomComplete = onComplete;
|
|
moveMonsToRoom_datas = datas;
|
|
NetStack.getIns().moveMonster(datas,moveMonsToRoomHandler);
|
|
}
|
|
|
|
private function moveMonsToRoomHandler() : void
|
|
{
|
|
var j:int = 0;
|
|
var movedata:Object = null;
|
|
var mids:Array = null;
|
|
var roomId:int = 0;
|
|
var i:int = 0;
|
|
var mon:MonsterVo = null;
|
|
for(j = 0; j < moveMonsToRoom_datas.length; )
|
|
{
|
|
movedata = moveMonsToRoom_datas[j];
|
|
mids = movedata.monsterId;
|
|
roomId = int(movedata.roomId);
|
|
for each(var stackvo:StackVo in Master.stacks)
|
|
{
|
|
if(stackvo.monsterId != 0 && mids.indexOf(stackvo.monsterId) != -1)
|
|
{
|
|
stackvo.monsterId = 0;
|
|
stackvo.atkNum = 0;
|
|
stackvo.defNum = 0;
|
|
stackvo.hpNum = 0;
|
|
stackvo.dexNum = 0;
|
|
}
|
|
}
|
|
for(i = 0; i < mids.length; )
|
|
{
|
|
mon = MonsterCenter.getIns().getMonById(mids[i]);
|
|
mon.roomId = roomId;
|
|
mon.process = 3;
|
|
GlobalBroadcast.dispatchEvent(new MYREvent(MYREvent.MONSTER_REMOVE_STACK,{
|
|
"mon":mon,
|
|
"type":"moveroom"
|
|
}));
|
|
i++;
|
|
}
|
|
j++;
|
|
}
|
|
moveMonsToRoom_datas = null;
|
|
if(onMoveMonsToRoomComplete != null)
|
|
{
|
|
onMoveMonsToRoomComplete();
|
|
onMoveMonsToRoomComplete = null;
|
|
}
|
|
}
|
|
|
|
private function getAutoFillEggs(mode:int = 1) : Array
|
|
{
|
|
var eggs:Array = Master.bag.getEggArr();
|
|
switch(mode)
|
|
{
|
|
case 0:
|
|
eggs.sortOn("timeGet",0x10 | 2);
|
|
break;
|
|
case 1:
|
|
eggs.sortOn("timeTotal",16);
|
|
break;
|
|
case 2:
|
|
eggs.sortOn("timeTotal",0x10 | 2);
|
|
break;
|
|
case 3:
|
|
eggs.sortOn("star",0x10 | 2);
|
|
}
|
|
return eggs;
|
|
}
|
|
|
|
public function getMonsterCanFromStack() : Array
|
|
{
|
|
var mon:MonsterVo = null;
|
|
var mons:Array = [];
|
|
for each(var s:StackVo in Master.stacks)
|
|
{
|
|
if(!s.isEmpty)
|
|
{
|
|
mon = s.getMon();
|
|
if(mon.mode == 2)
|
|
{
|
|
mons.push(mon);
|
|
}
|
|
}
|
|
}
|
|
return mons;
|
|
}
|
|
|
|
public function getNewStackId() : int
|
|
{
|
|
return Game.getIns().master.stacks.length + 1;
|
|
}
|
|
|
|
public function getStackById(sid:int) : StackVo
|
|
{
|
|
var i:int = 0;
|
|
for(i = 0; i < Master.stacks.length; )
|
|
{
|
|
if(Master.stacks[i].id == sid)
|
|
{
|
|
return Master.stacks[i];
|
|
}
|
|
i++;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public function getStackMonsters() : Array
|
|
{
|
|
var arr:Array = [];
|
|
for each(var s:StackVo in Master.stacks)
|
|
{
|
|
if(s.monsterId > 0)
|
|
{
|
|
arr.push(MonsterCenter.getIns().getMonById(s.monsterId));
|
|
}
|
|
}
|
|
return arr;
|
|
}
|
|
|
|
public function cleanLocalStackByMonId(mid:Number) : void
|
|
{
|
|
var mon:MonsterVo = null;
|
|
for each(var s:StackVo in Master.stacks)
|
|
{
|
|
mon = s.getMon();
|
|
if(s.monsterId == mid)
|
|
{
|
|
s.monsterId = 0;
|
|
s.atkNum = 0;
|
|
s.defNum = 0;
|
|
s.hpNum = 0;
|
|
s.dexNum = 0;
|
|
GlobalBroadcast.dispatchEvent(new MYREvent(MYREvent.MONSTER_REMOVE_STACK,{
|
|
"mon":mon,
|
|
"type":"task"
|
|
}));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|