/***************************************************/
private static Avalue ClipView(Spectator spectator, Vector viewVect, Polyline activityArea)
{
Avalue result = new Avalue();
result.ObjectId = spectator.BHoM_Guid;
result.ReferencePoint = spectator.Head.PairOfEyes.ReferenceLocation;
Vector rowV = Geometry.Query.CrossProduct(Vector.ZAxis, spectator.Head.PairOfEyes.ViewDirection);
Vector viewY = Geometry.Query.CrossProduct(viewVect, rowV);
Vector viewX = Geometry.Query.CrossProduct(viewVect, viewY);
//viewX reversed to ensure cartesian Z matches the view direction
viewX = viewX.Reverse();
viewX = viewX.Normalise();
viewY = viewY.Normalise();
viewVect = viewVect.Normalise();
//local cartesian
Cartesian local = Geometry.Create.CartesianCoordinateSystem(spectator.Head.PairOfEyes.ReferenceLocation, viewX, viewY);
//get the ConeOfVision
TransformMatrix transform = Geometry.Create.OrientationMatrixGlobalToLocal(local);
result.ConeOfVision = m_AvalueSettings.EffectiveConeOfVision.Transform(transform);
//planes where the calculation takes place
Plane viewPlane = result.ConeOfVision.FitPlane();
//make sure normal is viewvect
viewPlane.Normal = viewVect;
//find part of activity area to project
Polyline clippedArea = ReduceActivityArea(viewPlane, activityArea);
//project the pitch
result.FullActivityArea = ProjectPolylineToPlane(viewPlane, clippedArea, spectator.Head.PairOfEyes.ReferenceLocation);
//clip the projected pitch against the view cone
result.ClippedActivityArea = ClipActivityArea(result.FullActivityArea, result.ConeOfVision);
//calculate the avalue
result.AValue = result.ClippedActivityArea.Area() / result.ConeOfVision.Area() * 100;
//clip heads in front
if (m_AvalueSettings.CalculateOcclusion)
{
List <Spectator> infront = GetSpectatorsInfront(spectator, m_ConeOfVisionAngle);
if (infront.Count > 0)
{
List <Polyline> occludingClippedHeads = ClipHeads(infront, spectator, viewPlane, result.ClippedActivityArea);
if (occludingClippedHeads.Count > 0)
{
result.OccludingHeads = occludingClippedHeads;
result.Occulsion = occludingClippedHeads.Sum(x => x.Area()) / result.ConeOfVision.Area() * 100;
}
}
}
return(result);
}
/***************************************************/
private static Spectator GetSpecInfront(Spectator current, KDTree <Spectator> tree)
{
double[] query = { current.Head.PairOfEyes.ReferenceLocation.X, current.Head.PairOfEyes.ReferenceLocation.Y, current.Head.PairOfEyes.ReferenceLocation.Z };
//first get the neighbourhood around the current spec
var neighbours = tree.Nearest(query, neighbors: 8);
NodeDistance <KDTreeNode <Spectator> > closestInFront = new NodeDistance <KDTreeNode <Spectator> >();
double dist = Double.MaxValue;
foreach (var n in neighbours)
{
//only those infront
if (n.Node.Value.Head.PairOfEyes.ReferenceLocation.Z < current.Head.PairOfEyes.ReferenceLocation.Z)
{
if (n.Distance < dist)
{
closestInFront = n;
dist = n.Distance;
}
}
}
if (closestInFront.Node == null)
{
return(null);
}
else
{
return(closestInFront.Node.Value);
}
}
private void SpawnSpectator(Spectator Type)
{
Spectator Spawn = Instantiate(Type, transform);
Spawn.OnCreate();
mSpectators.Add(Spawn);
}
public void IsSpectatorExistWhenExistByName()
{
User user = new User("ni", "4363", "*****@*****.**", 233);
Spectator spec = game.AddSpectatingPlayer(user);
Assert.IsTrue(game.IsSpectatorExist(spec.Username));
}
/***************************************************/
private static List <Polyline> ClipHeads(List <Spectator> nearSpecs, Spectator current, Plane viewPlane, Polyline clippedArea)
{
//using the project activity area to clip heads in front that over lap
List <Polyline> clippedHeads = new List <Polyline>();
foreach (Spectator s in nearSpecs)
{
Point p = viewPlane.ClosestPoint(s.Head.PairOfEyes.ReferenceLocation);
//if distance to view plane is in range
if (s.Head.PairOfEyes.ReferenceLocation.Distance(p) <= m_AvalueSettings.FarClippingPlaneDistance)
{
Polyline projectedHead = ProjectPolylineToPlane(viewPlane, s.HeadOutline, current.Head.PairOfEyes.ReferenceLocation);
if (projectedHead.ControlPoints.Count == 0)
{
continue;
}
List <Polyline> clippedHead = Geometry.Compute.BooleanIntersection(clippedArea, projectedHead);
if (clippedHead.Count > 0)
{
clippedHeads.Add(clippedHead[0]);
}
}
}
return(clippedHeads);
}
/***************************************************/
private static List <Spectator> GetSpectatorsInfront(Spectator current, double viewConeAngle)
{
PairOfEyes viewer = current.Head.PairOfEyes;
double[] query = { viewer.ReferenceLocation.X, viewer.ReferenceLocation.Y, viewer.ReferenceLocation.Z };
//first get the neighbourhood around the current spec
var neighbours = m_KDTree.Nearest(query, radius: m_FarClippingPlaneDistance);
List <Spectator> infront = new List <Spectator>();
foreach (var n in neighbours)
{
PairOfEyes viewed = n.Node.Value.Head.PairOfEyes;
Vector toNeighbour = viewed.ReferenceLocation - viewer.ReferenceLocation;
toNeighbour.Z = 0;
if (toNeighbour.Length() == 0)
{
continue;
}
//point in plane within +-coneAngle in direction viewer is looking
double testAngle = Geometry.Query.Angle(toNeighbour, viewer.ViewDirection);
if (testAngle < viewConeAngle / 2)
{
infront.Add(n.Node.Value);
}
}
return(infront);
}
private void OnTimerElapsed(object sender, ElapsedEventArgs elapsedEventArgs)
{
try
{
new Thread(
async() =>
{
try
{
if (!_isRecording && Menu.Item(Name + "DoRecord").GetValue <bool>())
{
_isRecording = await Spectator.DoRecord();
}
if (!_isRecording && Menu.Item(Name + "IsRecording").GetValue <bool>())
{
_isRecording = await Spectator.IsRecoding();
}
if (_isRecording)
{
_timer.Enabled = false;
_timer.Stop();
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}).Start();
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
public void OnGameBegin()
{
for (int i = 0; i < mSpectators.Count; i++)
{
Destroy(mSpectators[i].gameObject);
}
mSpectators.Clear();
InitialSpawn();
for (int i = 0; i < mSpectators.Count; i++)
{
Spectator S = mSpectators[i];
S.SetCallbacks
(
() => { },
() => { OnSpectatorEnter(S); },
() => { OnSpectatorExit(S); },
() => { OnSpectatorBeginWatching(S); },
() => { OnSpectatorDistracted(S); }
);
}
for (int i = 0; i < mSpectators.Count; i++)
{
mSpectators[i].OnGameBegin();
}
}
private void OnSpectatorExit(Spectator S)
{
if (mSpectatorGrid.FreeCellAtPosition(S.transform.position))
{
S.ExitRoom(SpawnPointMax.x * 1.5f);
}
}
public void AddSpectatingTest()
{
User user = new User("roni", "4363", "*****@*****.**");
Spectator spec = game.AddSpectatingPlayer(user);
Assert.IsTrue(game.IsSpectatorExist(spec.Username));
}
/***************************************************/
private static Point FindFocalOffset(Spectator spect, Polyline focalPolyline)
{
Vector rowVector = Geometry.Query.CrossProduct(Vector.ZAxis, spect.Head.PairOfEyes.ViewDirection);
Point focal = new Point();
//plane is perpendicular to row
Plane interPlane = Geometry.Create.Plane(spect.Head.PairOfEyes.ReferenceLocation, rowVector);
double dist = Double.MaxValue;
Point ipt = new Point();
//loop the segments in the focalPolyline
//from the start point create a line parallel to the row
//inter sect with the plane
foreach (var seg in focalPolyline.SubParts())
{
Line offset = Geometry.Create.Line(seg.StartPoint(), seg.StartPoint() + rowVector);
offset.Infinite = true;
ipt = Geometry.Query.PlaneIntersection(offset, interPlane);
if (Geometry.Query.Distance(ipt, interPlane.Origin) < dist)
{
focal = ipt;
dist = Geometry.Query.Distance(ipt, interPlane.Origin);
}
}
return(focal);
}
public void OnFocus(ApplicationFocusEvent e, Spectator spectator)
{
if (e.IsFocused && !this.IsErrorScreen())
{
Cursor.visible = spectator.cursorState.CursorVisible;
Cursor.lockState = spectator.cursorState.CursorLockState;
}
}
private void SpawnAtPosition(Spectator Type, Vector3 Position)
{
Spectator Spawn = Instantiate(Type, transform);
Spawn.transform.position = Position;
Spawn.OnCreate();
mSpectators.Add(Spawn);
}
public void ConstructorSpectatorName_ParameterAreFilled_NameAdded()
{
//Arrange
string spectatorName = "Spectateur1";
var spectator = new Spectator(spectatorName, loggerMock.Object);
//Act - Assert
Assert.Equal(spectatorName, spectator.spectatorName);
}
public void SpawnSpectator(Vector3 position, Vector3 forward)
{
GameObject o = Instantiate(spectator, position, Quaternion.identity);
o.transform.forward = forward;
Spectator s = o.GetComponent <Spectator>();
s.manager = this;
}
public void SwitchCursorState(UpdateEvent evt, Spectator spectator)
{
if (InputManager.GetActionKeyDown(BattleActions.CURSOR))
{
Cursor.visible = !Cursor.visible;
Cursor.lockState = !(Cursor.visible || !spectator.mouseControlStateHolder.MouseControlAllowed) ? CursorLockMode.Locked : CursorLockMode.None;
spectator.cursorState.CursorVisible = Cursor.visible;
spectator.cursorState.CursorLockState = Cursor.lockState;
}
}
public void UpdateAfterTrick_MonkeyIsNull_ArgumentNullException()
{
//Arrange
string spectatorName = "Spectateur1";
var spectator = new Spectator(spectatorName, loggerMock.Object);
Monkey monkey = null;
//Act - Assert
Assert.Throws <ArgumentNullException>("monkey", () => spectator.Update(monkey, trick));
}
private void OnSpectatorEnter(Spectator S)
{
Vector3 Pos = mSpectatorGrid.GetRandomCellPosition();
if (mSpectatorGrid.OccupyCellAtPosition(Pos))
{
S.transform.position = new Vector3(S.transform.position.x, ConvertGridPosition(Pos).y, Pos.z);
S.EnterRoom(Pos.x);
}
}
/***************************************************/
private static Vector SetViewVector(this Spectator spectator)
{
if (m_AvalueSettings.FocalPoint == null)
{
return(spectator.Head.PairOfEyes.ViewDirection);
}
else
{
return(m_AvalueSettings.FocalPoint - spectator.Head.PairOfEyes.ReferenceLocation);
}
}
private void Awake()
{
if (_instance == null)
{
_instance = this;
}
else
{
Destroy(this);
}
}
public async Task <Response> AddAsync([FromBody] Spectator spectator)
{
spectator.Id = Guid.NewGuid();
await m_spectatorService.CreateSpectatorAsync(spectator);
return(new Response
{
IsSuccesfull = true,
Message = spectator.Id.ToString()
});
}
public void SpawnSpectator()
{
int max = spawnPoints.Count;
Vector3 pos = SelectSpawnPoint(max);
GameObject o = Instantiate(spectator, pos, Quaternion.identity);
//o.transform.forward = forward;
Spectator s = o.GetComponent <Spectator>();
s.manager = this;
}
public void UpdateAfterTrick_TrickIsNull_ArgumentNullException()
{
//Arrange
string spectatorName = "Spectateur1";
var spectator = new Spectator(spectatorName, loggerMock.Object);
Trick trick1 = null;
var monkeyName = "Singe1";
var monkey = new Monkey(monkeyName);
//Act - Assert
Assert.Throws <ArgumentNullException>("trick", () => spectator.Update(monkey, trick1));
}
// Ajout d'une nouvelle réservation
public static void AddSpectator(Spectator uneReservation)
{
try
{
// Ouverture connaxion
SqlConnection connexion = ConnexionBD.GetConnexionBD().GetSqlConnexion();
// Requête SQL ajout table Spectator
// SELECT SCOPE_IDENTITY() : renvoie l'id de la ligne qui vient d'être ajoutée
string reqAdd = "INSERT INTO Spectator (spectator_lastname, spectator_firstname, spectator_email, spectator_phone) VALUES (@lastname, @firstname, @email, @phone); SELECT SCOPE_IDENTITY()";
SqlCommand commAddSpec = new SqlCommand(reqAdd, connexion);
commAddSpec.Parameters.Add(new SqlParameter("@lastname", System.Data.SqlDbType.VarChar, 255));
commAddSpec.Parameters.Add(new SqlParameter("@firstname", System.Data.SqlDbType.VarChar, 255));
commAddSpec.Parameters.Add(new SqlParameter("@email", System.Data.SqlDbType.VarChar, 255));
commAddSpec.Parameters.Add(new SqlParameter("@phone", System.Data.SqlDbType.VarChar, 255));
commAddSpec.Parameters["@lastname"].Value = uneReservation.Spectator_lastname;
commAddSpec.Parameters["@firstname"].Value = uneReservation.Spectator_firstname;
commAddSpec.Parameters["@email"].Value = uneReservation.Spectator_email;
commAddSpec.Parameters["@phone"].Value = uneReservation.Spectator_phone;
// Exécution de la requête et récupération de l'id de la ligne qui vient d'être ajoutée
int idSpec = Convert.ToInt32(commAddSpec.ExecuteScalar());
// Requête SQL ajout table To_Book
string reqAddBook = "INSERT INTO To_book (toBook_spectator, toBook_show, seatsBooked) VALUES (@spectator, @show, @seatsBooked)";
connexion.Close();
SqlConnection connexionBook = ConnexionBD.GetConnexionBD().GetSqlConnexion();
SqlCommand commAddBook = new SqlCommand(reqAddBook, connexionBook);
commAddBook.Parameters.Add(new SqlParameter("@spectator", System.Data.SqlDbType.Int));
commAddBook.Parameters.Add(new SqlParameter("@show", System.Data.SqlDbType.Int));
commAddBook.Parameters.Add(new SqlParameter("@seatsBooked", System.Data.SqlDbType.Int));
commAddBook.Parameters["@spectator"].Value = idSpec;
commAddBook.Parameters["@show"].Value = uneReservation.Spectator_show.Show_id;
commAddBook.Parameters["@seatsBooked"].Value = uneReservation.Spectator_seatsBooked;
// Execution de la requête
commAddBook.ExecuteNonQuery();
// Connexion fermée
connexionBook.Close();
}
catch (Exception e)
{
//Message box erreur
string test = e.ToString();
}
}
/***************************************************/
private static double GetRowWidth(Spectator current, Spectator nearest, Vector rowV)
{
double width = 0;
Vector row = nearest.Head.PairOfEyes.ReferenceLocation - current.Head.PairOfEyes.ReferenceLocation;
Vector row2d = Geometry.Create.Vector(row.X, row.Y, 0);//horiz vector to spectator row in front
Vector projected = row2d.Project(rowV);
Vector rowWidth = row2d - projected;
width = rowWidth.Length();
return(width);
}
public int SpectateGame(string username, int gameID)
{
IGame game = GetGameById(gameID);
if (game.IsPlayerExist(username))
{
throw new AlreadyParticipatingException("The user " + username + " is already playing in game #" + gameID);
}
User user = userController.GetUserByName(username);
Spectator spectator = game.AddSpectatingPlayer(user);
return(spectator.Id);
}
public void Update(UpdateEvent e, Spectator spectator)
{
if (InputManager.GetActionKeyDown(BattleActions.SHOW_SCORE))
{
Cursor.lockState = CursorLockMode.None;
Cursor.visible = true;
}
if (InputManager.GetActionKeyUp(BattleActions.SHOW_SCORE))
{
Cursor.lockState = spectator.cursorState.CursorLockState;
Cursor.visible = spectator.cursorState.CursorVisible;
}
}
// Au click sur le bouton supprimer
private void btnSupprimer_Click(object sender, EventArgs e)
{
if (dgvListeReservations.SelectedRows.Count <= 0)
{
MessageBox.Show("Veuillez sélectionner une réservation");
}
else
{
var rep = MessageBox.Show("Êtes vous sûr de vouloir supprimmer cette réservation ?", "Confirmation", MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation);
if (rep == DialogResult.Yes)
{
int indexRow = dgvListeReservations.CurrentRow.Index;
Spectator laReserv = (Spectator)dgvListeReservations.Rows[indexRow].Cells[0].Value;
string message = ModuleReservations.DeleteReservation(laReserv);
MessageBox.Show(message);
// On valorise chaque label avec une valeur vide
lblLaPiece.Text = String.Empty;
lblLeTheme.Text = String.Empty;
lblLaDuree.Text = String.Empty;
lblLeType.Text = String.Empty;
lblLaRepresentation.Text = String.Empty;
lblLaCompagnie.Text = String.Empty;
lblLePrixFixe.Text = "€";
lblLeNom.Text = String.Empty;
lblLePrenom.Text = String.Empty;
lblLeNbPlaces.Text = String.Empty;
lblLeEmail.Text = String.Empty;
lblLeTelephone.Text = String.Empty;
lblLePrixTotal.Text = "0 €";
LoadDataGridView();
}
}
}
public void SpectactorInteractAfterTrick_ParametersAreFilled_String()
{
//Arrange
var monkeyName = "Singe1";
var monkey = new Monkey(monkeyName);
var spectator = new Spectator("Test", loggerMock.Object);
//Act
monkey.Attach(spectator);
monkey.PerformTrick(trick);
//Assert
loggerMock.Verify(x => x.LogMessage($"Spectateur applaudit pendant le tour {trick.trickType} '{trick.trickName}' du {monkey.Name}"));
}
static void Main(string[] args)
{
// Console.WriteLine("Hello World!");
Spectator Henry = new Spectator();
Trainer Pascal = new Trainer("baloo");
Trainer Roger = new Trainer("rantanplan");
Pascal.MonkeyExecuteTrick += Henry.WatchMonkey;
Roger.MonkeyExecuteTrick += Henry.WatchMonkey;
Pascal.ExecuteTrick(1);
Pascal.ExecuteTrick(2);
Roger.ExecuteTrick(2);
}
