public void RemoveGridObject(GridObject gridObject)
{
var message = new BattleSceneRemoveGridObjectMessage();
message.gridObj = StreamableFactory.CreateBattleSceneObject(gridObject);
_connection.SendMessage(message);
}
public void StartCheck(SceneObject initiative, SkillType initiativeSkillType, CharacterAction action, IEnumerable <SceneObject> targets)
{
if (!_isUsing)
{
return;
}
var message = new BattleSceneStartCheckMessage();
message.initiativeObj = StreamableFactory.CreateBattleSceneObject(initiative);
message.initiativeSkillType = StreamableFactory.CreateSkillTypeDescription(initiativeSkillType);
message.action = action;
int count = 0;
foreach (var target in targets)
{
++count;
}
message.targets = new BattleSceneObject[count];
int i = 0;
foreach (var target in targets)
{
message.targets[i++] = StreamableFactory.CreateBattleSceneObject(target);
}
_connection.SendMessage(message);
}
public void RemoveLadderObject(LadderObject ladderObject)
{
var message = new BattleSceneRemoveLadderObjectMessage();
message.ladderObj = StreamableFactory.CreateBattleSceneObject(ladderObject);
_connection.SendMessage(message);
}
public void AddLadderObject(LadderObject ladderObject)
{
var message = new BattleSceneAddLadderObjectMessage();
message.objData = StreamableFactory.CreateBattleSceneLadderObjData(ladderObject);
message.view = ladderObject.CharacterRef.View;
_connection.SendMessage(message);
}
private Message GetCharacterInfoData(Character character)
{
var message = new CharacterInfoDataMessage();
message.characterID = character.ID;
message.describable = StreamableFactory.CreateDescribable(character);
return(message);
}
public void PushGridObject(GridObject gridObject)
{
var message = new BattleScenePushGridObjectMessage();
message.view = gridObject.CharacterRef.View;
message.objData = StreamableFactory.CreateBattleSceneGridObjData(gridObject);
_connection.SendMessage(message);
}
public void CheckNextone(SceneObject nextone)
{
if (!_isUsing || !BattleSceneContainer.Instance.IsChecking)
{
return;
}
var message = new BattleSceneCheckNextoneMessage();
message.nextone = StreamableFactory.CreateBattleSceneObject(nextone);
_connection.SendMessage(message);
}
public void DisplayUsingStunt(SceneObject sceneObject, Stunt stunt)
{
if (!_isUsing)
{
return;
}
var message = new BattleSceneDisplayUsingStuntMessage();
message.obj = StreamableFactory.CreateBattleSceneObject(sceneObject);
message.stunt = StreamableFactory.CreateCharacterPropertyDescription(stunt);
_connection.SendMessage(message);
}
public void UpdateSumPoint(SceneObject sceneObject, int point)
{
if (!_isUsing || !BattleSceneContainer.Instance.IsChecking)
{
return;
}
var message = new BattleSceneCheckerUpdateSumPointMessage();
message.obj = StreamableFactory.CreateBattleSceneObject(sceneObject);
message.point = point;
_connection.SendMessage(message);
}
public void UpdateActionPoint(ActableGridObject actable)
{
if (!_isUsing)
{
return;
}
var message = new BattleSceneUpdateActionPointMessage();
message.obj = StreamableFactory.CreateBattleSceneObject(actable);
message.newActionPoint = actable.ActionPoint;
_connection.SendMessage(message);
}
public void ChangeTurn(ActableGridObject actable)
{
if (!_isUsing)
{
return;
}
_canOperate = actable.CharacterRef.Controller == _owner;
var message = new BattleSceneChangeTurnMessage();
message.canOperate = _canOperate;
message.gridObj = StreamableFactory.CreateBattleSceneObject(actable);
_connection.SendMessage(message);
}
public void DisplayTakeExtraMovePoint(ActableGridObject actable, SkillType usingSkillType)
{
if (!_isUsing)
{
return;
}
var message = new BattleSceneDisplayTakeExtraMovePointMessage();
message.obj = StreamableFactory.CreateBattleSceneObject(actable);
message.moveSkillType = StreamableFactory.CreateSkillTypeDescription(usingSkillType);
message.newMovePoint = actable.MovePoint;
_connection.SendMessage(message);
}
public void DisplayUsingAspect(SceneObject userSceneObject, SceneObject ownerSceneObject, Aspect aspect)
{
if (!_isUsing || !BattleSceneContainer.Instance.IsChecking)
{
return;
}
var message = new BattleSceneCheckerDisplayUsingAspectMessage();
message.userObj = StreamableFactory.CreateBattleSceneObject(userSceneObject);
message.aspectOwnerObj = StreamableFactory.CreateBattleSceneObject(ownerSceneObject);
message.aspect = StreamableFactory.CreateCharacterPropertyDescription(aspect);
_connection.SendMessage(message);
}
public void DisplaySkillReady(SceneObject sceneObject, SkillType skillType, bool bigone)
{
if (!_isUsing || !BattleSceneContainer.Instance.IsChecking)
{
return;
}
var message = new BattleSceneCheckerDisplaySkillReadyMessage();
message.obj = StreamableFactory.CreateBattleSceneObject(sceneObject);
message.skillTypeID = skillType.ID;
message.bigone = bigone;
_connection.SendMessage(message);
}
public void DisplayActableObjectMove(ActableGridObject actable, BattleMapDirection direction, bool stairway)
{
if (!_isUsing)
{
return;
}
var message = new BattleSceneDisplayActableObjectMovingMessage();
message.obj = StreamableFactory.CreateBattleSceneObject(actable);
message.direction = direction;
message.stairway = stairway;
_connection.SendMessage(message);
}
private Message GetSkillTypeList()
{
var message = new SkillTypeListDataMessage();
message.skillTypes = new SkillTypeDescription[SkillType.SkillTypes.Count];
int i = 0;
foreach (var skillType in SkillType.SkillTypes)
{
message.skillTypes[i++] = StreamableFactory.CreateSkillTypeDescription(skillType.Value);
}
return(message);
}
public void NotifyPassiveSelectSkillOrStunt(CharacterAction action, Character passive, Character initiative, SkillType initiativeSkillType)
{
if (!_isUsing)
{
return;
}
var message = new StorySceneCheckerNotifyPassiveSelectSkillOrStuntMessage();
message.passiveCharacterID = passive.ID;
message.initiativeCharacterID = initiative.ID;
message.initiativeSkillType = StreamableFactory.CreateSkillTypeDescription(initiativeSkillType);
message.action = action;
_connection.SendMessage(message);
}
public void NotifyPassiveSelectSkillOrStunt(CharacterAction action, SceneObject passive, SceneObject initiative, SkillType initiativeSkillType)
{
if (!_isUsing || !BattleSceneContainer.Instance.IsChecking)
{
return;
}
var message = new BattleSceneCheckerNotifyPassiveSelectSkillOrStuntMessage();
message.passiveObj = StreamableFactory.CreateBattleSceneObject(passive);
message.initiativeObj = StreamableFactory.CreateBattleSceneObject(initiative);
message.initiativeSkillType = StreamableFactory.CreateSkillTypeDescription(initiativeSkillType);
message.action = action;
_connection.SendMessage(message);
}
public void SetActingOrder(List <ActableGridObject> actableObjects)
{
if (!_isUsing)
{
return;
}
var message = new BattleSceneSetActingOrderMessage();
message.objOrder = new BattleSceneObject[actableObjects.Count];
for (int i = 0; i < actableObjects.Count; ++i)
{
message.objOrder[i] = StreamableFactory.CreateBattleSceneObject(actableObjects[i]);
}
_connection.SendMessage(message);
}
private Message GetDirectResistSkills(SkillType initiativeSkillType, CharacterAction action)
{
var message = new DirectResistSkillsListMessage();
List <SkillType> resistables = new List <SkillType>();
foreach (var skillType in SkillType.SkillTypes)
{
if (SkillChecker.CanResistSkillWithoutDMCheck(initiativeSkillType, skillType.Value, action))
{
resistables.Add(skillType.Value);
}
}
message.skillTypes = new SkillTypeDescription[resistables.Count];
for (int i = 0; i < resistables.Count; ++i)
{
message.skillTypes[i] = StreamableFactory.CreateSkillTypeDescription(resistables[i]);
}
return(message);
}
private Message GetDirectResistStunts(SkillType initiativeSkillType, Character passive, CharacterAction action)
{
var message = new DirectResistStuntsListMessage();
List <Stunt> resistables = new List <Stunt>();
if (passive.Stunts != null)
{
foreach (var stunt in passive.Stunts)
{
if (stunt.CanResistSkillWithoutDMCheck(initiativeSkillType, action))
{
resistables.Add(stunt);
}
}
}
message.characterID = passive.ID;
message.stunts = new CharacterPropertyDescription[resistables.Count];
for (int i = 0; i < resistables.Count; ++i)
{
message.stunts[i] = StreamableFactory.CreateCharacterPropertyDescription(resistables[i]);
}
return(message);
}
public Message MakeResponse(Message request)
{
try {
if (!_isUsing)
{
return(null);
}
var container = BattleSceneContainer.Instance;
switch (request.MessageType)
{
case BattleSceneGetGridObjectDataMessage.MESSAGE_TYPE: {
var reqMsg = (BattleSceneGetGridObjectDataMessage)request;
var resp = new BattleSceneGridObjectDataMessage();
var gridObject = BattleSceneContainer.Instance.FindObject(reqMsg.objID) as GridObject;
if (gridObject == null)
{
return(null);
}
resp.objData = StreamableFactory.CreateBattleSceneGridObjData(gridObject);
return(resp);
}
case BattleSceneGetLadderObjectDataMessage.MESSAGE_TYPE: {
var reqMsg = (BattleSceneGetLadderObjectDataMessage)request;
var resp = new BattleSceneLadderObjectDataMessage();
var ladderObject = BattleSceneContainer.Instance.FindObject(reqMsg.objID) as LadderObject;
if (ladderObject == null)
{
return(null);
}
resp.objData = StreamableFactory.CreateBattleSceneLadderObjData(ladderObject);
return(resp);
}
case BattleSceneGetMovePathInfoMessage.MESSAGE_TYPE: {
if (!_canOperate || container.CurrentActable.CharacterRef.Controller != _owner)
{
break;
}
var list = container.CurrentActable.GetReachablePlaceList();
var resp = CreateMovePathInfoMessage(list);
return(resp);
}
case BattleSceneGetCanExtraMoveMessage.MESSAGE_TYPE: {
if (!_canOperate || container.CurrentActable.CharacterRef.Controller != _owner)
{
break;
}
var resp = new BattleSceneCanTakeExtraMoveMessage();
resp.result = container.CurrentActable.CanTakeExtraMove();
return(resp);
}
case BattleSceneGetInitiativeUsableSkillOrStuntListMessage.MESSAGE_TYPE: {
if (!_canOperate || container.CurrentActable.CharacterRef.Controller != _owner)
{
break;
}
var reqMsg = (BattleSceneGetInitiativeUsableSkillOrStuntListMessage)request;
if (reqMsg.stunt)
{
var resp = new BattleSceneObjectUsableStuntListMessage();
var candoList = new List <Stunt>();
if (container.CurrentActable.CharacterRef.Stunts != null)
{
foreach (var stunt in container.CurrentActable.CharacterRef.Stunts)
{
if (container.CurrentActable.CanUseStuntInAction(stunt, reqMsg.action) &&
container.CurrentActable.IsActionPointEnough(stunt.BattleMapProperty))
{
candoList.Add(stunt);
}
}
}
resp.stunts = new CharacterPropertyDescription[candoList.Count];
for (int i = 0; i < candoList.Count; ++i)
{
resp.stunts[i] = StreamableFactory.CreateCharacterPropertyDescription(candoList[i]);
}
return(resp);
}
else
{
var resp = new BattleSceneObjectUsableSkillListMessage();
var candoList = new List <SkillType>();
foreach (var skillType in SkillType.SkillTypes)
{
var battleMapProperty = container.CurrentActable.CharacterRef.GetSkill(skillType.Value).BattleMapProperty;
if (container.CurrentActable.CanUseSkillInAction(skillType.Value, reqMsg.action) &&
container.CurrentActable.IsActionPointEnough(battleMapProperty))
{
candoList.Add(skillType.Value);
}
}
resp.skillTypes = new SkillTypeDescription[candoList.Count];
for (int i = 0; i < candoList.Count; ++i)
{
resp.skillTypes[i] = StreamableFactory.CreateSkillTypeDescription(candoList[i]);
}
return(resp);
}
}
case BattleSceneGetInitiativeUsableSkillOrStuntListOnInteractMessage.MESSAGE_TYPE: {
if (!_canOperate || container.CurrentActable.CharacterRef.Controller != _owner)
{
break;
}
var reqMsg = (BattleSceneGetInitiativeUsableSkillOrStuntListOnInteractMessage)request;
if (reqMsg.stunt)
{
var resp = new BattleSceneObjectUsableStuntListOnInteractMessage();
var candoList = new List <Stunt>();
if (container.CurrentActable.CharacterRef.Stunts != null)
{
foreach (var stunt in container.CurrentActable.CharacterRef.Stunts)
{
if (container.CurrentActable.CanUseStuntOnInteract(stunt) &&
container.CurrentActable.IsActionPointEnough(stunt.BattleMapProperty))
{
candoList.Add(stunt);
}
}
}
resp.stunts = new CharacterPropertyDescription[candoList.Count];
for (int i = 0; i < candoList.Count; ++i)
{
resp.stunts[i] = StreamableFactory.CreateCharacterPropertyDescription(candoList[i]);
}
return(resp);
}
else
{
var resp = new BattleSceneObjectUsableSkillListOnInteractMessage();
var candoList = new List <SkillType>();
foreach (var skillType in SkillType.SkillTypes)
{
var battleMapProperty = container.CurrentActable.CharacterRef.GetSkill(skillType.Value).BattleMapProperty;
if (container.CurrentActable.CanUseSkillOnInteract(skillType.Value) &&
container.CurrentActable.IsActionPointEnough(battleMapProperty))
{
candoList.Add(skillType.Value);
}
}
resp.skillTypes = new SkillTypeDescription[candoList.Count];
for (int i = 0; i < candoList.Count; ++i)
{
resp.skillTypes[i] = StreamableFactory.CreateSkillTypeDescription(candoList[i]);
}
return(resp);
}
}
case BattleSceneGetActionAffectableAreasMessage.MESSAGE_TYPE: {
if (!_canOperate || container.CurrentActable.CharacterRef.Controller != _owner)
{
break;
}
var reqMsg = (BattleSceneGetActionAffectableAreasMessage)request;
var resp = new BattleSceneActionAffectableAreasMessage();
Dictionary <GridPos, List <GridPos> > areas;
if (reqMsg.isStunt)
{
var stunt = container.CurrentActable.CharacterRef.FindStuntByID(reqMsg.skillTypeOrStuntID);
areas = container.CurrentActable.GetStuntAffectableAreas(stunt);
}
else
{
var skillType = SkillType.SkillTypes[reqMsg.skillTypeOrStuntID];
areas = container.CurrentActable.GetSkillAffectableAreas(skillType);
}
resp.centers = new GridPos[areas.Count];
resp.areas = new GridPos[areas.Count][];
int i = 0;
foreach (var area in areas)
{
resp.centers[i] = new GridPos()
{
row = area.Key.row, col = area.Key.col, highland = area.Key.highland
};
var gridList = area.Value;
int gridCount = area.Value.Count;
resp.areas[i] = new GridPos[gridCount];
for (int j = 0; j < gridCount; ++j)
{
resp.areas[i][j] = new GridPos()
{
row = gridList[j].row, col = gridList[j].col, highland = gridList[j].highland
};
}
++i;
}
return(resp);
}
case BattleSceneGetActionTargetCountMessage.MESSAGE_TYPE: {
if (!_canOperate || container.CurrentActable.CharacterRef.Controller != _owner)
{
break;
}
var reqMsg = (BattleSceneGetActionTargetCountMessage)request;
var resp = new BattleSceneActionTargetCountMessage();
if (reqMsg.isStunt)
{
var stunt = container.CurrentActable.CharacterRef.FindStuntByID(reqMsg.skillTypeOrStuntID);
resp.count = stunt.BattleMapProperty.targetMaxCount;
}
else
{
var skillType = SkillType.SkillTypes[reqMsg.skillTypeOrStuntID];
resp.count = container.CurrentActable.CharacterRef.GetSkill(skillType).BattleMapProperty.targetMaxCount;
}
return(resp);
}
case GetStuntTargetSelectableMessage.MESSAGE_TYPE: {
if (!_canOperate || container.CurrentActable.CharacterRef.Controller != _owner)
{
break;
}
var reqMsg = (GetStuntTargetSelectableMessage)request;
var target = container.FindObject(reqMsg.targetID);
var stunt = container.CurrentActable.CharacterRef.FindStuntByID(reqMsg.stuntID);
if (target != null && stunt != null)
{
var resp = new StuntTargetSelectableMessage();
resp.result = container.CurrentActable.CanUseStuntOnTarget(target, stunt, reqMsg.isInteract, reqMsg.action);
return(resp);
}
else
{
break;
}
}
case BattleSceneGetPassiveUsableSkillOrStuntListMessage.MESSAGE_TYPE: {
if (!container.IsChecking || container.CurrentPassive.CharacterRef.Controller != _owner)
{
break;
}
var reqMsg = (BattleSceneGetPassiveUsableSkillOrStuntListMessage)request;
if (reqMsg.stunt)
{
var resp = new BattleSceneObjectUsableStuntListMessage();
var candoList = new List <Stunt>();
if (container.CurrentPassive.CharacterRef.Stunts != null)
{
foreach (var stunt in container.CurrentPassive.CharacterRef.Stunts)
{
if (container.CanCurrentPassiveUseStunt(stunt))
{
candoList.Add(stunt);
}
}
}
resp.stunts = new CharacterPropertyDescription[candoList.Count];
for (int i = 0; i < candoList.Count; ++i)
{
resp.stunts[i] = StreamableFactory.CreateCharacterPropertyDescription(candoList[i]);
}
return(resp);
}
else
{
var resp = new BattleSceneObjectUsableSkillListMessage();
var candoList = new List <SkillType>();
foreach (var skillType in SkillType.SkillTypes)
{
if (container.CanCurrentPassiveUseSkill(skillType.Value))
{
candoList.Add(skillType.Value);
}
}
resp.skillTypes = new SkillTypeDescription[candoList.Count];
for (int i = 0; i < candoList.Count; ++i)
{
resp.skillTypes[i] = StreamableFactory.CreateSkillTypeDescription(candoList[i]);
}
return(resp);
}
}
default:
break;
}
return(null);
} catch (Exception e) {
Logger.WriteLine(e.Message);
return(null);
}
}
private Message GetCharacterPropertiesDescriptionData(Character character, GetCharacterDataMessage.DataType dataType)
{
CharacterPropertiesDescriptionMessage message;
switch (dataType)
{
case GetCharacterDataMessage.DataType.ASPECTS:
message = new CharacterAspectsDescriptionMessage();
message.properties = new CharacterPropertyDescription[character.Aspects.Count];
for (int i = 0; i < character.Aspects.Count; ++i)
{
message.properties[i] = StreamableFactory.CreateCharacterPropertyDescription(character.Aspects[i]);
}
break;
case GetCharacterDataMessage.DataType.CONSEQUENCES:
message = new CharacterConsequencesDescriptionMessage();
if (character.Consequences == null)
{
message.properties = new CharacterPropertyDescription[0];
}
else
{
message.properties = new CharacterPropertyDescription[character.Consequences.Count];
for (int i = 0; i < character.Consequences.Count; ++i)
{
message.properties[i] = StreamableFactory.CreateCharacterPropertyDescription(character.Consequences[i]);
}
}
break;
case GetCharacterDataMessage.DataType.EXTRAS:
message = new CharacterExtrasDescriptionMessage();
if (character.Extras == null)
{
message.properties = new CharacterPropertyDescription[0];
}
else
{
message.properties = new CharacterPropertyDescription[character.Extras.Count];
for (int i = 0; i < character.Extras.Count; ++i)
{
message.properties[i] = StreamableFactory.CreateCharacterPropertyDescription(character.Extras[i]);
}
}
break;
case GetCharacterDataMessage.DataType.STUNTS:
message = new CharacterStuntsDescriptionMessage();
if (character.Stunts == null)
{
message.properties = new CharacterPropertyDescription[0];
}
else
{
message.properties = new CharacterPropertyDescription[character.Stunts.Count];
for (int i = 0; i < character.Stunts.Count; ++i)
{
message.properties[i] = StreamableFactory.CreateCharacterPropertyDescription(character.Stunts[i]);
}
}
break;
default:
return(null);
}
message.characterID = character.ID;
return(message);
}
