private void Awake()
{
_nComponents = 5;
_voxelSize = 0.375f;
_existingParts = new List <Part>();
_agents = new List <ConfigurablePartAgent>();
_spaces = new List <PPSpace>();
_boundaries = new List <Voxel>();
_tenants = new List <Tenant>();
_spaceRequests = new List <PPSpaceRequest>();
_reconfigurationRequests = new List <ReconfigurationRequest>();
_activeRequest = null;
_hourStep = 0.05f;
_hour = 8;
InitializedAgents = 0;
_showDebug = true;
_compiledMessage = new string[2];
_showRawBoundaries = false;
_showSpaces = true;
_showSpaceData = false;
_showVoxels = false;
_activityLog = "";
_timePause = true;
//_regularBorder = Resources.Load<Sprite>("Textures/RectangularBorder");
//_activeBorder = Resources.Load<Sprite>("Textures/RectangularBorder_Active");
_cam = Camera.main;
}
/// <summary>
/// Sets one of the existing spaces to be reconfigured
/// </summary>
protected virtual void SetRandomSpaceToReconfigure(int areaDirection, int connectivityDirection)
{
PPSpace space = new PPSpace();
bool validRequest = false;
while (!validRequest)
{
UnityEngine.Random.InitState(System.DateTime.Now.Millisecond);
int i = UnityEngine.Random.Range(0, _spaces.Count);
space = _spaces[i];
if (space.BoundaryParts.Count > 0 && !space.IsSpare)
{
validRequest = true;
}
}
//Set area to be increased
ReconfigurationRequest rr = new ReconfigurationRequest(space, areaDirection, connectivityDirection);
_reconfigurationRequests = new List <ReconfigurationRequest>();
_reconfigurationRequests.Add(rr);
//Start requesting the first action
//rr.RequestNextAction();
}
public bool EvaluateReconfiguration(ReconfigurationRequest request)
{
//Console.WriteLine("[ConfigurationManager.EvaluateReconfiguration] Avaliando a reconfiguração");
lock (thisLock) {
if (!reconfiguring)
{
this.reconfiguring = true;
this.evaluations = SecurityAnalyzer.Evaluate(request, unit);
if (SecurityAnalyzer.isDeadlockFree(evaluations, unit))
{
this.request = request;
return(true);
}
else
{
this.evaluations = null;
this.reconfiguring = false;
return(false);
}
}
else
{
throw new Exception("Já existe uma reconfiguração em andamento. " +
" Esta deverá ser confirmada ou cancelada antes de nova submissão.");
}
}
//Console.WriteLine("[ConfigurationManager.EvaluateReconfiguration] Avaliação Finalizada");
}
public void CancelReconfiguration()
{
lock (thisLock) {
this.reconfiguring = false;
this.evaluations = null;
this.request = null;
}
}
/// <summary>
/// Checks if the reconfiguration subject of a request is still valid or has been destroyed
/// </summary>
/// <param name="request">The request to be assessed</param>
/// <returns>An integer representing the result of the action
/// 0 = valid;
/// 1 = successful;
/// 2 = destroyed the space</returns>
public int CheckResultFromRequest(ReconfigurationRequest request)
{
int result = 1;
Guid spaceId = request.SpaceId;
int checkCount = _spaces.Count(s => s.SpaceId == spaceId);
if (checkCount == 1)
{
PPSpace space = MainGrid.GetSpaceById(spaceId);
if (space != null)
{
//Space still exists, evaluate if reconfiguration was successful
bool success = request.ReconfigurationSuccessful(space);
request.CurrentIndices = space.Indices.ToArray();
if (success)
{
_reconfigurationRequests.Remove(request);
}
else
{
result = 0;
}
space.Reconfigure_Area = false;
space.Reconfigure_Connectivity = false;
_reconfigurationRequests.Remove(request);
}
}
else if (checkCount > 1)
{
//Space was destroyed and split into 2 or more. Differentiate new spaces
foreach (var space in _spaces.Where(s => s.SpaceId == spaceId))
{
space.SpaceId = Guid.NewGuid();
space.Reconfigure_Area = false;
space.Reconfigure_Connectivity = false;
}
_reconfigurationRequests.Remove(request);
result = 2;
}
else
{
//Space was destroyed, return false
_reconfigurationRequests.Remove(request);
result = 2;
}
return(result);
}
public bool EvaluateReconfiguration(string xmlRequest)
{
Console.WriteLine("[ConfigurationManager.EvaluateReconfiguration] Iniciando avaliação da reconfiguração...");
ReconfigurationRequest r = loader.loadRequest(xmlRequest, application);
if (r.StructuralRequest != null)
{
Console.WriteLine("[ConfigurationManager.EvaluateReconfiguration] Identificando os componentes impactos...");
r.StructuralRequest.GenerateChanges(application);
}
//Console.WriteLine("[ConfigurationManager.EvaluateReconfiguration] Requisição construída a partir do arquivo: " + xmlRequest);
bool result = EvaluateReconfiguration(r);
Console.WriteLine("[ConfigurationManager.EvaluateReconfiguration] Avaliação Concluída!");
Console.WriteLine("");
return(result);
}
/// <summary>
/// Sets one of the existing spaces to be reconfigured.
/// This overriden method replaces the behaviour brain according to the type of request
/// </summary>
protected override void SetRandomSpaceToReconfigure(int areaDirection, int connectivityDirection)
{
PPSpace space = new PPSpace();
bool validRequest = false;
while (!validRequest)
{
UnityEngine.Random.InitState(System.DateTime.Now.Millisecond);
int i = UnityEngine.Random.Range(0, _spaces.Count);
space = _spaces[i];
if (space.BoundaryParts.Count > 0 && !space.IsSpare)
{
validRequest = true;
}
}
//Create the reconfiguration request
ReconfigurationRequest rr = new ReconfigurationRequest(space, areaDirection, connectivityDirection);
_reconfigurationRequests = new List <ReconfigurationRequest>();
_reconfigurationRequests.Add(rr);
}
/// <summary>
/// Resets the grid after the an Episode is concluded
/// </summary>
public void ResetGrid(ReconfigurationRequest request, bool success)
{
_completedIndices = request.CurrentIndices;
_showCompleted = true;
if (success)
{
_completedColor = Color.green;
}
else
{
_completedColor = Color.red;
}
//StartCoroutine(AnimateCompletionAndRestart());
MainGrid.RestartGrid();
_spaces = MainGrid.Spaces;
_boundaries = MainGrid.Boundaries;
foreach (ConfigurablePartAgent partAgent in _existingParts.OfType <ConfigurablePart>().Select(p => p.CPAgent))
{
partAgent.EndEpisode();
}
}
public ReconfigurationRequest loadRequest(string xml, MetaHashComponent component)
{
ReconfigurationRequest request = null;
Console.WriteLine("[XmlLoader.loadRequest] Iniciando carga de script de reconfiguração... ");
if (true /*validator.IsValid (REQUEST_XSD, xml)*/)
{
clear();
generator.setInitialCode(component.LastIdCode);
request = new ReconfigurationRequest();
XmlDocument document = new XmlDocument();
XmlNode nodeRequest, data;
document.Load(xml);
nodeRequest = document.SelectSingleNode("reconfigurationRequest");
data = nodeRequest.SelectSingleNode("targetComponent");
request.TargetComponent = data.InnerText;
//Console.WriteLine("[XmlLoader.LoadRequest] Obtendo componente alvo {0}", request.TargetComponent);
List <MetaParameter> parameterList = uLoader.getParameters(nodeRequest.SelectNodes("parameter"));
if (parameterList != null)
{
Console.WriteLine("[XmlLoader.LoadRequest] Carregando as reconfigurações estruturais...");
request.StructuralRequest = new StructuralReconfigurationRequest(parameterList);
}
BehavioralReconfigurationRequest behavioralRequest = null;
List <MetaInnerComponent> innerComponents = generateInnerComponents(nodeRequest.SelectNodes("innerComponent"));
//Console.WriteLine("[XmlLoader.LoadRequest] Tem innerComponent para adicionar? {0}", innerComponents != null);
if (innerComponents != null)
{
behavioralRequest = new BehavioralReconfigurationRequest();
Console.WriteLine("[XmlLoader.LoadRequest] Carregando novos componentes aninhados...");
//Console.WriteLine("[XmlLoader.LoadRequest] {0} InnerComponent(s) adicionado(s)", innerComponents.Count);
behavioralRequest.NewInnerComponents = innerComponents;
uLoader.CandidateInnerComponents = innerComponents;
}
uLoader.InnerComponents = innerComponents;
XmlNodeList changeActionList = nodeRequest.SelectNodes("changeAction");
if (changeActionList != null)
{
Console.WriteLine("[XmlLoader.LoadRequest] Carregando as reconfigurações comportamentais...");
IEnumerator ienum = changeActionList.GetEnumerator();
BehavioralChange change;
XmlNode changeNode;
if (behavioralRequest == null)
{
behavioralRequest = new BehavioralReconfigurationRequest();
}
XmlAttribute attr;
int initialCode;
int aditionalStates, aditionalTrans;
aditionalStates = aditionalTrans = 0;
while (ienum.MoveNext())
{
changeNode = (XmlNode)ienum.Current;
change = new BehavioralChange();
//Console.WriteLine("[XmlLoader.LoadRequest] Criando uma nova BehavioralChange");
initialCode = generator.getCurrentCode();
attr = (XmlAttribute)changeNode.Attributes.GetNamedItem("unit");
change.Unit = attr.Value;
//Console.WriteLine("[XmlLoader.LoadRequest] Unit a sofrer alteração: {0}", change.Unit);
MetaUnit u = component.Units[change.Unit];
if (u != null)
{
//Console.WriteLine("[XmlLoader.LoadRequest] Unit {0} encontrada!", change.Unit);
attr = (XmlAttribute)changeNode.Attributes.GetNamedItem("action");
change.Action = attr.Value;
//Console.WriteLine("[XmlLoader.LoadRequest] Ação a sofrer alteração: {0}", change.Action);
MetaAction a = u.Actions[change.Action];
if (a != null && !a.IsNative)
{
//Console.WriteLine("[XmlLoader.LoadRequest] Ação {0} encontrada!", change.Action);
attr = (XmlAttribute)changeNode.Attributes.GetNamedItem("type");
if (attr.Value.Equals("remove"))
{
change.Type = BehavioralChange.BehavioralChangeType.REMOVE;
}
else
{
change.Type = BehavioralChange.BehavioralChangeType.INCLUDE;
}
attr = (XmlAttribute)changeNode.Attributes.GetNamedItem("point");
change.Point = attr.Value;
//Console.WriteLine("[XmlLoader.LoadRequest] Ponto a sofrer alteração: {0}", change.Point);
Transition t = a.Protocol.getTransition(change.Point);
if (t != null)
{
//Console.WriteLine("[XmlLoader.LoadRequest] Ponto {0} encontrado.", change.Point);
change.NewSlices = uLoader.getSlices(changeNode.SelectNodes("slice"));
uLoader.CandidateSlices = change.NewSlices;
if (change.Type == BehavioralChange.BehavioralChangeType.INCLUDE)
{
//Console.WriteLine("[XmlLoader.LoadRequest] Obtendo novo protocolo");
change.Transitions = uLoader.getTransitions(changeNode.SelectSingleNode("protocol").FirstChild, u, t.InitialState, t.FinalState, a.Protocol.NumStates + aditionalStates, a.Protocol.LastTransationId + aditionalTrans);
aditionalStates = uLoader.NumStates - a.Protocol.NumStates;
aditionalTrans = uLoader.NumTransations - a.Protocol.LastTransationId;
//TODO remover
//Console.WriteLine("Transações de reconfiguração");
//foreach(Transition tst in change.Transitions) {
// Console.WriteLine(tst);
//}
}
else
{
change.Transitions = new List <Transition>();
change.Transitions.Add(new Transition(t.InitialState, t.FinalState, Configuration.LAMBDA_TRANSITION, a.Protocol.LastTransationId++));
}
}
else
{
throw new Exception("[XmlLoader.loadRequest] Ponto de reconfiguração não existe: " + change.Point);
}
}
else
{
throw new Exception("[XmlLoader.loadRequest] Ação a ser alterada não existe ou nãoo é uma configuração: " + change.Action);
}
}
else
{
throw new Exception("[XmlLoader.loadRequest] Unidade da ação a ser alterada não existe: " + change.Unit);
}
change.AditionalStates = generator.getCurrentCode() - initialCode;
behavioralRequest.AddChange(change);
}
}
request.BehavioralRequest = behavioralRequest;
component.LastIdCode = generator.getCurrentCode();
}
uLoader.CandidateSlices = null;
uLoader.CandidateInnerComponents = null;
Console.WriteLine("[XmlLoader.loadRequest] Carga de script realizada com sucesso!");
return(request);
}
/// <summary>
/// Check if there are enough requests to initialize reconfiguration. If so, pauses simulation
/// and tells the agents to store their current positions
/// </summary>
protected override void CheckForReconfiguration()
{
//If the space count (of non-spare spaces) is 0, restart the position of every other part
if (_spaces.Where(s => !s.IsSpare).Count() == 1)
{
for (int i = 0; i < _agents.Count; i++)
{
if (i % 2 == 0)
{
ConfigurablePart part = _agents[i].GetPart();
int attempt = 0;
bool success = false;
foreach (var index in part.OccupiedIndexes)
{
var voxel = MainGrid.Voxels[index.x, index.y, index.z];
voxel.IsOccupied = false;
voxel.Part = null;
}
while (!success)
{
part.JumpToNewPosition(PopSeed + attempt, out success);
attempt++;
}
}
}
FinilizeReconfiguration();
_activeRequest = null;
foreach (var agent in _agents)
{
agent.FreezeAgent();
agent.ClearRequest();
}
ResetSpacesEvaluation();
}
//If all ok, continue checking for reconfiguration
else if (_spaces.Count(s => s.Reconfigure) > 0)
{
_timePause = true;
//Get only the first one and only create one type of request.
var toReconfigure = _spaces.Where(s => s.Reconfigure).ToList();
var target = toReconfigure[0];
if (target.Reconfigure_Area)
{
//SetAreaModel();
int targetArea = 1;
if (target._areaDecrease > target._areaIncrease)
{
targetArea = -1;
}
ReconfigurationRequest rr = new ReconfigurationRequest(target, targetArea, 0);
_activeRequest = rr;
//_reconfigurationRequests.Add(rr);
}
else if (target.Reconfigure_Connectivity)
{
//SetConnectivityModel();
int targetConnec = 1;
if (target._connectivityDecrease > target._connectivityIncrease)
{
targetConnec = -1;
}
ReconfigurationRequest rr = new ReconfigurationRequest(target, 0, targetConnec);
_activeRequest = rr;
//_reconfigurationRequests.Add(rr);
}
var spaces = _spaces.Where(s => s.Reconfigure).ToList();
for (int i = 1; i < _spaces.Count(s => s.Reconfigure); i++)
{
PPSpace space = spaces[i];
space.ResetAreaEvaluation();
space.ResetConnectivityEvaluation();
space.TimesSurvived = 0;
space.TimesUsed = 0;
}
}
}
private void Update()
{
if (_showVoxels)
{
DrawState();
}
if (_showRawBoundaries)
{
DrawBoundaries();
}
if (_showSpaces)
{
DrawSpaces();
}
#region Control inputs
if (Input.GetKeyDown(KeyCode.V))
{
_showVoxels = !_showVoxels;
SetGameObjectsVisibility(_showVoxels);
}
if (Input.GetKeyDown(KeyCode.B))
{
_showRawBoundaries = !_showRawBoundaries;
}
//Slow down simulation
//if (Input.GetKeyDown(KeyCode.KeypadMinus))
//{
// _hourStep += 0.05f;
// _hourStep = Mathf.Clamp(_hourStep, 0.05f, 1f);
// //UpdateSpeedDisplay();
// //print(_hourStep);
//}
//Speed up simulation
//if (Input.GetKeyDown(KeyCode.KeypadPlus))
//{
// _hourStep -= 0.05f;
// _hourStep = Mathf.Clamp(_hourStep, 0.05f, 1f);
// //UpdateSpeedDisplay();
// //print(_hourStep);
//}
//Manual pause trigger
//if (Input.GetKeyDown(KeyCode.P))
//{
// _timePause = !_timePause;
//}
//Reconfigure and continue
//if (Input.GetKeyDown(KeyCode.Space))
//{
// FinilizeReconfiguration();
// //StartCoroutine(FinilizeReconfigurationAnimated());
//}
//if (Input.GetKeyDown(KeyCode.M))
//{
// _hourStep = 0.025f;
// //UpdateSpeedDisplay();
//}
//if (Input.GetKeyDown(KeyCode.W))
//{
// var ss = _spaces.Where(s => !s.IsSpare);
// foreach (var s in ss)
// {
// print($"{s.Name}: {s.NumberOfConnections}");
// }
//}
#endregion
//Oscilate the intensity of the colors used to represent the space
if (!_timePause)
{
_colorOscilator = ((Mathf.Sin(Time.time * 3) + 1) / 2f);
}
//Check if the reconfiguration request is finished
//if (_timePause && _reconfigurationRequests.Count > 0 && _reconfigurationRequests[0] != null)
if (_timePause && _activeRequest != null)
{
//print("Entered here");
//var request = _reconfigurationRequests[0];
if (_activeRequest.AllAgentsFinished())
{
FinilizeReconfiguration();
if (_spaces.Where(s => s.SpaceId == _activeRequest.SpaceId).Count() != 0)
{
var recSpace = _spaces.First(s => s.SpaceId == _activeRequest.SpaceId);
recSpace.ResetAreaEvaluation();
recSpace.ResetConnectivityEvaluation();
recSpace.TimesSurvived = 0;
recSpace.TimesUsed = 0;
}
_activeRequest = null;
foreach (var agent in _agents)
{
agent.FreezeAgent();
agent.ClearRequest();
}
}
//Request the next action from the agents
else
{
_activeRequest.RequestNextAction();
}
}
}
/// <summary>
/// Clears the active request assigned to this agent
/// </summary>
public void ClearRequest()
{
_activeRequest = new ReconfigurationRequest();
_stepsTaken = 0;
StepsEnded = false;
}
/// <summary>
/// Assign a request to this agent
/// </summary>
/// <param name="request">The <see cref="ReconfigurationRequest"/> to be assigned</param>
public void SetRequest(ReconfigurationRequest request)
{
_activeRequest = request;
}
/// <summary>
/// Manually sets the selected space to be reconfigured
/// </summary>
protected virtual void SetSpaceToReconfigure()
{
ReconfigurationRequest rr = new ReconfigurationRequest(_selectedSpace, 1, 0);
_reconfigurationRequests.Add(rr);
}
/*public bool CommitReconfiguration ()
* {
* Thread commit = new Thread(new ThreadStart(Commit));
* commit.Priority = ThreadPriority.Highest;
* commit.Start();
*
* return true;
* }*/
public bool CommitReconfiguration()
{
Configuration protocol;
Console.WriteLine("[ConfigurationManager.Commit] Aplicando a reconfiguração...");
lock (thisLock) {
if (reconfiguring)
{
foreach (ExecutionStateEvaluation es in evaluations)
{
protocol = unit.Actions [es.ActionName].Protocol;
protocol.stopStates(es.StatesToStop);
WaitForSafeState(protocol.ReconfigMonitor, es);
Console.WriteLine("[ConfigurationManager.Commit] Estado seguro para reconfiguração!");
if (request.StructuralRequest != null && request.StructuralRequest.Changes != null)
{
Console.WriteLine("[ConfigurationManager.Commit] Aplicando reconfigurações estruturais...");
foreach (StructuralChange sc in request.StructuralRequest.Changes)
{
if (SecurityAnalyzer.isChangeConcrete(sc))
{
Console.WriteLine("[ConfigurationManager.Commit] Reconfigurando a unidade {0}", sc.Old.Name);
createConcreteUnit(sc.New, ((IUnit)sc.Old.Entity).CID.getInstanceName() /*+ "(new)"*/);
SubstituteUnit(sc.Old, sc.New);
}
}
}
BehavioralReconfigurationRequest behavioralRequest = request.BehavioralRequest;
if (behavioralRequest != null)
{
foreach (BehavioralChange bc in behavioralRequest.Changes)
{
if (bc.NewSlices != null)
{
//Console.WriteLine("[ConfigurationManager.Commit] Adicionando novas fatias");
foreach (MetaSlice slice in bc.NewSlices.Values)
{
if (!unit.Slices.ContainsKey(slice.Inner))
{
Console.WriteLine("[ConfigurationManager.Commit] Adicionando fatia '{0}'...", slice.Inner);
createConcreteUnit(slice.Unit, slice.Inner /*+ "(new)"*/);
unit.AddSlice(slice.Inner, slice);
}
}
}
unit.Actions [bc.Action].Protocol.generateAutomaton(bc.Transitions);
}
}
}
foreach (ExecutionStateEvaluation es in evaluations)
{
foreach (MetaAction action in unit.Actions.Values)
{
if (!action.IsNative && action.Name.Equals(es.ActionName))
{
action.Protocol.runStates(es.StatesToStop);
}
}
}
this.reconfiguring = false;
this.evaluations = null;
this.request = null;
Console.WriteLine("[ConfigurationManager.Commit] Reconfiguração aplicada!");
return(true);
}
}
return(false);
}
