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 toReadBytesFull(BytesReadStream stream)
{
base.toReadBytesFull(stream);
stream.startReadObj();
BaseData preInfoT = stream.readDataFullNotNull();
if (preInfoT != null)
{
if (preInfoT is ScenePreInfoData)
{
this.preInfo = (ScenePreInfoData)preInfoT;
}
else
{
this.preInfo = new ScenePreInfoData();
if (!(preInfoT.GetType().IsAssignableFrom(typeof(ScenePreInfoData))))
{
stream.throwTypeReadError(typeof(ScenePreInfoData), preInfoT.GetType());
}
this.preInfo.shadowCopy(preInfoT);
}
}
else
{
this.preInfo = null;
}
stream.endReadObj();
}
/** 指定单位组 */
public void loadNext(ScenePreInfoData infoData)
{
_partTwoComplete = false;
if (infoData == null || infoData.signedPlayers == null)
{
onLoadTwoOver();
}
else
{
// IntSet loadList=new IntSet();
//
// foreach(UnitInfoData v in infoData.signedPlayers)
// {
// makeUnitLoadList(loadList,v);
// }
//
// int index=_index;
//
// LoadControl.loadSet(loadList,()=>
// {
// if(_index==index)
// {
// onLoadTwoOver();
// }
// });
//TODO:资源预加载
onLoadTwoOver();
}
}
/// <summary>
/// 复制(潜拷贝)
/// </summary>
protected override void toShadowCopy(BaseData data)
{
if (!(data is ScenePreInfoData))
{
return;
}
ScenePreInfoData mData = (ScenePreInfoData)data;
this.signedPlayers = mData.signedPlayers;
}
/// <summary>
/// 是否数据一致
/// </summary>
protected override bool toDataEquals(BaseData data)
{
ScenePreInfoData mData = (ScenePreInfoData)data;
if (mData.signedPlayers != null)
{
if (this.signedPlayers == null)
{
return(false);
}
if (this.signedPlayers.Length != mData.signedPlayers.Length)
{
return(false);
}
RoleShowData[] signedPlayersT = this.signedPlayers;
RoleShowData[] signedPlayersR = mData.signedPlayers;
int signedPlayersLen = signedPlayersT.Length;
for (int signedPlayersI = 0; signedPlayersI < signedPlayersLen; ++signedPlayersI)
{
RoleShowData signedPlayersU = signedPlayersT[signedPlayersI];
RoleShowData signedPlayersV = signedPlayersR[signedPlayersI];
if (signedPlayersV != null)
{
if (signedPlayersU == null)
{
return(false);
}
if (!signedPlayersU.dataEquals(signedPlayersV))
{
return(false);
}
}
else
{
if (signedPlayersU != null)
{
return(false);
}
}
}
}
else
{
if (this.signedPlayers != null)
{
return(false);
}
}
return(true);
}
public override void makePreInfo(ScenePreInfoData infoData)
{
if (!_g13)
{
_m13 = instance.Type.GetMethod("makePreInfo", 1);
_g13 = true;
}
if (_m13 != null && !_b13)
{
_b13 = true;
_p1[0] = infoData;
appdomain.Invoke(_m13, instance, _p1);
_p1[0] = null;
_b13 = false;
}
else
{
base.makePreInfo(infoData);
}
}
/** 预进入场景第二阶段 */
public void preEnterSceneNext(ScenePreInfoData info)
{
if (_createdNextScene)
{
_scene.setPreInfo(info);
//不是无切换过程
if (_isSwitchCross)
{
loadSceneResourceOver();
}
else
{
_scene.load.loadNext(info);
}
}
else
{
_preInfo = info;
}
}
/// <summary>
/// 复制(深拷贝)
/// </summary>
protected override void toCopy(BaseData data)
{
if (!(data is ScenePreInfoData))
{
return;
}
ScenePreInfoData mData = (ScenePreInfoData)data;
if (mData.signedPlayers != null)
{
RoleShowData[] signedPlayersR = mData.signedPlayers;
int signedPlayersLen = signedPlayersR.Length;
if (this.signedPlayers == null || this.signedPlayers.Length != signedPlayersLen)
{
this.signedPlayers = new RoleShowData[signedPlayersLen];
}
RoleShowData[] signedPlayersT = this.signedPlayers;
for (int signedPlayersI = 0; signedPlayersI < signedPlayersLen; ++signedPlayersI)
{
RoleShowData signedPlayersV = signedPlayersR[signedPlayersI];
RoleShowData signedPlayersU;
if (signedPlayersV != null)
{
signedPlayersU = (RoleShowData)signedPlayersV.clone();
}
else
{
signedPlayersU = null;
}
signedPlayersT[signedPlayersI] = signedPlayersU;
}
}
else
{
this.signedPlayers = null;
}
}
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 preEnterScene(int sceneID, int lineID)
{
_preSceneID = sceneID;
_preLineID = lineID;
_createdNextScene = false;
_preInfo = null;
_isSwitching = true;
_isSwitchCross = false;
SceneConfig nextConfig = SceneConfig.get(sceneID);
_switchType = nextConfig.switchType;
if (_scene != null)
{
//是否跳过加载资源
if (isSkipLoadSource(nextConfig))
{
_isSwitchCross = true;
}
}
removeNowScene();
}
/** 预备信息 */
public void setPreInfo(ScenePreInfoData preInfo)
{
_preInfo = preInfo;
}
/// <summary>
/// 读取字节流(简版)
/// </summary>
protected override void toReadBytesSimple(BytesReadStream stream)
{
base.toReadBytesSimple(stream);
this.preInfo = (ScenePreInfoData)stream.readDataSimpleNotNull();
}
/// <summary>
/// 回池
/// </summary>
protected override void toRelease(DataPool pool)
{
base.toRelease(pool);
this.preInfo = null;
}
/** 构造预备进入数据(机器人) */
public virtual void makePreInfo(ScenePreInfoData infoData)
{
infoData.signedPlayers = _signedUnits;
}
protected void removeNowSceneOver()
{
onRemoveNowSceneOver();
clearNowScene(!_isSwitchCross);
//有下个场景
if (_preSceneID > 0)
{
//创建场景
//客户端场景不做池了
SceneConfig config = SceneConfig.get(_preSceneID);
_scene = GameC.factory.createScene();
_scene.setType(config.type);
_scene.construct();
//初始化场景ID
_scene.initSceneID(_preSceneID);
//设置预进入数据
if (_preInfo != null)
{
_scene.setPreInfo(_preInfo);
}
//标记创建了下个场景
_createdNextScene = true;
if (_isSwitchCross)
{
// loadSceneResourceOver();
}
else
{
_scene.load.startLoad(loadSceneResourceOver);
}
//客户端单人副本
if (config.instanceType == SceneInstanceType.ClientDriveSinglePlayerBattle)
{
//有进出逻辑
if (_scene.inout != null)
{
ScenePreInfoData preInfo = toCreateScenePreInfoData();
_scene.inout.beforePreEnter();
_scene.inout.makePreInfo(preInfo);
preEnterSceneNext(preInfo);
}
//没有进出逻辑
else
{
preEnterSceneNext(null);
}
}
}
else
{
leaveSceneOver();
}
}
