/** 创建简版数据 */
public UnitSimpleData createSimpleUnitData()
{
UnitSimpleData re = GameC.factory.createUnitSimpleData();
makeSimpleUnitData(re);
return(re);
}
/// <summary>
/// 回池
/// </summary>
protected override void toRelease(DataPool pool)
{
base.toRelease(pool);
this.instanceID = 0;
this.data = null;
}
public void makeSimpleUnitData(UnitSimpleData re)
{
re.instanceID = instanceID;
re.identity = (UnitIdentityData)_data.identity.clone();
if (re.pos == null)
{
re.pos = (UnitPosData)_data.pos.clone();
}
else
{
re.pos.copy(_data.pos);
}
if (re.attributes == null)
{
re.attributes = new IntIntMap();
}
else
{
re.attributes.clear();
}
if (_data.fight != null)
{
IntIntMap dic = _data.fight.attributes;
foreach (int k in AttributeControl.attribute.simpleUnitList)
{
re.attributes.put(k, dic.get(k));
}
}
}
/// <summary>
/// 执行
/// </summary>
protected override void execute()
{
UnitSimpleData data = scene.getBindVisionUnit(instanceID);
if (data != null)
{
data.pos.pos.copyPos(pos);
data.pos.dir.copyDir(dir);
scene.inout.simpleUnitPosChanged(data);
}
}
/// <summary>
/// 执行
/// </summary>
protected override void execute()
{
UnitSimpleData data = scene.getBindVisionUnit(instanceID);
if (data != null)
{
attributes.forEach((k, v) =>
{
data.attributes.put(k, v);
});
scene.inout.simpleUnitAttributeChanged(data);
}
}
/// <summary>
/// 复制(潜拷贝)
/// </summary>
protected override void toShadowCopy(BaseData data)
{
if (!(data is UnitSimpleData))
{
return;
}
UnitSimpleData mData = (UnitSimpleData)data;
this.instanceID = mData.instanceID;
this.identity = mData.identity;
this.pos = mData.pos;
this.attributes = mData.attributes;
}
/// <summary>
/// 读取字节流(简版)
/// </summary>
protected override void toReadBytesSimple(BytesReadStream stream)
{
base.toReadBytesSimple(stream);
this.instanceID = stream.readInt();
if (stream.readBoolean())
{
this.data = (UnitSimpleData)stream.readDataSimpleNotNull();
}
else
{
this.data = null;
}
}
/** 添加单位 */
public Unit addUnit(UnitData data)
{
//预处理
//服务器驱动场景启用
if (_config.instanceType != SceneInstanceType.ClientDriveSinglePlayerBattle)
{
//是自己的M单位
if (data.identity is MUnitIdentityData && data.identity.playerID == GameC.player.role.playerID)
{
MUnitUseLogic useLogic = GameC.player.character.getMUnitUseLogic(data.getMUnitIdentity().mIndex);
if (useLogic == null)
{
Ctrl.throwError("不能找不到主单位的使用逻辑", data.getMUnitIdentity().mIndex);
}
//取主角的数据逻辑
UnitFightDataLogic dataLogic = useLogic.getFightLogic();
//先清空
dataLogic.clear();
//再重设数据
dataLogic.setData(data.fight, data.avatar);
data.fightDataLogic = dataLogic;
}
}
//
Unit unit = toAddUnit(data);
if (unit != null)
{
toActiveUnit(unit);
UnitSimpleData sData = _bindVisionUnits.get(data.instanceID);
if (sData != null)
{
unit.makeSimpleUnitData(sData);
}
}
return(unit);
}
/// <summary>
/// 读取字节流(完整版)
/// </summary>
protected override void toReadBytesFull(BytesReadStream stream)
{
base.toReadBytesFull(stream);
stream.startReadObj();
this.instanceID = stream.readInt();
if (stream.readBoolean())
{
BaseData dataT = stream.readDataFullNotNull();
if (dataT != null)
{
if (dataT is UnitSimpleData)
{
this.data = (UnitSimpleData)dataT;
}
else
{
this.data = new UnitSimpleData();
if (!(dataT.GetType().IsAssignableFrom(typeof(UnitSimpleData))))
{
stream.throwTypeReadError(typeof(UnitSimpleData), dataT.GetType());
}
this.data.shadowCopy(dataT);
}
}
else
{
this.data = null;
}
}
else
{
this.data = null;
}
stream.endReadObj();
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
if (this.hero != null)
{
stream.writeBoolean(true);
stream.writeDataSimpleNotNull(this.hero);
}
else
{
stream.writeBoolean(false);
}
if (this.units != null)
{
stream.writeLen(this.units.size());
if (!this.units.isEmpty())
{
UnitData[] unitsVValues = this.units.getValues();
for (int unitsVI = 0, unitsVLen = this.units.length(); unitsVI < unitsVLen; ++unitsVI)
{
UnitData unitsV = unitsVValues[unitsVI];
if (unitsV != null)
{
stream.writeDataSimpleNotNull(unitsV);
}
else
{
nullObjError("unitsV");
}
}
}
}
else
{
nullObjError("units");
}
if (this.roles != null)
{
stream.writeLen(this.roles.size());
if (!this.roles.isEmpty())
{
SceneRoleData[] rolesVValues = this.roles.getValues();
for (int rolesVI = rolesVValues.Length - 1; rolesVI >= 0; --rolesVI)
{
SceneRoleData rolesV = rolesVValues[rolesVI];
if (rolesV != null)
{
if (rolesV != null)
{
stream.writeDataSimpleNotNull(rolesV);
}
else
{
nullObjError("rolesV");
}
}
}
}
}
else
{
nullObjError("roles");
}
if (this.selfBindFieldItemBags != null)
{
stream.writeBoolean(true);
stream.writeLen(this.selfBindFieldItemBags.size());
if (!this.selfBindFieldItemBags.isEmpty())
{
FieldItemBagBindData[] selfBindFieldItemBagsVValues = this.selfBindFieldItemBags.getValues();
for (int selfBindFieldItemBagsVI = selfBindFieldItemBagsVValues.Length - 1; selfBindFieldItemBagsVI >= 0; --selfBindFieldItemBagsVI)
{
FieldItemBagBindData selfBindFieldItemBagsV = selfBindFieldItemBagsVValues[selfBindFieldItemBagsVI];
if (selfBindFieldItemBagsV != null)
{
if (selfBindFieldItemBagsV != null)
{
stream.writeBoolean(true);
stream.writeDataSimpleNotNull(selfBindFieldItemBagsV);
}
else
{
stream.writeBoolean(false);
}
}
}
}
}
else
{
stream.writeBoolean(false);
}
if (this.bindVisionUnits != null)
{
stream.writeBoolean(true);
stream.writeLen(this.bindVisionUnits.size());
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];
stream.writeInt(bindVisionUnitsK);
if (bindVisionUnitsV != null)
{
stream.writeBoolean(true);
stream.writeDataSimpleNotNull(bindVisionUnitsV);
}
else
{
stream.writeBoolean(false);
}
}
}
}
}
else
{
stream.writeBoolean(false);
}
if (this.battleData != null)
{
stream.writeBoolean(true);
stream.writeDataSimpleNotNull(this.battleData);
}
else
{
stream.writeBoolean(false);
}
}
/** 添加简版单位数据 */
public void addBindVision(UnitSimpleData data)
{
_bindVisionUnits.put(data.instanceID, data);
}
/** 删除单位 */
public void removeUnit(int instanceID)
{
Unit unit = _units.get(instanceID);
if (unit == null)
{
if (ShineSetting.openCheck)
{
Ctrl.throwError("单位不存在:" + instanceID);
}
return;
}
UnitSimpleData sData = _bindVisionUnits.get(instanceID);
if (sData != null)
{
unit.makeSimpleUnitData(sData);
}
//场景移除单位
onRemoveUnit(unit);
//预移除
unit.preRemove();
//没有aoi
//标记
unit.enabled = false;
//析构
unit.dispose();
//字典移除
_units.remove(instanceID);
bool canFight = unit.canFight() && !isSimple();
if (canFight)
{
_fightUnits.remove(instanceID);
}
UnitData data = unit.getUnitData();
if (unit.isCharacter())
{
CharacterIdentityData iData = (CharacterIdentityData)data.identity;
if (_config.instanceType == SceneInstanceType.FiniteBattleWithFrameSync)
{
_charactersByIndex.remove(iData.syncIndex);
}
_characters.remove(iData.playerID);
}
unit.setScene(null);
//双解绑
if (canFight)
{
data.fightDataLogic.setUnit(null);
}
unit.setUnitData(null);
if (canFight && isNeedReleaseFightDataLogic(unit))
{
//清空数据
data.fightDataLogic.clear();
//析构数据逻辑
data.fightDataLogic.setData(null, null);
GameC.pool.releaseUnitFightDataLogic(data.fightDataLogic);
data.fightDataLogic = null;
}
if (isNeedReleaseUnit(unit))
{
GameC.pool.releaseUnit(unit);
}
}
/// <summary>
/// 是否数据一致
/// </summary>
protected override bool toDataEquals(BaseData data)
{
UnitSimpleData mData = (UnitSimpleData)data;
if (this.instanceID != mData.instanceID)
{
return(false);
}
if (mData.identity != null)
{
if (this.identity == null)
{
return(false);
}
if (!this.identity.dataEquals(mData.identity))
{
return(false);
}
}
else
{
if (this.identity != null)
{
return(false);
}
}
if (mData.pos != null)
{
if (this.pos == null)
{
return(false);
}
if (!this.pos.dataEquals(mData.pos))
{
return(false);
}
}
else
{
if (this.pos != null)
{
return(false);
}
}
if (mData.attributes != null)
{
if (this.attributes == null)
{
return(false);
}
if (this.attributes.size() != mData.attributes.size())
{
return(false);
}
IntIntMap attributesR = mData.attributes;
if (!this.attributes.isEmpty())
{
int attributesKFreeValue = this.attributes.getFreeValue();
int[] attributesKKeys = this.attributes.getKeys();
int[] attributesVValues = this.attributes.getValues();
for (int attributesKI = attributesKKeys.Length - 1; attributesKI >= 0; --attributesKI)
{
int attributesK = attributesKKeys[attributesKI];
if (attributesK != attributesKFreeValue)
{
int attributesV = attributesVValues[attributesKI];
int attributesU = attributesR.get(attributesK);
if (attributesV != attributesU)
{
return(false);
}
}
}
}
}
else
{
if (this.attributes != null)
{
return(false);
}
}
return(true);
}
/// <summary>
/// 转文本输出
/// </summary>
protected override void toWriteDataString(DataWriter writer)
{
writer.writeTabs();
writer.sb.Append("hero");
writer.sb.Append(':');
if (this.hero != null)
{
this.hero.writeDataString(writer);
}
else
{
writer.sb.Append("UnitData=null");
}
writer.writeEnter();
writer.writeTabs();
writer.sb.Append("units");
writer.sb.Append(':');
writer.sb.Append("List<UnitData>");
if (this.units != null)
{
SList <UnitData> unitsT = this.units;
int unitsLen = unitsT.size();
writer.sb.Append('(');
writer.sb.Append(unitsLen);
writer.sb.Append(')');
writer.writeEnter();
writer.writeLeftBrace();
for (int unitsI = 0; unitsI < unitsLen; ++unitsI)
{
UnitData unitsV = unitsT.get(unitsI);
writer.writeTabs();
writer.sb.Append(unitsI);
writer.sb.Append(':');
if (unitsV != null)
{
unitsV.writeDataString(writer);
}
else
{
writer.sb.Append("UnitData=null");
}
writer.writeEnter();
}
writer.writeRightBrace();
}
else
{
writer.sb.Append("=null");
}
writer.writeEnter();
writer.writeTabs();
writer.sb.Append("roles");
writer.sb.Append(':');
writer.sb.Append("Map<long,SceneRoleData>");
if (this.roles != null)
{
writer.sb.Append('(');
writer.sb.Append(this.roles.size());
writer.sb.Append(')');
writer.writeEnter();
writer.writeLeftBrace();
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];
writer.writeTabs();
writer.sb.Append(rolesK);
writer.sb.Append(':');
if (rolesV != null)
{
rolesV.writeDataString(writer);
}
else
{
writer.sb.Append("SceneRoleData=null");
}
writer.writeEnter();
}
}
}
writer.writeRightBrace();
}
else
{
writer.sb.Append("=null");
}
writer.writeEnter();
writer.writeTabs();
writer.sb.Append("selfBindFieldItemBags");
writer.sb.Append(':');
writer.sb.Append("Map<int,FieldItemBagBindData>");
if (this.selfBindFieldItemBags != null)
{
writer.sb.Append('(');
writer.sb.Append(this.selfBindFieldItemBags.size());
writer.sb.Append(')');
writer.writeEnter();
writer.writeLeftBrace();
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];
writer.writeTabs();
writer.sb.Append(selfBindFieldItemBagsK);
writer.sb.Append(':');
if (selfBindFieldItemBagsV != null)
{
selfBindFieldItemBagsV.writeDataString(writer);
}
else
{
writer.sb.Append("FieldItemBagBindData=null");
}
writer.writeEnter();
}
}
}
writer.writeRightBrace();
}
else
{
writer.sb.Append("=null");
}
writer.writeEnter();
writer.writeTabs();
writer.sb.Append("bindVisionUnits");
writer.sb.Append(':');
writer.sb.Append("Map<int,UnitSimpleData>");
if (this.bindVisionUnits != null)
{
writer.sb.Append('(');
writer.sb.Append(this.bindVisionUnits.size());
writer.sb.Append(')');
writer.writeEnter();
writer.writeLeftBrace();
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];
writer.writeTabs();
writer.sb.Append(bindVisionUnitsK);
writer.sb.Append(':');
if (bindVisionUnitsV != null)
{
bindVisionUnitsV.writeDataString(writer);
}
else
{
writer.sb.Append("UnitSimpleData=null");
}
writer.writeEnter();
}
}
}
writer.writeRightBrace();
}
else
{
writer.sb.Append("=null");
}
writer.writeEnter();
writer.writeTabs();
writer.sb.Append("battleData");
writer.sb.Append(':');
if (this.battleData != null)
{
this.battleData.writeDataString(writer);
}
else
{
writer.sb.Append("BattleSceneData=null");
}
writer.writeEnter();
}
public void simpleUnitPosChanged(UnitSimpleData data)
{
//TODO:继续
}
/// <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;
}
}
/// <summary>
/// 复制(深拷贝)
/// </summary>
protected override void toCopy(BaseData data)
{
if (!(data is UnitSimpleData))
{
return;
}
UnitSimpleData mData = (UnitSimpleData)data;
this.instanceID = mData.instanceID;
if (mData.identity != null)
{
this.identity = (UnitIdentityData)mData.identity.clone();
}
else
{
this.identity = null;
nullObjError("identity");
}
if (mData.pos != null)
{
this.pos = (UnitPosData)mData.pos.clone();
}
else
{
this.pos = null;
}
if (mData.attributes != null)
{
if (this.attributes != null)
{
this.attributes.clear();
this.attributes.ensureCapacity(mData.attributes.size());
}
else
{
this.attributes = new IntIntMap(mData.attributes.size());
}
IntIntMap attributesT = this.attributes;
if (!mData.attributes.isEmpty())
{
int attributesKFreeValue = mData.attributes.getFreeValue();
int[] attributesKKeys = mData.attributes.getKeys();
int[] attributesVValues = mData.attributes.getValues();
for (int attributesKI = attributesKKeys.Length - 1; attributesKI >= 0; --attributesKI)
{
int attributesK = attributesKKeys[attributesKI];
if (attributesK != attributesKFreeValue)
{
int attributesV = attributesVValues[attributesKI];
int attributesW;
int attributesU;
attributesW = attributesK;
attributesU = attributesV;
attributesT.put(attributesW, attributesU);
}
}
}
}
else
{
this.attributes = null;
nullObjError("attributes");
}
}
/// <summary>
/// 读取字节流(完整版)
/// </summary>
protected override void toReadBytesFull(BytesReadStream stream)
{
stream.startReadObj();
if (stream.readBoolean())
{
BaseData heroT = stream.readDataFullNotNull();
if (heroT != null)
{
if (heroT is UnitData)
{
this.hero = (UnitData)heroT;
}
else
{
this.hero = new UnitData();
if (!(heroT.GetType().IsAssignableFrom(typeof(UnitData))))
{
stream.throwTypeReadError(typeof(UnitData), heroT.GetType());
}
this.hero.shadowCopy(heroT);
}
}
else
{
this.hero = null;
}
}
else
{
this.hero = null;
}
int unitsLen = stream.readLen();
if (this.units != null)
{
this.units.clear();
this.units.ensureCapacity(unitsLen);
}
else
{
this.units = new SList <UnitData>();
}
SList <UnitData> unitsT = this.units;
for (int unitsI = unitsLen - 1; unitsI >= 0; --unitsI)
{
UnitData unitsV;
BaseData unitsVT = stream.readDataFullNotNull();
if (unitsVT != null)
{
if (unitsVT is UnitData)
{
unitsV = (UnitData)unitsVT;
}
else
{
unitsV = new UnitData();
if (!(unitsVT.GetType().IsAssignableFrom(typeof(UnitData))))
{
stream.throwTypeReadError(typeof(UnitData), unitsVT.GetType());
}
unitsV.shadowCopy(unitsVT);
}
}
else
{
unitsV = null;
}
unitsT.add(unitsV);
}
int rolesLen = stream.readLen();
if (this.roles != null)
{
this.roles.clear();
this.roles.ensureCapacity(rolesLen);
}
else
{
this.roles = new LongObjectMap <SceneRoleData>(rolesLen);
}
LongObjectMap <SceneRoleData> rolesT = this.roles;
for (int rolesI = rolesLen - 1; rolesI >= 0; --rolesI)
{
SceneRoleData rolesV;
BaseData rolesVT = stream.readDataFullNotNull();
if (rolesVT != null)
{
if (rolesVT is SceneRoleData)
{
rolesV = (SceneRoleData)rolesVT;
}
else
{
rolesV = new SceneRoleData();
if (!(rolesVT.GetType().IsAssignableFrom(typeof(SceneRoleData))))
{
stream.throwTypeReadError(typeof(SceneRoleData), rolesVT.GetType());
}
rolesV.shadowCopy(rolesVT);
}
}
else
{
rolesV = null;
}
rolesT.put(rolesV.playerID, rolesV);
}
if (stream.readBoolean())
{
int selfBindFieldItemBagsLen = stream.readLen();
if (this.selfBindFieldItemBags != null)
{
this.selfBindFieldItemBags.clear();
this.selfBindFieldItemBags.ensureCapacity(selfBindFieldItemBagsLen);
}
else
{
this.selfBindFieldItemBags = new IntObjectMap <FieldItemBagBindData>(selfBindFieldItemBagsLen);
}
IntObjectMap <FieldItemBagBindData> selfBindFieldItemBagsT = this.selfBindFieldItemBags;
for (int selfBindFieldItemBagsI = selfBindFieldItemBagsLen - 1; selfBindFieldItemBagsI >= 0; --selfBindFieldItemBagsI)
{
FieldItemBagBindData selfBindFieldItemBagsV;
if (stream.readBoolean())
{
BaseData selfBindFieldItemBagsVT = stream.readDataFullNotNull();
if (selfBindFieldItemBagsVT != null)
{
if (selfBindFieldItemBagsVT is FieldItemBagBindData)
{
selfBindFieldItemBagsV = (FieldItemBagBindData)selfBindFieldItemBagsVT;
}
else
{
selfBindFieldItemBagsV = new FieldItemBagBindData();
if (!(selfBindFieldItemBagsVT.GetType().IsAssignableFrom(typeof(FieldItemBagBindData))))
{
stream.throwTypeReadError(typeof(FieldItemBagBindData), selfBindFieldItemBagsVT.GetType());
}
selfBindFieldItemBagsV.shadowCopy(selfBindFieldItemBagsVT);
}
}
else
{
selfBindFieldItemBagsV = null;
}
}
else
{
selfBindFieldItemBagsV = null;
}
selfBindFieldItemBagsT.put(selfBindFieldItemBagsV.instanceID, selfBindFieldItemBagsV);
}
}
else
{
this.selfBindFieldItemBags = null;
}
if (stream.readBoolean())
{
int bindVisionUnitsLen = stream.readLen();
if (this.bindVisionUnits != null)
{
this.bindVisionUnits.clear();
this.bindVisionUnits.ensureCapacity(bindVisionUnitsLen);
}
else
{
this.bindVisionUnits = new IntObjectMap <UnitSimpleData>(bindVisionUnitsLen);
}
IntObjectMap <UnitSimpleData> bindVisionUnitsT = this.bindVisionUnits;
for (int bindVisionUnitsI = bindVisionUnitsLen - 1; bindVisionUnitsI >= 0; --bindVisionUnitsI)
{
int bindVisionUnitsK;
UnitSimpleData bindVisionUnitsV;
bindVisionUnitsK = stream.readInt();
if (stream.readBoolean())
{
BaseData bindVisionUnitsVT = stream.readDataFullNotNull();
if (bindVisionUnitsVT != null)
{
if (bindVisionUnitsVT is UnitSimpleData)
{
bindVisionUnitsV = (UnitSimpleData)bindVisionUnitsVT;
}
else
{
bindVisionUnitsV = new UnitSimpleData();
if (!(bindVisionUnitsVT.GetType().IsAssignableFrom(typeof(UnitSimpleData))))
{
stream.throwTypeReadError(typeof(UnitSimpleData), bindVisionUnitsVT.GetType());
}
bindVisionUnitsV.shadowCopy(bindVisionUnitsVT);
}
}
else
{
bindVisionUnitsV = null;
}
}
else
{
bindVisionUnitsV = null;
}
bindVisionUnitsT.put(bindVisionUnitsK, bindVisionUnitsV);
}
}
else
{
this.bindVisionUnits = null;
}
if (stream.readBoolean())
{
BaseData battleDataT = stream.readDataFullNotNull();
if (battleDataT != null)
{
if (battleDataT is BattleSceneData)
{
this.battleData = (BattleSceneData)battleDataT;
}
else
{
this.battleData = new BattleSceneData();
if (!(battleDataT.GetType().IsAssignableFrom(typeof(BattleSceneData))))
{
stream.throwTypeReadError(typeof(BattleSceneData), battleDataT.GetType());
}
this.battleData.shadowCopy(battleDataT);
}
}
else
{
this.battleData = null;
}
}
else
{
this.battleData = null;
}
stream.endReadObj();
}
public void simpleUnitAttributeChanged(UnitSimpleData data)
{
//TODO:继续
}
