//-------------------------------------------------------------------------------------[] 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; }