//Messaging
public void GenerateMessage(GameObject recipient, string text)
{
GameObject MessageSphereInstance = Instantiate(prefabMessageSphereInstance, transform.position, transform.rotation) as GameObject; //Instantiate message sphere prefab
MessageSphereInstance.transform.parent = recipient.transform;
MessageFunctionality mf = MessageSphereInstance.GetComponent <MessageFunctionality>();
mf.sender = this.gameObject; //Tell the message who the sender is
mf.recipient = recipient;
mf.msg = text;
//For spreading marking appropriately
mf.representationHolding = GetComponent <MarkerFunctionality>().representationHolding; //Set the current marker to the message
Debug.Log("New instance of message created from " + this.gameObject.ToString() + " for " + recipient.gameObject.ToString());
mf.isActive = true;
ActorFunctionality raf = recipient.GetComponent <ActorFunctionality>();
if (raf.messageQueueBox.GetComponent <MessageQueueFunctionality>().messageQueue.Count == 0)
{
//set the status accordingly (this is the only message in the queue)
recipient.GetComponent <MarkerFunctionality>().MessageMark(mf.representationHolding);
}
raf.messageQueueBox.GetComponent <MessageQueueFunctionality>().EnqueueToMsgQueue(MessageSphereInstance); //Enqueue the message
}
public void ActScene()
{
//if invalid data is received just assume a winner to avoid a crash
if (!ActorFunctionality.ActorListHasMembers(this.Actors) && !ActorFunctionality.ActorListHasMembers(this.Enemies))
{
this.WinnerSide = CombatEnums.SideEnum.Left;
return;
}
this.SetSides();
//determine which side starts;
this.CurrentSide = CombatEnums.SideEnum.Left;
//determine which combatants start, on both sides
this.CurrentActor = this.Actors.First();
this.CurrentEnemy = this.Enemies.First();
//main combat loop, runs until one side is obliterated
bool combatContinues = true;
while (combatContinues)
{
combatContinues = this.Act();
}
}
private bool Act()
{
bool result = false;
this.CombatFormulas.ApplyDamage(this.CurrentActor, this.CurrentEnemy);
if (this.CurrentEnemy.CurrentStats.HitPoints <= 0)
{
if (ActorFunctionality.ActorListHasOtherAliveMembers(this.DetermineEnemyData(), this.CurrentEnemy))
{
result = true;
this.ContinueCombat();
}
else
{
this.WinnerSide = this.CurrentSide;
}
}
else
{
result = true;
this.ContinueCombat();
}
return(result);
}
private void ActivateFirstAliveActor()
{
if (this.CurrentSide == CombatEnums.SideEnum.Left)
{
this.CurrentActor = ActorFunctionality.DetermineFirstAliveActor(this.Actors);
this.CurrentEnemy = ActorFunctionality.DetermineFirstAliveActor(this.Enemies);
}
else
{
this.CurrentActor = ActorFunctionality.DetermineFirstAliveActor(this.Enemies);
this.CurrentEnemy = ActorFunctionality.DetermineFirstAliveActor(this.Actors);
}
}
public static void Handle(MessageDropped currEvent)
{
//Do some animation to show disappearing message
//Currently, this is visualized like MessageReceived
ActorFunctionality af = Actors.allActors[currEvent.receiverId].GetComponent <ActorFunctionality>();
af.ReceiveMessageFromQueueDiscreetly();
if (logCreateForEvent)
{
//Create a Log of it
Log newLog = new Log(0, "Message dropped : " + currEvent.receiverId);
VisualizationHandler.Handle(newLog);
}
}
public static void Handle(MessageReceived currEvent)
{
GameObject recGO = Actors.allActors[currEvent.receiverId];
//Use dictionary of actors to do this
ActorFunctionality af = recGO.GetComponent <ActorFunctionality>();
af.ReceiveMessageFromQueueDiscreetly(Actors.allActors[currEvent.senderId]);
if (logCreateForEvent)
{
//Create a Log of it
Log newLog = new Log(0, "Message received : " + currEvent.receiverId + ", message : " + currEvent.msg);
VisualizationHandler.Handle(newLog);
}
}
public static void Handle(MessageSent currEvent)
{
GameObject senderGO = Actors.allActors[currEvent.senderId];
//Use dictionary of actors to do this
ActorFunctionality af = senderGO.GetComponent <ActorFunctionality>();
af.GenerateMessageDiscreetly(Actors.allActors[currEvent.receiverId], currEvent.msg);
if (logCreateForEvent)
{
//Create a Log of it
Log newLog = new Log(0, "Message sent : " + currEvent.senderId + " to " + currEvent.receiverId + ", message : " + currEvent.msg);
VisualizationHandler.Handle(newLog);
}
}
/// <summary>
/// this allows us to add spells which cause a combatant to switch sides for a while, for example
/// </summary>
private void SetSides()
{
if (ActorFunctionality.ActorListHasMembers(this.Actors))
{
foreach (var actor in this.Actors)
{
actor.CombatSide = CombatEnums.SideEnum.Left;
}
}
if (ActorFunctionality.ActorListHasMembers(this.Enemies))
{
foreach (var enemy in this.Enemies)
{
enemy.CombatSide = CombatEnums.SideEnum.Right;
}
}
}
IEnumerator Start()
{
while (true) //Execute indefinitely
{
if (Trace.stepEvents.Count == 0 && Trace.stepStates.Count == 0) //If there are no historical steps to be implemented
{
yield return(new WaitForSeconds(timeDelay)); //Time delay for each event visualization
if (!UserInputHandler.isPaused)
{
if (Trace.NewStepPossible())
{
audioS.Play(); //Play a sound
if (!Trace.allEvents[Trace.pointerToCurrAtomicStep][Trace.pointerToCurrEvent].isSuppressed)
{
Trace.allEvents[Trace.pointerToCurrAtomicStep][Trace.pointerToCurrEvent].HandleOutline(); //Do the outlining
yield return(new WaitForSeconds(0.25f)); //Time delay for actual visualization
Trace.allEvents[Trace.pointerToCurrAtomicStep][Trace.pointerToCurrEvent].HandleVisualization();
}
else
{
Trace.allEvents[Trace.pointerToCurrAtomicStep][Trace.pointerToCurrEvent].HandleDiscreetly();
}
rootOfActors.BroadcastMessage("NewTraceStep", SendMessageOptions.DontRequireReceiver);
Trace.IncrementPointer(); //Let's move to the next event
}
}
}
else //There ARE historical steps to be implemented
{
Debug.Log("Implementing step response");
bool prevLogDispValue = DiscreetHandler.logCreateForEvent;
DiscreetHandler.logCreateForEvent = false; //Because it does not make sense to display logs of this
//Empty all message queues
foreach (var item in Actors.allActors)
{
ActorFunctionality af = item.Value.GetComponent <ActorFunctionality>();
af.messageQueueBox.GetComponent <MessageQueueFunctionality>().EmptyQueue(); //Empty all actors' queues
//Clear all markings
Markers.Initialize();
rootOfActors.BroadcastMessage("ClearMark");
//Clear breakpoints
rootOfActors.BroadcastMessage("ClearTag");
}
foreach (ActorEvent ev in Trace.stepEvents) //Handle each event discreetly
{
ev.HandleDiscreetly();
}
foreach (State st in Trace.stepStates) //Set the states now as all events have been handled
{
NetworkInterface.StateUnwrapper(st);
}
DiscreetHandler.logCreateForEvent = prevLogDispValue;
Trace.stepEvents = new List <ActorEvent>(); //Reset the list as everything has been implelented
}
}
}
