300 lines
9.2 KiB
ActionScript
300 lines
9.2 KiB
ActionScript
package net.pixvi.myr.center
|
|
{
|
|
import net.pixvi.myr.GameMath;
|
|
import net.pixvi.myr.element.alchemy.AlchemyStackVo;
|
|
import net.pixvi.myr.element.bag.BuildMaterialVo;
|
|
import net.pixvi.myr.element.bag.EquipBuildVo;
|
|
import net.pixvi.myr.element.bag.EquipVo;
|
|
import net.pixvi.myr.element.bag.ItemVo;
|
|
import net.pixvi.myr.net.NetAlchemy;
|
|
import net.pixvi.pfw.utils.core.Singleton;
|
|
import net.pixvi.pfw.utils.json.Json;
|
|
|
|
public class AlchemyCenter extends Singleton
|
|
{
|
|
|
|
public static var alchemySpeedTime:int = 1800;
|
|
|
|
private var startAlchemy_para:Object;
|
|
|
|
private var onStartAlchemyComplete:Function;
|
|
|
|
private var onOverAlchemyComplete:Function;
|
|
|
|
private var overAlchemy_para:AlchemyStackVo;
|
|
|
|
private var onSpeedAlchemyComplete:Function;
|
|
|
|
private var speedAlchemy_para:Object;
|
|
|
|
private var onAddAlchemyStackComplete:Function;
|
|
|
|
public function AlchemyCenter()
|
|
{
|
|
super();
|
|
}
|
|
|
|
public static function getIns() : AlchemyCenter
|
|
{
|
|
return Singleton.getInstanceOrCreate(AlchemyCenter) as AlchemyCenter;
|
|
}
|
|
|
|
public static function getAlchemyStackByAlchemyStackData(alchemyStackData:Object) : AlchemyStackVo
|
|
{
|
|
var asvo:AlchemyStackVo = new AlchemyStackVo();
|
|
asvo.id = alchemyStackData.id;
|
|
asvo.starting = alchemyStackData.starting == 1;
|
|
asvo.endTime = alchemyStackData.endTime / 1000;
|
|
if(!asvo.starting || alchemyStackData.itemTypes == null || alchemyStackData.itemTypes == "")
|
|
{
|
|
asvo.itemTypes = [];
|
|
}
|
|
else
|
|
{
|
|
asvo.itemTypes = Json.decode(alchemyStackData.itemTypes.toString()) as Array;
|
|
}
|
|
return asvo;
|
|
}
|
|
|
|
public function startAlchemy(stackId:int, types:Array, items:Array, onComplete:Function) : void
|
|
{
|
|
onStartAlchemyComplete = onComplete;
|
|
var materialDic:Object = {};
|
|
var materialArr:Array = [];
|
|
var level:int = getFormulaLevel(types);
|
|
var cost:int = int(GameMath.alchemyFormulaCost[level].cost);
|
|
for each(var item:ItemVo in items)
|
|
{
|
|
if(materialDic[item.id] == null)
|
|
{
|
|
materialDic[item.id] = {
|
|
"itemId":item.id,
|
|
"num":1
|
|
};
|
|
}
|
|
else
|
|
{
|
|
materialDic[item.id].num++;
|
|
}
|
|
}
|
|
for each(var io:Object in materialDic)
|
|
{
|
|
materialArr.push(io);
|
|
}
|
|
startAlchemy_para = {
|
|
"cost":cost,
|
|
"items":materialArr,
|
|
"types":types,
|
|
"stackId":stackId
|
|
};
|
|
NetAlchemy.getIns().startAlchemy(stackId,materialArr,startAlchemyHandler);
|
|
}
|
|
|
|
private function startAlchemyHandler(endTime:int, moneyCost:int) : void
|
|
{
|
|
MasterCenter.getIns().addMoney(-moneyCost,true);
|
|
for each(var item:Object in startAlchemy_para.items)
|
|
{
|
|
BagCenter.getIns().subNum(item.itemId,item.num);
|
|
}
|
|
var stackvo:AlchemyStackVo = getAlchemyStackVoById(startAlchemy_para.stackId);
|
|
stackvo.itemTypes = startAlchemy_para.types;
|
|
stackvo.starting = true;
|
|
stackvo.endTime = endTime;
|
|
if(onStartAlchemyComplete != null)
|
|
{
|
|
onStartAlchemyComplete();
|
|
onStartAlchemyComplete = null;
|
|
}
|
|
}
|
|
|
|
public function checkAlchemyFormula(types:Array) : Boolean
|
|
{
|
|
var exp:EquipBuildVo = null;
|
|
var ivo:ItemVo = null;
|
|
var i:int = 0;
|
|
var exps:Array = [];
|
|
var items:Array = [];
|
|
for each(i in types)
|
|
{
|
|
ivo = new ItemVo();
|
|
ivo.num = 1;
|
|
ivo.type = i;
|
|
items.push(ivo);
|
|
}
|
|
var buildMaterialVo:BuildMaterialVo = new BuildMaterialVo();
|
|
buildMaterialVo.buildByItemVoArr(items);
|
|
for(i = 0; i < Table.equipbuild_list.length; )
|
|
{
|
|
exp = Table.equipbuild_list[i];
|
|
if(exp.check(buildMaterialVo))
|
|
{
|
|
return true;
|
|
}
|
|
i++;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public function overAlchemy(alchemyStackId:int, onComplete:Function) : void
|
|
{
|
|
onOverAlchemyComplete = onComplete;
|
|
var alchemyStack:AlchemyStackVo = getAlchemyStackVoById(alchemyStackId);
|
|
overAlchemy_para = alchemyStack;
|
|
NetAlchemy.getIns().finishAlchemy(alchemyStack.id,overAlchemyComplete);
|
|
}
|
|
|
|
public function overAlchemyComplete(equipData:Object) : void
|
|
{
|
|
var equipVo:EquipVo = BagCenter.getItemByItemData(equipData) as EquipVo;
|
|
BagCenter.getIns().addItem(equipVo);
|
|
overAlchemy_para.starting = false;
|
|
overAlchemy_para.itemTypes = [];
|
|
if(onOverAlchemyComplete != null)
|
|
{
|
|
onOverAlchemyComplete(equipVo);
|
|
onOverAlchemyComplete = null;
|
|
}
|
|
overAlchemy_para = null;
|
|
}
|
|
|
|
public function getDazaoMoneyCost(items:Array) : int
|
|
{
|
|
var i:int = 0;
|
|
var material:Object = null;
|
|
var j:int = 0;
|
|
var materialNum:int = 0;
|
|
for each(var it:ItemVo in items)
|
|
{
|
|
for(i = 0; i < it.material.length; )
|
|
{
|
|
material = it.material[i];
|
|
materialNum += material.num;
|
|
i++;
|
|
}
|
|
}
|
|
for(j = 0; j < GameMath.alchemyFormulaLevel.length; )
|
|
{
|
|
if(GameMath.alchemyFormulaLevel[j].num > materialNum)
|
|
{
|
|
return GameMath.alchemyFormulaLevel[j].cost;
|
|
}
|
|
j++;
|
|
}
|
|
return materialNum;
|
|
}
|
|
|
|
public function getFormulaLevel(itemTypes:Array) : int
|
|
{
|
|
var k:int = 0;
|
|
var type:int = 0;
|
|
var i:int = 0;
|
|
var material:Object = null;
|
|
var j:int = 0;
|
|
var materialNum:int = 0;
|
|
for(k = 0; k < itemTypes.length; )
|
|
{
|
|
type = int(itemTypes[k]);
|
|
for(i = 0; i < Table.item_info[type].material.length; )
|
|
{
|
|
material = Table.item_info[type].material[i];
|
|
materialNum += int(material.value);
|
|
i++;
|
|
}
|
|
k++;
|
|
}
|
|
var lv:int = 1;
|
|
for(j = 0; j < GameMath.alchemyFormulaLevel.length; )
|
|
{
|
|
if(materialNum <= GameMath.alchemyFormulaLevel[j].num)
|
|
{
|
|
return GameMath.alchemyFormulaLevel[j].lv;
|
|
}
|
|
j++;
|
|
}
|
|
return lv;
|
|
}
|
|
|
|
public function getAlchemyStackVoById(id:int) : AlchemyStackVo
|
|
{
|
|
for each(var vo:AlchemyStackVo in Master.alchemyStacks)
|
|
{
|
|
if(vo.id == id)
|
|
{
|
|
return vo;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public function speedAlchemyByItem(alchemyStackId:int, itemNum:int, onComplete:Function) : void
|
|
{
|
|
onSpeedAlchemyComplete = onComplete;
|
|
var item:ItemVo = BagCenter.getIns().getByType(GameMath.alchemySpeedItemId);
|
|
speedAlchemy_para = {
|
|
"num":itemNum,
|
|
"id":alchemyStackId,
|
|
"itemId":item.id
|
|
};
|
|
NetAlchemy.getIns().speedAlchemy(alchemyStackId,itemNum,item.id,speedAlchemyHandler);
|
|
}
|
|
|
|
private function speedAlchemyHandler(newEndTime:int) : void
|
|
{
|
|
BagCenter.getIns().subNum(speedAlchemy_para.itemId,speedAlchemy_para.num,true);
|
|
getAlchemyStackVoById(speedAlchemy_para.id).endTime = newEndTime;
|
|
if(onSpeedAlchemyComplete != null)
|
|
{
|
|
onSpeedAlchemyComplete();
|
|
onSpeedAlchemyComplete = null;
|
|
speedAlchemy_para = null;
|
|
}
|
|
}
|
|
|
|
public function addAlchemeyStack(onComplete:Function) : void
|
|
{
|
|
onAddAlchemyStackComplete = onComplete;
|
|
NetAlchemy.getIns().addAlchemyStack(allAlchemyStackComplete);
|
|
}
|
|
|
|
public function allAlchemyStackComplete(alchemyStackData:Object = null) : void
|
|
{
|
|
var num:int = int(Master.alchemyStacks.length);
|
|
var money:int = int(Table.alchemyStack_price[num.toString()].money);
|
|
var ke:int = int(Table.alchemyStack_price[num.toString()].ke);
|
|
if(money != 0)
|
|
{
|
|
MasterCenter.getIns().addMoney(-money);
|
|
}
|
|
if(ke != 0)
|
|
{
|
|
MasterCenter.getIns().addKe(-ke);
|
|
}
|
|
var s:AlchemyStackVo = getAlchemyStackByAlchemyStackData(alchemyStackData);
|
|
Master.alchemyStacks.push(s);
|
|
if(onAddAlchemyStackComplete != null)
|
|
{
|
|
onAddAlchemyStackComplete();
|
|
onAddAlchemyStackComplete = null;
|
|
}
|
|
}
|
|
|
|
public function hasFinish() : Boolean
|
|
{
|
|
var i:int = 0;
|
|
var s:AlchemyStackVo = null;
|
|
for(i = 0; i < Master.alchemyStacks.length; )
|
|
{
|
|
s = Master.alchemyStacks[i];
|
|
if(s.starting && s.finish())
|
|
{
|
|
return true;
|
|
}
|
|
i++;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|