private void _SelectAction_Enter()
{
_currentSelectAction = new TargetedAction()
{
Instigator = CurrentActingPartyMember
};
}
public CCTargetedActionState(CCTargetedAction action, CCNode target)
: base(action, target)
{
ForcedTarget = action.ForcedTarget;
TargetedAction = action.TargetedAction;
ActionState = (CCFiniteTimeActionState)TargetedAction.StartAction(ForcedTarget);
}
public JTargetedActionState(JTargetedAction action, GameObject target)
: base(action, target)
{
ForcedTarget = action.ForcedTarget;
TargetedAction = action.TargetedAction;
ActionState = (JFiniteTimeActionState)TargetedAction.StartAction(ForcedTarget);
}
public void SetStatus(Status status, TargetedAction action)
{
Current = status;
if (Current == Status.None && _statusEffect != null)
{
Destroy(_statusEffect.gameObject);
}
else if (action != null)
{
_statusEffect = action;
_statusEffect.SetReciever(_character);
}
if (StatusChanged != null)
{
StatusChanged.Invoke(new StatusChangeEvent(_character, status));
}
}
public bool SetPlayerStatus(Status status, Character target)
{
if (target.Status.Current == Status.None)
{
TargetedAction instance = null;
switch (status)
{
case Status.Poisoned: instance = Create(Poison); break;
}
target.Status.SetStatus(status, instance);
return(true);
}
else
{
return(false);
}
}
private void ConnectTargets(EventNode Event, ActionNode Action)
{
if (!(Action.DotaAction is TargetedAction))
{
return; //An action without targets doesn't need it's nodes resolved
}
TargetedAction ta = Action.DotaAction as TargetedAction;
if (ta.Target.Preset == null)
{
return; //Not a preset. TODO: Generated a Make Target node with the details of this target key
}
var outputItem = Event.GetTargetNodeFor(ta.Target.Preset);
if (outputItem == null)
{
return;
}
graphControl1.Connect(outputItem, Action.TargetPin);
}
private List <Character> FindPotentialActionTargets(TargetedAction targetedAction)
{
List <Character> potentialTargets = new List <Character>();
switch (_currentTargetType)
{
case TargetType.AllEnemiesExclusive:
potentialTargets = CharacterManager.Instance.GetNonTargetedAliveEnemies(_attatchedPlayer);
break;
case TargetType.AllEnemiesInclusive:
potentialTargets = CharacterManager.Instance.GetAliveEnemies();
break;
case TargetType.AllPlayersExclusive:
potentialTargets = CharacterManager.Instance.GetNonTargetedAlivePlayers(_attatchedPlayer);
break;
case TargetType.AllPlayersInclusive:
potentialTargets = CharacterManager.Instance.GetAlivePlayers();
break;
case TargetType.EnemySingle:
potentialTargets = CharacterManager.Instance.GetNonTargetedAliveEnemies(_attatchedPlayer);
break;
case TargetType.PlayersSingle:
potentialTargets = CharacterManager.Instance.GetNonTargetedAlivePlayers(_attatchedPlayer);
break;
case TargetType.Self:
potentialTargets.Add(_attatchedPlayer);
break;
}
return(potentialTargets);
}
protected BuildingCard( string n, string code, int cost, int start,
TargetedAction run = null, TargetedAction up = null, PlayableTester test = null ) :
base(n,code,run,test) {
energyCost = cost; startingEnergy = start; upgrader = up;
}
protected EventCard( string n, string c, TargetedAction a=null, PlayableTester t=null ) : base(n,c,a,t) {}
protected GameCard( string n, string c, TargetedAction a = null, PlayableTester t = null ) {
name = n; code = c; runner = a; tester = t;
allCards.Add (c, this);
}
public override CCFiniteTimeAction Reverse()
{
return(new CCTargetedAction(ForcedTarget, TargetedAction.Reverse()));
}
public ExecuteableAction(Character targeter, TargetedAction action)
{
Targeter = targeter;
ActionToApply = action;
Targets = new List <Character>();
}
void ExecuteQueue()
{
try{
bool ready=false;
foreach(MudCharacter character in NonPlayersInRoom)
{
character.StartTurn();
}
foreach(MudCharacter character in PlayersInRoom)
{
character.StartTurn();
}
//give all characters a chance to put in an action
while(!ready)
{
lock(lockobject){
foreach(MudCharacter character in PlayersInRoom) //test for an action from all characters
{
ready=false;
foreach(CharacterAction action in ActionQueue)
{
if(action.Character==character)
{
ready=true;
break;
}
}
if(!ready)
{
break;
}
}
if(DateTime.Now>time) //if time is up execute all actions in the queue
{
if(ActionQueue.Count==0&&PlayersInRoom.Count>0)
{
time=DateTime.Now.AddSeconds(timeoutSeconds);
}else{
ready=true;
}
}
}
Thread.Sleep(100);
}
lock(lockobject)
{
while(ActionQueue.Count>0)
{
CharacterAction action=ActionQueue.Dequeue();
//skip actions by characters no longer in room(probably dead)
if(action.Character is PlayerCharacter)
{
if(!PlayersInRoom.Contains(action.Character as PlayerCharacter))
{
continue;
}
}else{
if(!NonPlayersInRoom.Contains(action.Character))
{
continue;
}
}
//skip actions on targets no longer in room
if(action is TargetedAction)
{
TargetedAction ta=(action as TargetedAction);
if(ta.Target is PlayerCharacter)
{
if(!PlayersInRoom.Contains(ta.Target as PlayerCharacter))
{
continue;
}
}else{
if(!NonPlayersInRoom.Contains(ta.Target))
{
continue;
}
}
}
string msg=action.DoAction();
NotifyPlayers(msg);
//test for death
//funky loops because the lists we're iterating might be changed
foreach(MudCharacter c in GetCharactersInRoom())
{
if(c.HitPoints<=0)
{
NotifyPlayers("\t{0} has died.",c.StatusString());
c.OnDeath();
RemoveCharacter(c);
}
}
}
foreach(MudCharacter c in GetCharactersInRoom())
{
c.EndTurn();
if(c.HitPoints<=0)
{
NotifyPlayers("\t{0} has died.",c.StatusString());
c.OnDeath();
RemoveCharacter(c);
}
}
Status=GenerateStatus();
}
Thread.Sleep(100);
lock(lockobject)
{
if(PlayersInRoom.Count==0){
ActionQueue.Clear();
ActionTask=null;
time=DateTime.MinValue;
}else{
time=DateTime.Now.AddSeconds(timeoutSeconds);
ActionTask=Task.Factory.StartNew(new Action(ExecuteQueue));
}
}
}catch(Exception ex){
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
}
}
