//-------------------------------------------------------------------------------------[]
private void SetBothRoleAccord(
DraftScenario draftScenario,
IStoryAction action)
{
SetActiveRoleAccord(draftScenario, action.ActiveActor);
SetPassiveRoleAccord(draftScenario, action.PassiveActor);
}
//-------------------------------------------------------------------------------------[]
private void WriteActiveFighterScenarioLine(
IStoryAction action,
DraftScenario draftScenario)
{
if (!action.ActiveActor.HasValue())
{
return;
}
SetActiveRoleAccord(draftScenario, action.ActiveActor);
SetLastCodeAsBase(draftScenario);
var piece = string.Empty;
if (action.ActiveColor == _blueAuraColor)
{
piece = GetChooseCharBlueScenario();
}
if (action.ActiveColor == _redAuraColor)
{
piece = GetChooseCharRedScenario();
}
if (!string.IsNullOrEmpty(piece))
{
AddPiece(draftScenario, piece);
}
}
//-------------------------------------------------------------------------------------[]
private void AddAttackPiece(
DraftScenario draftScenario,
IStoryAction action,
string piece)
{
AddPiece(draftScenario, ConvertAttackScenario(action, piece));
}
//-------------------------------------------------------------------------------------[]
private void AddAttackChargePieceForBlue(
DraftScenario draftScenario,
IStoryAction action,
string piece)
{
AddPiece(draftScenario, ConvertAttackChargeScenarioForBlue(action, piece));
}
private static void enqueueAttachActions(IStoryAction <UintT> storyAction, CM.DomainAction domainAction, CM.Animation effectingAnimation,
FireBoltActionList aaq, string parentActionId, bool implicitActorInstantiation)
{
foreach (CM.AttachAction aa in domainAction.AttachActions)
{
float startTick = 0;
string actorName = null;
string parentName = null;
bool attach = false;
foreach (CM.DomainActionParameter domainActionParameter in domainAction.Params)
{
if (domainActionParameter.Name == aa.ActorNameParamName)
{
getActionParameterValue(storyAction, domainActionParameter, out actorName);
//TODO fail gracefully if we don't find actor param value
}
else if (domainActionParameter.Name == aa.ParentParamName)
{
getActionParameterValue(storyAction, domainActionParameter, out parentName);
//TODO fail gracefully if we don't find parent param value
}
}
attach = aa.Attach;
startTick = getStartTick(storyAction, aa, effectingAnimation);
if ((!implicitActorInstantiation || actorWillBeInstantiated(actorName)) &&
Create.ValidForConstruction(actorName, parentName))
{
aaq.Add(new Attach(startTick, actorName, parentName, attach)
{
ParentActionId = parentActionId
});
}
}
}
private static void enqueueDestroyActions(IStoryAction <UintT> storyAction, CM.DomainAction domainAction,
CM.Animation effectingAnimation, FireBoltActionList aaq,
string parentActionId, bool implicitActorInstantiation)
{
foreach (CM.DestroyAction da in domainAction.DestroyActions)
{
float startTick = 0;
string actorName = null;
foreach (CM.DomainActionParameter domainActionParameter in domainAction.Params)
{
if (domainActionParameter.Name == da.ActorNameParamName)
{
if (!getActionParameterValue(storyAction, domainActionParameter, out actorName) ||
(implicitActorInstantiation && !actorWillBeInstantiated(actorName)))
{
break;
}
}
}
startTick = getStartTick(storyAction, da, effectingAnimation);
if (Destroy.ValidForConstruction(actorName))
{
aaq.Add(new Destroy(startTick, actorName)
{
ParentActionId = parentActionId
});
}
}
}
//-------------------------------------------------------------------------------------[]
private void WritePowerUpCastingScenarioLine(
IStoryAction action,
DraftScenario draftScenario)
{
SetBothRoleAccord(draftScenario, action);
SetLastCodeAsBase(draftScenario);
var attackView = GetAttackView(action);
if (action.EquipmentType ==
Constants.Spells.Lightning)
{
AddAttackPiece(draftScenario, action, GetAttackRedPowerUpPiece(action));
AddAttackBluePiece(draftScenario, action, attackView);
}
else
{
switch (attackView)
{
case AttackView.Death:
case AttackView.Fatality:
AddAttackPiece(draftScenario, action, GetAttackBlueDeathScenario(action));
break;
default:
AddAttackPiece(draftScenario, action, GetAttackBlueLiveScenario(action));
break;
}
}
}
//===============================================================================================[]
#endregion
#region ScenarioLines
//===============================================================================================[]
private void WriteAttackScenarioLine(
IStoryAction action,
DraftScenario draftScenario)
{
SetBothRoleAccord(draftScenario, action);
SetLastCodeAsBase(draftScenario);
var attackView = GetAttackView(action);
switch (attackView)
{
case AttackView.Self: {
AddAttackPiece(draftScenario, action, GetAttackSelfScenario(action));
break;
}
case AttackView.Fatality: {
AddAttackFatalityRedPiece(draftScenario, action);
AddAttackBluePiece(draftScenario, action, attackView);
break;
}
default: {
AddAttackRedPiece(draftScenario, action);
AddAttackBluePiece(draftScenario, action, attackView);
break;
}
}
}
private static float getStartTick(IStoryAction <UintT> storyAction, CM.FireBoltAction fireBoltAction, CM.Animation effectingAnimation)
{
float startTick = 0;
startTick = storyAction.Time.Start.ToMillis(cm.MillisPerTick);
startTick += getEffectorAnimationOffset(effectingAnimation, fireBoltAction);
return(startTick);
}
private static void enqueueRotateActions(IStoryAction <UintT> storyAction, CM.DomainAction domainAction,
CM.Animation effectingAnimation, FireBoltActionList aaq,
string parentActionId, bool implicitActorInstantiation)
{
foreach (CM.RotateAction ra in domainAction.RotateActions)
{
float startTick = 0;
float endTick = 0;
string actorName = null;
float? targetDegrees = null;
Vector2?targetPoint = null;
foreach (CM.DomainActionParameter domainActionParameter in domainAction.Params)
{
if (domainActionParameter.Name == ra.ActorNameParamName)
{
if (!getActionParameterValue(storyAction, domainActionParameter, out actorName) ||
(implicitActorInstantiation && !actorWillBeInstantiated(actorName)))
{
break;
}
}
else if (domainActionParameter.Name == ra.DestinationParamName)
{
IActionProperty targetOrientation;
if (storyAction.TryGetProperty(domainActionParameter.Name, out targetOrientation))
{
if (targetOrientation.Value.Value is float)
{
targetDegrees = (float)targetOrientation.Value.Value;
if (targetOrientation.Range.Name == "x+degrees")
{
targetDegrees = targetDegrees.Value.convertSourceEngineToUnityRotation();
}
}
else if (targetOrientation.Value.Value is Coordinate2D)
{
targetPoint = new Vector2((float)((Coordinate2D)targetOrientation.Value.Value).X,
(float)((Coordinate2D)targetOrientation.Value.Value).Y);
}
}
else
{
Debug.LogError("orientation not set for stepId[" + storyAction.Name + "]");
}
}
}
startTick = getStartTick(storyAction, ra, effectingAnimation);
endTick = getEndTick(storyAction, ra, effectingAnimation, startTick);
var targetRotation = new Vector3Nullable(null, targetDegrees, null);
if (Rotate.ValidForConstruction(actorName, targetRotation, targetPoint))
{
aaq.Add(new Rotate(startTick, endTick, actorName, targetRotation, targetPoint)
{
ParentActionId = parentActionId
});
}
}
}
//-------------------------------------------------------------------------------------[]
private void AddAttackRedPiece(
DraftScenario draftScenario,
IStoryAction action)
{
var scenario = GetAttackRedScenario(action);
var piece = ConvertHexesToFly(action, scenario);
AddAttackPiece(draftScenario, action, piece);
}
public ActionChain(string firstActionUid)
{
this.Valid = true;
this.actions = new List <IStoryAction>();
IDataController dataController = Service.Get <IDataController>();
string text = firstActionUid;
this.recursiveCounter = 0;
bool flag = true;
while (!string.IsNullOrEmpty(text) && this.recursiveCounter < 500)
{
this.recursiveCounter++;
if (this.recursiveCounter > 500)
{
Service.Get <StaRTSLogger>().ErrorFormat("Bad Metadata. The story chain that starts with {0} has caused a loop.", new object[]
{
firstActionUid
});
this.Valid = false;
return;
}
try
{
StoryActionVO vo = dataController.Get <StoryActionVO>(text);
IStoryAction storyAction = StoryActionFactory.GenerateStoryAction(vo, this);
this.actions.Add(storyAction);
text = storyAction.Reaction;
if (storyAction is EndChainStoryAction)
{
flag = false;
}
}
catch (KeyNotFoundException ex)
{
Service.Get <StaRTSLogger>().ErrorFormat("Error in Story Chain Starting with {0}. Could not find Action {1}. {2}", new object[]
{
firstActionUid,
text,
ex.get_Message()
});
this.Valid = false;
return;
}
}
if (flag)
{
IStoryAction item = StoryActionFactory.GenerateStoryAction(new StoryActionVO
{
ActionType = "EndChain",
Uid = "autoEnd" + Service.Get <QuestController>().AutoIncrement()
}, this);
this.actions.Add(item);
}
this.currentActionIndex = -1;
this.PrepareNextAction();
}
private static CM.Animation getEffectingAnimation(IStoryAction <UintT> storyAction, CM.DomainAction domainAction)
{
//find effector if any
CM.AnimateAction effectorAnimateAction = domainAction.AnimateActions.Find(x => x.Effector);
//didn't find an effector for this domain action...move along; nothing to see here
if (effectorAnimateAction == null)
{
return(null);
}
string effectorActorName = null;
CM.AnimationMapping effectorAnimationMapping = null;
CM.Animation effectingAnimation = null;
foreach (CM.DomainActionParameter domainActionParameter in domainAction.Params)
{
if (domainActionParameter.Name == effectorAnimateAction.ActorNameParamName)
{
IActionProperty actorNameProperty;
if (storyAction.TryGetProperty(domainActionParameter.Name, out actorNameProperty))
{
effectorActorName = actorNameProperty.Value.Name;
}
if (effectorActorName == null)
{
Debug.LogError("actorName not set for stepId[" + storyAction.Name + "]");
return(null);
}
string abstractEffectorActorName;
if (!getAbstractActorName(effectorActorName, out abstractEffectorActorName))
{
Extensions.Log("Failed to find effectorActorName[{0}] in hierarchy for stepid[{1}]", effectorActorName, storyAction.Name);
return(null);
}
CM.Actor effectorActor;
if (!cm.TryGetActor(abstractEffectorActorName, out effectorActor))
{
Extensions.Log("effector actor [{0}] undefined for step[{1}]", effectorActorName, storyAction.Name);
return(null);
}
if (!effectorActor.TryGetAnimationMapping(effectorAnimateAction.Name, out effectorAnimationMapping))
{
Extensions.Log("cinematic model animation instance undefined for actor[" +
effectorActorName + "] action[" + domainAction.Name + "] paramName[" + domainActionParameter.Name + "]");
return(null);
}
effectingAnimation = cm.FindAnimation(effectorAnimationMapping.AnimationName);
if (effectingAnimation == null)
{
Debug.LogError(string.Format("animation name [{0}] undefined.", effectingAnimation));
}
}
}
return(effectingAnimation);
}
//-------------------------------------------------------------------------------------[]
private void WriteNewActorScenarioLine(
IStoryAction action,
DraftScenario draftScenario)
{
SetActiveRoleAccord(draftScenario, action.ActiveActor);
SetLastCodeAsBase(draftScenario);
var piece = GetNewActorScenario();
AddPiece(draftScenario, piece);
}
//-------------------------------------------------------------------------------------[]
private void WriteTurningScenarioLine(
IStoryAction action,
DraftScenario draftScenario)
{
SetActiveRoleAccord(draftScenario, action.ActiveActor);
SetLastCodeAsBase(draftScenario);
var piece = ConvertTurningScenario(action, GetTurnScenario());
AddPiece(draftScenario, piece);
}
//===============================================================================================[]
#endregion
//-------------------------------------------------------------------------------------[]
private void WriteScenarioLine(
DraftScenario draftScenario,
IStoryAction action)
{
if (!IsValidStoryAction(action))
{
return;
}
_writeActions[action.Type](action, draftScenario);
}
public virtual void Destroy()
{
Service.Get <StaRTSLogger>().DebugFormat("Destroying trigger {0}", new object[]
{
this.vo.Uid
});
this.vo = null;
this.parent = null;
this.prepareArgs = null;
this.updateAction = null;
}
//-------------------------------------------------------------------------------------[]
private void WriteAttackChargeScenarioLine(
IStoryAction action,
DraftScenario draftScenario)
{
SetBothRoleAccord(draftScenario, action);
SetLastCodeAsBase(draftScenario);
var attackView = GetAttackView(action);
AddAttackChargePieceForRed(draftScenario, action, GetAttackChargeRedScenario(action));
AddAttackChargeBluePiece(draftScenario, action, attackView);
}
public override void Execute()
{
base.Execute();
IStoryAction[] array = new IStoryAction[this.children.Keys.Count];
this.children.Keys.CopyTo(array, 0);
for (int i = 0; i < array.Length; i++)
{
Service.QuestController.LogAction(array[i].VO);
array[i].Execute();
}
}
private static float getEndTick(IStoryAction <UintT> storyAction, CM.FireBoltAction fireBoltAction, CM.Animation effectingAnimation, float startTick)
{
float endTick = storyAction.Time.End.ToMillis(cm.MillisPerTick);
if (fireBoltAction.MaxDuration.HasValue &&
fireBoltAction.MaxDuration.Value < storyAction.Time.End - storyAction.Time.Start)
{
endTick = startTick + fireBoltAction.MaxDuration.Value;
}
return(endTick);
}
public void ChildPrepared(IStoryAction child)
{
this.children[child] = 1;
foreach (int current in this.children.Values)
{
if (current < 1)
{
return;
}
}
this.parent.ChildPrepared(this);
}
private static CM.DomainAction getStoryDomainAction(IStoryAction action)
{
//check if the step action is in the domain of cinematic model
foreach (CM.DomainAction domainAction in cm.DomainActions)
{
if (string.Equals(domainAction.Name, action.ActionType.Name, StringComparison.OrdinalIgnoreCase))
{
return(domainAction);
}
}
return(null);
}
public void ChildComplete(IStoryAction child)
{
this.children[child] = 2;
foreach (int current in this.children.Values)
{
if (current < 2)
{
return;
}
}
this.parent.ChildComplete(this);
}
private static bool getActionParameterValue(IStoryAction <UintT> storyAction, CM.DomainActionParameter domainActionParameter, out string parameterValueName)
{
parameterValueName = null;
IActionProperty ParamNameProperty;
if (storyAction.TryGetProperty(domainActionParameter.Name, out ParamNameProperty))
{
parameterValueName = ParamNameProperty.Value.Name;
return(true);
}
Extensions.Log(domainActionParameter.Name + " not set for stepId[" + storyAction.Name + "]");
return(false);
}
public AbstractStoryTrigger(StoryTriggerVO vo, ITriggerReactor parent)
{
this.vo = vo;
this.parent = parent;
this.Reaction = vo.Reaction;
if (!string.IsNullOrEmpty(vo.PrepareString))
{
this.prepareArgs = vo.PrepareString.Split(new char[]
{
'|'
});
}
else
{
this.prepareArgs = new string[0];
}
if (!string.IsNullOrEmpty(vo.UpdateAction))
{
IDataController dataController = Service.Get <IDataController>();
try
{
StoryActionVO storyActionVO = dataController.Get <StoryActionVO>(vo.UpdateAction);
this.updateAction = StoryActionFactory.GenerateStoryAction(storyActionVO, this);
if (!string.IsNullOrEmpty(this.updateAction.VO.Reaction))
{
Service.Get <StaRTSLogger>().ErrorFormat("Story chaining is not currently supported for UIActions. {0}, {1}", new object[]
{
vo.Uid,
vo.UpdateAction
});
}
}
catch (KeyNotFoundException ex)
{
Service.Get <StaRTSLogger>().ErrorFormat("Error in StoryTrigger {0}. Could not find UiAction {1}.", new object[]
{
vo.Uid,
vo.UpdateAction
});
throw ex;
}
}
}
//-------------------------------------------------------------------------------------[]
private static AttackView GetAttackView(IStoryAction action)
{
if (action.ActiveActor ==
action.PassiveActor)
{
return(AttackView.Self);
}
if (action.IsFatality)
{
return(AttackView.Fatality);
}
if (action.WithDeath)
{
return(AttackView.Death);
}
if (action.WithoutDamage)
{
return(AttackView.Block);
}
return(AttackView.Live);
}
//-------------------------------------------------------------------------------------[]
private void AddAttackChargeBluePiece(
DraftScenario draftScenario,
IStoryAction action,
AttackView attackView)
{
switch (attackView)
{
case AttackView.Live:
AddAttackChargePieceForBlue(draftScenario, action, GetAttackChargeBlueLiveScenario(action));
break;
case AttackView.Death:
AddAttackChargePieceForBlue(draftScenario, action, GetAttackChargeBlueDeathScenario(action));
break;
case AttackView.Fatality:
AddAttackChargePieceForBlue(draftScenario, action, GetAttackChargeBlueDeathScenario(action));
break;
case AttackView.Block:
AddAttackChargePieceForBlue(draftScenario, action, GetAttackChargeBlueMissScenario(action));
break;
}
}
//-------------------------------------------------------------------------------------[]
private void AddAttackBluePiece(
DraftScenario draftScenario,
IStoryAction action,
AttackView attackView)
{
switch (attackView)
{
case AttackView.Live: {
var scenario = GetAttackBlueLiveScenario(action);
var piece = ConvertHexesToFly(action, scenario);
AddAttackPiece(draftScenario, action, piece);
}
break;
case AttackView.Death: {
var scenario = GetAttackBlueDeathScenario(action);
var piece = ConvertHexesToFly(action, scenario);
AddAttackPiece(draftScenario, action, piece);
}
break;
case AttackView.Block: {
var scenario = GetAttackBlueMissScenario(action);
var piece = ConvertHexesToFly(action, scenario);
AddAttackPiece(draftScenario, action, piece);
}
break;
case AttackView.Fatality: {
var scenario = GetAttackBlueFatalityScenario(action);
var piece = ConvertHexesToFly(action, scenario);
AddAttackPiece(draftScenario, action, piece);
}
break;
}
}
public virtual void ChildComplete(IStoryAction action)
{
}
public virtual void ChildPrepared(IStoryAction action)
{
this.updateActionPrepared = true;
}
