/// <summary>
/// 读取字节流(完整版)
/// </summary>
protected override void toReadBytesFull(BytesReadStream stream)
{
base.toReadBytesFull(stream);
stream.startReadObj();
BaseData enterDataT = stream.readDataFullNotNull();
if (enterDataT != null)
{
if (enterDataT is SceneEnterData)
{
this.enterData = (SceneEnterData)enterDataT;
}
else
{
this.enterData = new SceneEnterData();
if (!(enterDataT.GetType().IsAssignableFrom(typeof(SceneEnterData))))
{
stream.throwTypeReadError(typeof(SceneEnterData), enterDataT.GetType());
}
this.enterData.shadowCopy(enterDataT);
}
}
else
{
this.enterData = null;
}
stream.endReadObj();
}
public void initEnterData(SceneEnterData data)
{
if (!enabled)
{
return;
}
ScenePreInfoData preInfo = _scene.getPreInfo();
if (preInfo != null)
{
RoleShowData[] signedPlayers = _scene.getPreInfo().signedPlayers;
if (signedPlayers != null)
{
foreach (RoleShowData v in signedPlayers)
{
_signedPlayers.put(v.playerID, v);
}
}
}
BattleSceneData bData = data.battleData;
onRefreshBattleStateByServer(bData.state, bData.timeTick);
if (_scene.isDriveAll())
{
//客户端场景,直接进入pre状态
switchState(BattleStateType.Pre);
}
}
/// <summary>
/// 复制(潜拷贝)
/// </summary>
protected override void toShadowCopy(BaseData data)
{
if (!(data is SceneEnterData))
{
return;
}
SceneEnterData mData = (SceneEnterData)data;
this.hero = mData.hero;
this.units = mData.units;
this.roles = mData.roles;
this.selfBindFieldItemBags = mData.selfBindFieldItemBags;
this.bindVisionUnits = mData.bindVisionUnits;
this.battleData = mData.battleData;
}
/** 进入客户端场景 */
private void toEnterClientScene()
{
SceneEnterData enterData = _scene.method.createSceneEnterData();
//有进出逻辑
if (_scene.inout != null)
{
UnitData heroData = _scene.inout.createCharacterDataSelf();
enterData.hero = heroData;
enterData.units = new SList <UnitData>();
}
_scene.battle.makeSceneEnterData(enterData);
_scene.method.makeSceneEnterData(enterData);
enterScene(enterData);
}
/** 服务器推送进入场景 */
public void enterScene(SceneEnterData enterData)
{
Ctrl.print("进入场景");
_enterData = enterData;
//TODO:这里可以再补一次资源存在性校验
//初始化
_scene.init();
//初始化进入数据
_scene.initEnterData(_enterData);
GameC.player.dispatch(GameEventType.EnterScene, _scene.getConfig().id);
onEnterScene();
doAddSwitch();
}
public override SceneEnterData createSceneEnterData()
{
if (!_g13)
{
_m13 = instance.Type.GetMethod("createSceneEnterData", 0);
_g13 = true;
}
if (_m13 != null && !_b13)
{
_b13 = true;
SceneEnterData re = (SceneEnterData)appdomain.Invoke(_m13, instance, null);
_b13 = false;
return(re);
}
else
{
return(base.createSceneEnterData());
}
}
public override void initEnterData(SceneEnterData data)
{
if (!_g20)
{
_m20 = instance.Type.GetMethod("initEnterData", 1);
_g20 = true;
}
if (_m20 != null && !_b20)
{
_b20 = true;
_p1[0] = data;
appdomain.Invoke(_m20, instance, _p1);
_p1[0] = null;
_b20 = false;
}
else
{
base.initEnterData(data);
}
}
public override void makeSceneEnterData(SceneEnterData data)
{
if (!_g14)
{
_m14 = instance.Type.GetMethod("makeSceneEnterData", 1);
_g14 = true;
}
if (_m14 != null && !_b14)
{
_b14 = true;
_p1[0] = data;
appdomain.Invoke(_m14, instance, _p1);
_p1[0] = null;
_b14 = false;
}
else
{
base.makeSceneEnterData(data);
}
}
public virtual void makeSceneEnterData(SceneEnterData data)
{
if (!enabled)
{
return;
}
BattleSceneData bData = GameC.factory.createBattleSceneData();
bData.state = _state;
bData.timeTick = _timeTick;
data.battleData = bData;
//units
ScenePreInfoData preInfo = _scene.getPreInfo();
if (preInfo != null)
{
//指定进入角色构造
RoleShowData[] signedPlayers = preInfo.signedPlayers;
if (signedPlayers != null)
{
foreach (RoleShowData v in signedPlayers)
{
//不是自己(有其他角色就自行创建)
if (v.playerID != data.hero.identity.playerID)
{
UnitData unitData = _scene.inout.createCharacterDataForRobot(v.playerID);
data.units.add(unitData);
}
}
}
}
}
/** 初始化进入数据 */
public void initEnterData(SceneEnterData enterData)
{
//有玩家角色
if (enterData.roles != null)
{
foreach (SceneRoleData roleData in enterData.roles)
{
role.addRole(roleData);
}
}
if (enterData.bindVisionUnits != null)
{
_bindVisionUnits = enterData.bindVisionUnits;
}
//有主角
if (enterData.hero != null)
{
//主角
addHero(enterData.hero);
}
SList <SceneLogicBase> logics = _logics;
SceneLogicBase logic;
for (int i = 0, len = logics.Count; i < len; ++i)
{
if ((logic = logics[i]).enabled)
{
logic.afterHero();
}
}
//先处理掉落包数据
if (enterData.selfBindFieldItemBags != null)
{
role.initFieldItemBagBindDic(enterData.selfBindFieldItemBags);
}
//有单位组
if (enterData.units != null)
{
foreach (UnitData v in enterData.units)
{
addUnit(v);
}
}
if (unitFactory != null)
{
//初始化起始单位
unitFactory.initFirst();
}
if (camera != null)
{
//默认镜头
camera.cameraToDefault();
}
//后调用play的
battle.initEnterData(enterData);
method.initEnterData(enterData);
onStart();
}
/// <summary>
/// 读取字节流(简版)
/// </summary>
protected override void toReadBytesSimple(BytesReadStream stream)
{
base.toReadBytesSimple(stream);
this.enterData = (SceneEnterData)stream.readDataSimpleNotNull();
}
/// <summary>
/// 回池
/// </summary>
protected override void toRelease(DataPool pool)
{
base.toRelease(pool);
this.enterData = null;
}
/// <summary>
/// 是否数据一致
/// </summary>
protected override bool toDataEquals(BaseData data)
{
SceneEnterData mData = (SceneEnterData)data;
if (mData.hero != null)
{
if (this.hero == null)
{
return(false);
}
if (!this.hero.dataEquals(mData.hero))
{
return(false);
}
}
else
{
if (this.hero != null)
{
return(false);
}
}
if (mData.units != null)
{
if (this.units == null)
{
return(false);
}
if (this.units.size() != mData.units.size())
{
return(false);
}
SList <UnitData> unitsT = this.units;
SList <UnitData> unitsR = mData.units;
int unitsLen = unitsT.size();
for (int unitsI = 0; unitsI < unitsLen; ++unitsI)
{
UnitData unitsU = unitsT.get(unitsI);
UnitData unitsV = unitsR.get(unitsI);
if (unitsV != null)
{
if (unitsU == null)
{
return(false);
}
if (!unitsU.dataEquals(unitsV))
{
return(false);
}
}
else
{
if (unitsU != null)
{
return(false);
}
}
}
}
else
{
if (this.units != null)
{
return(false);
}
}
if (mData.roles != null)
{
if (this.roles == null)
{
return(false);
}
if (this.roles.size() != mData.roles.size())
{
return(false);
}
LongObjectMap <SceneRoleData> rolesR = mData.roles;
if (!this.roles.isEmpty())
{
long rolesKFreeValue = this.roles.getFreeValue();
long[] rolesKKeys = this.roles.getKeys();
SceneRoleData[] rolesVValues = this.roles.getValues();
for (int rolesKI = rolesKKeys.Length - 1; rolesKI >= 0; --rolesKI)
{
long rolesK = rolesKKeys[rolesKI];
if (rolesK != rolesKFreeValue)
{
SceneRoleData rolesV = rolesVValues[rolesKI];
SceneRoleData rolesU = rolesR.get(rolesK);
if (rolesU != null)
{
if (rolesV == null)
{
return(false);
}
if (!rolesV.dataEquals(rolesU))
{
return(false);
}
}
else
{
if (rolesV != null)
{
return(false);
}
}
}
}
}
}
else
{
if (this.roles != null)
{
return(false);
}
}
if (mData.selfBindFieldItemBags != null)
{
if (this.selfBindFieldItemBags == null)
{
return(false);
}
if (this.selfBindFieldItemBags.size() != mData.selfBindFieldItemBags.size())
{
return(false);
}
IntObjectMap <FieldItemBagBindData> selfBindFieldItemBagsR = mData.selfBindFieldItemBags;
if (!this.selfBindFieldItemBags.isEmpty())
{
int selfBindFieldItemBagsKFreeValue = this.selfBindFieldItemBags.getFreeValue();
int[] selfBindFieldItemBagsKKeys = this.selfBindFieldItemBags.getKeys();
FieldItemBagBindData[] selfBindFieldItemBagsVValues = this.selfBindFieldItemBags.getValues();
for (int selfBindFieldItemBagsKI = selfBindFieldItemBagsKKeys.Length - 1; selfBindFieldItemBagsKI >= 0; --selfBindFieldItemBagsKI)
{
int selfBindFieldItemBagsK = selfBindFieldItemBagsKKeys[selfBindFieldItemBagsKI];
if (selfBindFieldItemBagsK != selfBindFieldItemBagsKFreeValue)
{
FieldItemBagBindData selfBindFieldItemBagsV = selfBindFieldItemBagsVValues[selfBindFieldItemBagsKI];
FieldItemBagBindData selfBindFieldItemBagsU = selfBindFieldItemBagsR.get(selfBindFieldItemBagsK);
if (selfBindFieldItemBagsU != null)
{
if (selfBindFieldItemBagsV == null)
{
return(false);
}
if (!selfBindFieldItemBagsV.dataEquals(selfBindFieldItemBagsU))
{
return(false);
}
}
else
{
if (selfBindFieldItemBagsV != null)
{
return(false);
}
}
}
}
}
}
else
{
if (this.selfBindFieldItemBags != null)
{
return(false);
}
}
if (mData.bindVisionUnits != null)
{
if (this.bindVisionUnits == null)
{
return(false);
}
if (this.bindVisionUnits.size() != mData.bindVisionUnits.size())
{
return(false);
}
IntObjectMap <UnitSimpleData> bindVisionUnitsR = mData.bindVisionUnits;
if (!this.bindVisionUnits.isEmpty())
{
int bindVisionUnitsKFreeValue = this.bindVisionUnits.getFreeValue();
int[] bindVisionUnitsKKeys = this.bindVisionUnits.getKeys();
UnitSimpleData[] bindVisionUnitsVValues = this.bindVisionUnits.getValues();
for (int bindVisionUnitsKI = bindVisionUnitsKKeys.Length - 1; bindVisionUnitsKI >= 0; --bindVisionUnitsKI)
{
int bindVisionUnitsK = bindVisionUnitsKKeys[bindVisionUnitsKI];
if (bindVisionUnitsK != bindVisionUnitsKFreeValue)
{
UnitSimpleData bindVisionUnitsV = bindVisionUnitsVValues[bindVisionUnitsKI];
UnitSimpleData bindVisionUnitsU = bindVisionUnitsR.get(bindVisionUnitsK);
if (bindVisionUnitsU != null)
{
if (bindVisionUnitsV == null)
{
return(false);
}
if (!bindVisionUnitsV.dataEquals(bindVisionUnitsU))
{
return(false);
}
}
else
{
if (bindVisionUnitsV != null)
{
return(false);
}
}
}
}
}
}
else
{
if (this.bindVisionUnits != null)
{
return(false);
}
}
if (mData.battleData != null)
{
if (this.battleData == null)
{
return(false);
}
if (!this.battleData.dataEquals(mData.battleData))
{
return(false);
}
}
else
{
if (this.battleData != null)
{
return(false);
}
}
return(true);
}
/// <summary>
/// 复制(深拷贝)
/// </summary>
protected override void toCopy(BaseData data)
{
if (!(data is SceneEnterData))
{
return;
}
SceneEnterData mData = (SceneEnterData)data;
if (mData.hero != null)
{
this.hero = (UnitData)mData.hero.clone();
}
else
{
this.hero = null;
}
if (mData.units != null)
{
if (this.units != null)
{
this.units.clear();
this.units.ensureCapacity(mData.units.size());
}
else
{
this.units = new SList <UnitData>();
}
SList <UnitData> unitsT = this.units;
if (!mData.units.isEmpty())
{
UnitData[] unitsVValues = mData.units.getValues();
for (int unitsVI = 0, unitsVLen = mData.units.length(); unitsVI < unitsVLen; ++unitsVI)
{
UnitData unitsV = unitsVValues[unitsVI];
UnitData unitsU;
if (unitsV != null)
{
unitsU = (UnitData)unitsV.clone();
}
else
{
unitsU = null;
nullObjError("unitsU");
}
unitsT.add(unitsU);
}
}
}
else
{
this.units = null;
nullObjError("units");
}
if (mData.roles != null)
{
if (this.roles != null)
{
this.roles.clear();
this.roles.ensureCapacity(mData.roles.size());
}
else
{
this.roles = new LongObjectMap <SceneRoleData>(mData.roles.size());
}
LongObjectMap <SceneRoleData> rolesT = this.roles;
if (!mData.roles.isEmpty())
{
SceneRoleData[] rolesVValues = mData.roles.getValues();
for (int rolesVI = rolesVValues.Length - 1; rolesVI >= 0; --rolesVI)
{
SceneRoleData rolesV = rolesVValues[rolesVI];
if (rolesV != null)
{
SceneRoleData rolesU;
if (rolesV != null)
{
rolesU = (SceneRoleData)rolesV.clone();
}
else
{
rolesU = null;
nullObjError("rolesU");
}
rolesT.put(rolesU.playerID, rolesU);
}
}
}
}
else
{
this.roles = null;
nullObjError("roles");
}
if (mData.selfBindFieldItemBags != null)
{
if (this.selfBindFieldItemBags != null)
{
this.selfBindFieldItemBags.clear();
this.selfBindFieldItemBags.ensureCapacity(mData.selfBindFieldItemBags.size());
}
else
{
this.selfBindFieldItemBags = new IntObjectMap <FieldItemBagBindData>(mData.selfBindFieldItemBags.size());
}
IntObjectMap <FieldItemBagBindData> selfBindFieldItemBagsT = this.selfBindFieldItemBags;
if (!mData.selfBindFieldItemBags.isEmpty())
{
FieldItemBagBindData[] selfBindFieldItemBagsVValues = mData.selfBindFieldItemBags.getValues();
for (int selfBindFieldItemBagsVI = selfBindFieldItemBagsVValues.Length - 1; selfBindFieldItemBagsVI >= 0; --selfBindFieldItemBagsVI)
{
FieldItemBagBindData selfBindFieldItemBagsV = selfBindFieldItemBagsVValues[selfBindFieldItemBagsVI];
if (selfBindFieldItemBagsV != null)
{
FieldItemBagBindData selfBindFieldItemBagsU;
if (selfBindFieldItemBagsV != null)
{
selfBindFieldItemBagsU = (FieldItemBagBindData)selfBindFieldItemBagsV.clone();
}
else
{
selfBindFieldItemBagsU = null;
}
selfBindFieldItemBagsT.put(selfBindFieldItemBagsU.instanceID, selfBindFieldItemBagsU);
}
}
}
}
else
{
this.selfBindFieldItemBags = null;
}
if (mData.bindVisionUnits != null)
{
if (this.bindVisionUnits != null)
{
this.bindVisionUnits.clear();
this.bindVisionUnits.ensureCapacity(mData.bindVisionUnits.size());
}
else
{
this.bindVisionUnits = new IntObjectMap <UnitSimpleData>(mData.bindVisionUnits.size());
}
IntObjectMap <UnitSimpleData> bindVisionUnitsT = this.bindVisionUnits;
if (!mData.bindVisionUnits.isEmpty())
{
int bindVisionUnitsKFreeValue = mData.bindVisionUnits.getFreeValue();
int[] bindVisionUnitsKKeys = mData.bindVisionUnits.getKeys();
UnitSimpleData[] bindVisionUnitsVValues = mData.bindVisionUnits.getValues();
for (int bindVisionUnitsKI = bindVisionUnitsKKeys.Length - 1; bindVisionUnitsKI >= 0; --bindVisionUnitsKI)
{
int bindVisionUnitsK = bindVisionUnitsKKeys[bindVisionUnitsKI];
if (bindVisionUnitsK != bindVisionUnitsKFreeValue)
{
UnitSimpleData bindVisionUnitsV = bindVisionUnitsVValues[bindVisionUnitsKI];
int bindVisionUnitsW;
UnitSimpleData bindVisionUnitsU;
bindVisionUnitsW = bindVisionUnitsK;
if (bindVisionUnitsV != null)
{
bindVisionUnitsU = (UnitSimpleData)bindVisionUnitsV.clone();
}
else
{
bindVisionUnitsU = null;
}
bindVisionUnitsT.put(bindVisionUnitsW, bindVisionUnitsU);
}
}
}
}
else
{
this.bindVisionUnits = null;
}
if (mData.battleData != null)
{
this.battleData = (BattleSceneData)mData.battleData.clone();
}
else
{
this.battleData = null;
}
}
/** 初始化进入数据 */
public virtual void initEnterData(SceneEnterData data)
{
}
/** 构造场景进入数据(客户端场景)(激活单位后) */
public virtual void makeSceneEnterData(SceneEnterData data)
{
}
