public static void QuantumState_SetVisible(QuantumState __instance, bool visible)
{
if (!QSBWorldSync.AllObjectsReady)
{
return;
}
if (!visible)
{
return;
}
var allMultiStates = QSBWorldSync.GetWorldObjects <QSBMultiStateQuantumObject>();
var stateObject = __instance.GetWorldObject <QSBQuantumState>();
var owner = allMultiStates.FirstOrDefault(x => x.QuantumStates.Contains(stateObject));
if (owner == default)
{
DebugLog.ToConsole($"Error - Could not find QSBMultiStateQuantumObject for state {__instance.name}", MessageType.Error);
return;
}
if (owner.ControllingPlayer != QSBPlayerManager.LocalPlayerId)
{
return;
}
var stateIndex = owner.QuantumStates.IndexOf(stateObject);
owner.SendMessage(new MultiStateChangeMessage(stateIndex));
}
protected override void Start()
{
base.Start();
crosshair = GameObject.Find("Crosshair").GetComponent <Image>();
currentState = QuantumState.Idle;
shipCam = FindObjectOfType <ShipCam>().GetComponentInChildren <Camera>();
originalFOV = shipCam.fieldOfView;
}
public EntanglementWindow(QuantumState state)
{
//Bipartition = new SystemBipartition(state.Size);
State = state;
//sizeChosen = definitionChosen = true;
//criterionChosen = partitionChosen = false;
InitializeComponent();
//SetPartitions();
}
public override void Evaluate(QuantumState state, SystemBipartition bipartition)
{
if (state.Size == 1)
{
SigmaRank = 1;
}
else
{
EvaluatedMatrix = Transformation.FromStateRowWise(state, bipartition);
Decompose(EvaluatedMatrix);
}
}
public override Transformation GetTransformation(QuantumState state)
{
double random = new Random().NextDouble();
double probability = state.ProabailityInBasis(GateTransformation.Column(0));
if (random < probability)
{
return(new Transformation(GateTransformation.Column(0).OuterProduct(GateTransformation.Column(0))));
}
else
{
return(new Transformation(GateTransformation.Column(1).OuterProduct(GateTransformation.Column(1))));
}
}
public static void QuantumState_SetVisible(QuantumState __instance, bool visible)
{
if (!visible)
{
return;
}
var allMultiStates = QSBWorldSync.GetWorldObjects <QSBMultiStateQuantumObject>();
var stateObject = QSBWorldSync.GetWorldFromUnity <QSBQuantumState, QuantumState>(__instance);
var owner = allMultiStates.First(x => x.QuantumStates.Contains(stateObject));
if (owner.ControllingPlayer != QSBPlayerManager.LocalPlayerId)
{
return;
}
var stateIndex = owner.QuantumStates.IndexOf(stateObject);
QSBEventManager.FireEvent(
EventNames.QSBMultiStateChange,
owner.ObjectId,
stateIndex);
}
private bool CreateStateFromDefinition()
{
Complex[, ] values = ReadTextMatrix();
if (values == null)
{
return(false);
}
if (DensityMatrix.IsChecked == true)
{
if (!StateOperator.IsStateOperator(values))
{
ErrorMessage.Content = "Defined matrix does not represent state operator";
ErrorMessage.Visibility = Visibility.Visible;
return(false);
}
StateOperator = StateOperator.FromValues(values);
return(true);
}
else if (StateMatrix.IsChecked == true)
{
Complex sum = Complex.Zero;
foreach (Complex value in values)
{
sum += value;
}
if (sum == Complex.Zero)
{
ErrorMessage.Content = "At least one value mus be nonzero";
ErrorMessage.Visibility = Visibility.Visible;
return(false);
}
State = QuantumState.FromValues(values);
return(true);
}
return(false);
}
public abstract void DisplayResults(QuantumState state, SystemBipartition bipartition);
internal void Import()
{
State = (item.Adjustment + 1.0) / 2.0;
}
public override void DisplayResults(QuantumState state, SystemBipartition bipartition)
{
DisplayResults(StateOperator.FromQuantumState(state), bipartition);
}
//public ComputableCrossNormCriterion(QuantumState state) : base(state) { }
//public ComputableCrossNormCriterion(StateOperator @operator) : base(@operator) { }
public override void Evaluate(QuantumState state, SystemBipartition bipartition)
{
Evaluate(StateOperator.FromQuantumState(state), bipartition);
}
public override void DisplayResults(QuantumState state, SystemBipartition bipartition)
{
Criterion.Evaluate(state, bipartition);
SetVisuals((SchmidtDecomposition)Criterion);
}
//public QuantumState State { get; private set;}
//public StateOperator StateOperator { get; private set; }
/*
* public SvdEntanglementCriterion(QuantumState state)
* {
* State = state;
* StateOperator = StateOperator.FromQuantumState(state);
* }
*
* public SvdEntanglementCriterion(StateOperator state)
* {
* StateOperator = state;
* }
*/
public abstract void Evaluate(QuantumState state, SystemBipartition bipartition);
void ChangeState(QuantumState state)
{
switch (state)
{
case QuantumState.Idle:
crosshair.enabled = false;
shipController.thrusters.Activate();
shipController.boosters.Activate();
// Indicator Lights
if (shipController.assistModule)
{
if (quantumLock)
{
shipController.lights.QuantumInactiveIndicator();
}
else
{
shipController.lights.QuantumReadyIndicator();
}
shipController.assistModule.Activate();
}
break;
case QuantumState.Searching:
// Indicator Lights
if (shipController.assistModule)
{
shipController.lights.QuantumActiveIndicator();
}
crosshair.enabled = true;
break;
case QuantumState.Breaking:
crosshair.enabled = false;
shipController.thrusters.Deactivate();
shipController.boosters.Deactivate();
// Indicator Lights
if (shipController.assistModule)
{
shipController.assistModule.Deactivate();
shipController.lights.QuantumActiveIndicator();
}
quantumParts.Stop();
break;
case QuantumState.Jumping:
shipController.thrusters.Deactivate();
shipController.boosters.Deactivate();
quantumParts.Play();
// Indicator Lights
if (shipController.assistModule)
{
shipController.lights.QuantumActiveIndicator();
}
break;
default:
break;
}
currentState = state;
}
