public void CanAddPoints()
{
ISpaceManager sm = new SpaceManager();
var space = sm.CreateSpace<string>(new Space3DConfig());
var dims = space.Dimensions;
sm.AddPoint(space, "17,-51", 17, 0, -51);
AssertBounds(dims, 17, 17, -51, -51);
sm.AddPoint(space, "19,-55", 19, 0, -55);
AssertBounds(dims, 17, 19, -55, -51);
sm.AddPoint(space, "15,-61", 15, 0, -61);
AssertBounds(dims, 15, 19, -61, -51);
sm.AddPoint(space, "21,-57", 21, 0, -57);
AssertBounds(dims, 15, 21, -61, -51);
sm.AddPoint(space, "22,-60", 22, 0, -60);
AssertBounds(dims, 15, 22, -61, -51);
sm.AddPoint(space, "22,-55", 22, 0, -55);
AssertBounds(dims, 15, 22, -61, -51);
sm.AddPoint(space, "23,-52", 23, 0, -52);
AssertBounds(dims, 15, 23, -61, -51);
sm.AddPoint(space, "24,-52", 24, 0, -52);
AssertBounds(dims, 15, 24, -61, -51);
}
public void CanFindClosestDimensionPoints()
{
ISpaceManager sm = new SpaceManager();
var space = sm.CreateSpace<string>(new Space3DConfig());
var dims = space.Dimensions;
sm.AddPoint(space, "17,-51", 17, 52, -51);
sm.AddPoint(space, "19,-55", 19, -20, -55);//IN
sm.AddPoint(space, "15,-61", 15, 0, -61);
sm.AddPoint(space, "21,-57", 21, 300, -57);//IN
sm.AddPoint(space, "22,-60", 22, -59, -60);
sm.AddPoint(space, "22,-55", 22, 2, -55);//IN
sm.AddPoint(space, "23,-52", 23, -500, -52);//IN
sm.AddPoint(space, "24,-52", 24, 100, -52);
var center = new[] { 20.5f, 0f, -55.5f };
DimensionPoint<string> left;
DimensionPoint<string> right;
var result = sm.TryFindDimensionPoint(dims[0], center[0], out left, out right);
result.ShouldBe(false);
left.ToString().ShouldBe("DimensionPoint(19)");
right.ToString().ShouldBe("DimensionPoint(21)");
result = sm.TryFindDimensionPoint(dims[2], center[2], out left, out right);
result.ShouldBe(false);
left.ToString().ShouldBe("DimensionPoint(-57)");
right.ToString().ShouldBe("DimensionPoint(-55)");
}
private void Awake()
{
DontDestroyOnLoad(this);
Instance = this;
GenHyperGrid();
}
public static void Main(string[] args)
{
bool_0 = true;
DateTime now = DateTime.Now;
Output.InitializeStream(true, OutputLevel.DebugInformation);
Output.WriteLine("Initializing BoomBang game environment...");
ConfigManager.Initialize(Constants.DataFileDirectory + @"\server-main.cfg");
Output.SetVerbosityLevel((OutputLevel)ConfigManager.GetValue("output.verbositylevel"));
foreach (string str in args)
{
Output.WriteLine("Command line argument: " + str);
Input.ProcessInput(str.Split(new char[] { ' ' }));
}
try
{
Output.WriteLine("Initializing MySQL manager...");
SqlDatabaseManager.Initialize();
Output.WriteLine("Setting up server listener on port " + ((int)ConfigManager.GetValue("net.bind.port")) + "...");
boomBangTcpListener_0 = new BoomBangTcpListener(new IPEndPoint(IPAddress.Any, (int)ConfigManager.GetValue("net.bind.port")), (int)ConfigManager.GetValue("net.backlog"), new OnNewConnectionCallback(SessionManager.HandleIncomingConnection));
using (SqlDatabaseClient client = SqlDatabaseManager.GetClient())
{
Output.WriteLine("Resetting database counters and statistics...");
smethod_0(client);
Output.WriteLine("Initializing game components and workers...");
DataRouter.Initialize();
GlobalHandler.Initialize();
SessionManager.Initialize();
CharacterInfoLoader.Initialize();
UserCredentialsAuthenticator.Initialize();
RegisterManager.Initialize();
Class1.smethod_0();
LaptopHandler.Initialize();
CatalogManager.Initialize(client);
FlowerPowerManager.Initialize();
NewsCacheManager.Initialize(client);
Navigator.Initialize(client);
SpaceManager.Initialize(client);
SpaceInfoLoader.Initialize();
SpaceHandler.Initialize();
GameHandler.Initialize();
CrossdomainPolicy.Initialize(@"Data\crossdomain.xml");
WordFilterManager.Initialize(client);
AdvertisementManager.Initialize();
ContestHandler.Initialize();
SilverCoinsWorker.Initialize();
ModerationBanManager.Initialize(client);
}
}
catch (Exception exception)
{
HandleFatalError("Could not initialize BoomBang game environment: " + exception.Message + "\nStack trace: " + exception.StackTrace);
return;
}
TimeSpan span = (TimeSpan)(DateTime.Now - now);
Output.WriteLine("The server has initialized successfully (" + Math.Round(span.TotalSeconds, 2) + " seconds). Ready for connections.", OutputLevel.Notification);
Output.WriteLine("Pulsa ENTER e introduce un comando. Ten una guía de comandos escribiendo HELP", OutputLevel.Notification);
Console.Beep();
}
//---------------------------------------------------------------------------------------------
//Поворот параллельно плоскости XY
protected Point3D[] RotateParallelToPlaneXY(
Point3D[] points,
RealVector planeNormalVector
)
{
RealVector[] coordinatesVectors = SpaceManager.GetCoordinatesVectors(points);
RealVector[] newVectors;
RealVector currentPlaneNormalVector = planeNormalVector;
double rotationAngleAroundAxisX =
Math.Atan(planeNormalVector[1] / planeNormalVector[2]);
RealMatrix rotationMatrixAroundAxisX =
SpaceManager.GetRotationMatrixAroundAxisX(rotationAngleAroundAxisX);
newVectors =
SpaceManager.RotateVectors(coordinatesVectors, rotationMatrixAroundAxisX);
currentPlaneNormalVector =
SpaceManager.RotateVector(currentPlaneNormalVector, rotationMatrixAroundAxisX);
double rotationAngleAroundAxisY =
-Math.Atan(currentPlaneNormalVector[0] / currentPlaneNormalVector[2]);
RealMatrix rotationMatrixAroundAxisY =
SpaceManager.GetRotationMatrixAroundAxisY(rotationAngleAroundAxisY);
newVectors =
SpaceManager.RotateVectors(newVectors, rotationMatrixAroundAxisY);
Point3D[] newPoints = SpaceManager.CreatePoints3DFromVectors(newVectors);
return(newPoints);
}
//---------------------------------------------------------------------------------------------
//Дисперсия
private double GetPointsDispersion(Point3D[] points, Point3D pointsCentre)
{
double[] distancesFromPointsCentre = SpaceManager.GetDistances(points, pointsCentre);
double dispersion = Statistician.GetDispersion(distancesFromPointsCentre);
return(dispersion);
}
public void CanAddPoints()
{
ISpaceManager sm = new SpaceManager();
var space = sm.CreateSpace <string>(new Space3DConfig());
var dims = space.Dimensions;
sm.AddPoint(space, "17,-51", 17, 0, -51);
AssertBounds(dims, 17, 17, -51, -51);
sm.AddPoint(space, "19,-55", 19, 0, -55);
AssertBounds(dims, 17, 19, -55, -51);
sm.AddPoint(space, "15,-61", 15, 0, -61);
AssertBounds(dims, 15, 19, -61, -51);
sm.AddPoint(space, "21,-57", 21, 0, -57);
AssertBounds(dims, 15, 21, -61, -51);
sm.AddPoint(space, "22,-60", 22, 0, -60);
AssertBounds(dims, 15, 22, -61, -51);
sm.AddPoint(space, "22,-55", 22, 0, -55);
AssertBounds(dims, 15, 22, -61, -51);
sm.AddPoint(space, "23,-52", 23, 0, -52);
AssertBounds(dims, 15, 23, -61, -51);
sm.AddPoint(space, "24,-52", 24, 0, -52);
AssertBounds(dims, 15, 24, -61, -51);
}
private void UpdateDebris(float deltaTime, SpaceManager spaceManager)
{
foreach (ShockWaveDebris debris in m_shockWaveDebris)
{
debris.UpdateDebris(speed, deltaTime, spaceManager);
}
}
public void CanFindSpacePointsWithin()
{
ISpaceManager sm = new SpaceManager();
var space = sm.CreateSpace <string>(new Space3DConfig());
sm.AddPoint(space, "17,-51", 17, 52, -51);
sm.AddPoint(space, "19,-55", 19, -20, -55); //IN
sm.AddPoint(space, "15,-61", 15, 0, -61);
sm.AddPoint(space, "21,-57", 21, 300, -57); //IN
sm.AddPoint(space, "22,-60", 22, -59, -60);
sm.AddPoint(space, "22,-55", 22, 2, -55); //IN
sm.AddPoint(space, "23,-52", 23, -500, -52); //IN
sm.AddPoint(space, "24,-52", 24, 100, -52);
var center = new[] { 20.5f, 0f, -55.5f };
var points =
sm.FindSpacePointsWithin(space, 4.5f, DimensionSelector.OnlyDimXZ, center);
var list = new List <SpacePoint <string> >(points);
list.Count.ShouldBe(4);
list.Select(sp => sp.Value).ShouldContain("19,-55");
list.Select(sp => sp.Value).ShouldContain("21,-57");
list.Select(sp => sp.Value).ShouldContain("22,-55");
list.Select(sp => sp.Value).ShouldContain("23,-52");
list.Select(sp => sp.Value).ShouldNotContain("15,-61");
list.Select(sp => sp.Value).ShouldNotContain("17,-51");
list.Select(sp => sp.Value).ShouldNotContain("22,-60");
list.Select(sp => sp.Value).ShouldNotContain("24,-52");
}
public SpaceStateManager(
MessageHandlerID messageHandlerId,
IClientPlayerInfoManager clientPlayerInfoManager,
IGlobalGameUISingleton globalGameUiSingleton,
CollisionManager collisionManager,
INetworkingService networkingService,
PhysicsManager physicsManager,
PlayerShipManager playerShipManager,
ProjectileManager projectileManager,
SelectionManager selectionManager,
SimulationManager simulationManager,
ClientShipManager clientShipManager,
SpaceManager spaceManager,
StructureFactoryManager structureFactoryManager,
TargetingService targetingService,
TeamManager teamManager,
WarpHoleManager warpHoleManager,
MessageService_ToServer messageService,
FloatyAreaObjectManager floatyAreaObjectManager)
: base(messageHandlerId, clientPlayerInfoManager, collisionManager, globalGameUiSingleton, networkingService, physicsManager, playerShipManager,
projectileManager, selectionManager, clientShipManager, simulationManager, structureFactoryManager,
warpHoleManager, teamManager, targetingService, floatyAreaObjectManager, messageService, GameStateType.Space, new SpaceViewModel(clientShipManager)
)
{
_spaceManager = spaceManager;
_synchronousUpdateList.Add(_playerShipManager);
}
public static ServerMessage Compose(uint CategoryId, uint MainId, List <NavigatorItem> ItemContainer)
{
ServerMessage message = new ServerMessage(FlagcodesOut.NAVIGATOR, ItemcodesOut.NAVIGATOR_SUBITEMS, false);
message.AppendParameter(CategoryId, false);
foreach (NavigatorItem item in ItemContainer)
{
SpaceInstance instanceBySpaceId = SpaceManager.GetInstanceBySpaceId(item.UInt32_0);
if (item.SpaceId.Equals(MainId) && !item.IsCategory)
{
message.AppendParameter(true, true);
message.AppendParameter(true, true);
message.AppendParameter(item.SpaceId, true);
message.AppendParameter(item.Name, true);
if (instanceBySpaceId == null)
{
message.AppendParameter(0, true);
}
else
{
message.AppendParameter((instanceBySpaceId.ActorCount > 12) ? 12 : instanceBySpaceId.HumanActorCount, true);
}
message.AppendParameter(0, true);
message.AppendParameter(0, true);
message.AppendParameter(item.UInt32_0, true);
message.AppendParameter("-1", true);
message.AppendParameter(12, false);
}
}
return(message);
}
public void CanFindClosestDimensionPoints()
{
ISpaceManager sm = new SpaceManager();
var space = sm.CreateSpace <string>(new Space3DConfig());
var dims = space.Dimensions;
sm.AddPoint(space, "17,-51", 17, 52, -51);
sm.AddPoint(space, "19,-55", 19, -20, -55); //IN
sm.AddPoint(space, "15,-61", 15, 0, -61);
sm.AddPoint(space, "21,-57", 21, 300, -57); //IN
sm.AddPoint(space, "22,-60", 22, -59, -60);
sm.AddPoint(space, "22,-55", 22, 2, -55); //IN
sm.AddPoint(space, "23,-52", 23, -500, -52); //IN
sm.AddPoint(space, "24,-52", 24, 100, -52);
var center = new[] { 20.5f, 0f, -55.5f };
DimensionPoint <string> left;
DimensionPoint <string> right;
var result = sm.TryFindDimensionPoint(dims[0], center[0], out left, out right);
result.ShouldBe(false);
left.ToString().ShouldBe("DimensionPoint(19)");
right.ToString().ShouldBe("DimensionPoint(21)");
result = sm.TryFindDimensionPoint(dims[2], center[2], out left, out right);
result.ShouldBe(false);
left.ToString().ShouldBe("DimensionPoint(-57)");
right.ToString().ShouldBe("DimensionPoint(-55)");
}
//---------------------------------------------------------------------------------------------
public InterferogramDecodingResult DecodeInterferogram(
BitMask2D bitMask, params RealMatrix[] interferograms
)
{
//Выбранные точки изображения
Point[] selectedImagePoints = bitMask.GetTruePoints();
//3D точки в плоскости, параллельной плоскости XY
Point3D[] points3D =
this.GetParallelToCoordinatePlanePoints3D(interferograms, selectedImagePoints);
Point2D[] points2D = SpaceManager.GetProjectionXY(points3D);
this.ProjectionPoints = points2D;
points2D = PlaneManager.DisplacePointsToFirstQuadrant(points2D);
Point2D[] transformedPoints = this.GetTransformedPoints(points2D);
int sizeX = interferograms[0].ColumnCount;
int sizeY = interferograms[0].RowCount;
RealMatrix phaseMatrix =
this.CalculatePhaseMatrix(transformedPoints, selectedImagePoints, sizeX, sizeY);
InterferogramDecodingResult decodingResult = new InterferogramDecodingResult(phaseMatrix);
return(decodingResult);
}
//----------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------
public PlaneDescriptor Approximate(params Point3D[] points)
{
int n = 3;
RealMatrix matrixA = new RealMatrix(points.Length, n);
for (int index = 0; index < points.Length; index++)
{
Point3D point = points[index];
matrixA[index, 0] = 1;
matrixA[index, 1] = point.X;
matrixA[index, 2] = point.Y;
}
RealVector vectorZ = new RealVector(SpaceManager.GetCoordinatesZ(points));
RealMatrix transposedMatrixA = matrixA.GetTransposedMatrix();
RealVector coefficientsVector =
(transposedMatrixA * matrixA).GetInverseMatrix() * transposedMatrixA * vectorZ;
double d = coefficientsVector[0];
double a = coefficientsVector[1];
double b = coefficientsVector[2];
double coefficientOfX = a / d;
double coefficientOfY = b / d;
double coefficientOfZ = -1 / d;
double absoluteTerm = 1;
PlaneDescriptor planeDescriptor =
new PlaneDescriptor(coefficientOfX, coefficientOfY, coefficientOfZ, absoluteTerm);
return(planeDescriptor);
}
void Start()
{
direction = scrollDirection;
instance = this;
DontDestroyOnLoad(this.gameObject);
}
public static SpaceStateManager BuildSpaceStateManager(int?areaID, IMessenger messenger, INetworkingService _networkingService)
{
//Null references, unused by the Simulator
TextureManager textureManager = null;
SpriteBatch spriteBatch = null;
ParticleManager particleManager = null;
Texture2D warpholeTexture = null;
Texture2D borderTexture = null;
SelectionManager selectionManager = null;
IGlobalGameUISingleton globalGameUISingleton = null;
MessageService_ToServer messageService = new MessageService_ToServer(messenger);
SimulationManager simulationManager = new SimulationManager();
CollisionManager collisionManager = new CollisionManager(messageService);
PlayerShipManager playerShipManager = new PlayerShipManager(messageService);
IClientPlayerInfoManager clientPlayerInfoManager = new PlayablePlayerInfoManager(playerShipManager);
TargetingService targetingService = new TargetingService();
TeamManager teamManager = new TeamManager(targetingService);
PhysicsManager physicsManager = new PhysicsManager();
BorderManager borderManager = new BorderManager(borderTexture, spriteBatch, physicsManager);
ProjectileManager projectileManager = new ProjectileManager(particleManager, physicsManager.World, spriteBatch, targetingService, simulationManager, messageService, collisionManager);
ClientShipManager clientShipManager = new ClientShipManager(particleManager, playerShipManager, spriteBatch, textureManager, simulationManager, targetingService, teamManager, projectileManager, messageService, clientPlayerInfoManager, true);
clientShipManager.SendPositionUpdates = true;
StructureFactoryManager structureFactoryManager = new StructureFactoryManager(messageService, physicsManager.World, projectileManager, targetingService, teamManager, null, clientShipManager, null, true);
WarpHoleManager warpholeManager = new WarpHoleManager(messageService, particleManager, physicsManager, clientShipManager, warpholeTexture);
GravityManager gravityManager = new GravityManager(physicsManager);
SpaceObjectManager spaceObjectManager = new SpaceObjectManager(textureManager, messageService, spriteBatch, particleManager, physicsManager);
SpaceManager spaceManager = new SpaceManager(spriteBatch, borderManager, gravityManager, physicsManager, spaceObjectManager, warpholeManager);
FloatyAreaObjectManager floatyAreaObjectManager = new FloatyAreaObjectManager(physicsManager.World, textureManager, messageService, spriteBatch, particleManager);
var mhi = areaID == null ? new MessageHandlerID() : new MessageHandlerID((int)areaID);
SpaceStateManager spaceStateManager = new SpaceStateManager(mhi,
clientPlayerInfoManager,
globalGameUISingleton,
collisionManager,
_networkingService,
physicsManager,
playerShipManager,
projectileManager,
selectionManager,
simulationManager,
clientShipManager,
spaceManager,
structureFactoryManager,
targetingService,
teamManager,
warpholeManager,
messageService,
floatyAreaObjectManager);
spaceStateManager.SetAreaId(areaID);
return(spaceStateManager);
}
public static void DeserializeBinaryAsync(Stream sReader, SpaceManager sPMInst, Action doAfter)
{
ThreadPool.QueueUserWorkItem(DeserializeBinaryThreading, new object[] { sReader, sPMInst, doAfter });
/* Thread deserializeThread = new Thread(DeserializeBinaryThreading);
* deserializeThread.Priority = System.Threading.ThreadPriority.Highest;
* deserializeThread.Start(new object[] { sReader, sPMInst, doAfter });*/
}
// Start is called before the first frame update
void Start()
{
spaceManagerInstance = Component.FindObjectOfType <SpaceManager>();
if (!spaceManagerInstance.obtainGraphAtStart)
{
Destroy(this);
}
}
//---------------------------------------------------------------------------------------------
//Повернутая в плоскости направляющая цилиндра
private RealVector GetRotatedInPlaneCylinderGuidLine(RealVector cylinderGuidLine, double angle)
{
RealVector auxiliaryVector = new RealVector(0, 0, -1);
RealVector newVector =
SpaceManager.RotateVectorInPlane(cylinderGuidLine, auxiliaryVector, angle);
return(newVector);
}
//---------------------------------------------------------------------------------------------
public InterferogramDecodingResult DecodeInterferogram(RealMatrix[] interferograms, BitMask2D bitMask)
{
//double gamma = 2;
//interferograms = MatricesManager.GetGammaCorrectedMatrices( gamma, interferograms );
//interferograms = GetNormalizedMatrices( interferograms );
//Выбранные точки изображения
Point[] selectedImagePoints = bitMask.GetTruePoints();
Point3D[] points3D =
this.GetParallelToCoordinatePlanePoints3D(interferograms, selectedImagePoints);
this.TrajectoryPoints = points3D;
Point2D[] points2D = SpaceManager.GetProjectionXY(points3D);
this.ProjectionPoints = points2D;
EllipseDescriptor ellipseDescriptor = this.GetEllipseDescriptor(points2D);
Point2D ellipseCentre = ellipseDescriptor.GetCentre();
Point3D pointsCentre = new Point3D(ellipseCentre.X, ellipseCentre.Y, points3D[0].Z);
RealVector cylinderGuidLine = this.GetCylinderGuidLine(ellipseDescriptor);
RealVector normalizedCylinderGuidLine = cylinderGuidLine.GetNormalizedVector();
/*
* this.CalculateCirclePointsDispersion( cylinderGuidLine, points3D, pointsCentre );
* double cylinderGuidLineOptimalAngle = this.GetCylinderGuidLineOptimalAngle();
* cylinderGuidLine = this.GetRotatedInPlaneCylinderGuidLine
* ( cylinderGuidLine, cylinderGuidLineOptimalAngle );
*/
Point3D[] circlePoints = this.GetCirclePoints(points3D, normalizedCylinderGuidLine);
this.CirclePoints = circlePoints;
Point3D circlePointsCentre =
this.GetCorrectedCirclePoint(pointsCentre, normalizedCylinderGuidLine);
//Поворот точек
RealMatrix rotationMatrix = this.GetRotationMatrix(circlePoints);
//rotationMatrix.WriteToTextFile( @"d:\!!\RotationMatrix.txt" ); // debug
Point3D[] rotatedCirclePoints = this.RotatePoints(circlePoints, rotationMatrix);
this.RotatedCirclePoints = rotatedCirclePoints;
Point3D rotatedCirclePointsCentre = PlaneManager.RotateVector
(new RealVector(circlePointsCentre), rotationMatrix).ToPoint3D();
Point3D[] correctedPoints =
this.DisplacePoints(rotatedCirclePoints, rotatedCirclePointsCentre);
int sizeX = interferograms[0].ColumnCount;
int sizeY = interferograms[0].RowCount;
RealMatrix phaseMatrix = this.CalculatePhaseMatrixByCirclePoints
(correctedPoints, selectedImagePoints, sizeX, sizeY);
InterferogramDecodingResult decodingResult = new InterferogramDecodingResult(phaseMatrix);
return(decodingResult);
}
void Start()
{
spaceManagerInstance = Component.FindObjectOfType <SpaceManager>();
progressbarSlider = gameObject.GetComponentInChildren <Slider>();
processingProgressText = progressbarSlider.GetComponentInChildren <Text>();
if (!spaceManagerInstance.obtainGraphAtStart)
{
Destroy(this);
}
}
public FighterBlackboard(Fighter fighter, GameObject parentObject)
{
this.fighter = fighter;
this.parentObject = parentObject;
mothership = fighter.mothership;
tickInterval = .1f;
// add some variance in update speed because some dudes react faster than others (but mostly for smoothing fps drops when clumps spawn)
tickInterval = UnityEngine.Random.Range(-tickInterval * .2f, tickInterval * .2f) + tickInterval;
spaceManager = fighter.spaceManager;
}
public void UpdateDebris(float currentSpeed, float deltaTime, SpaceManager spaceManager)
{
if (m_pieceOfDebris != null)
{
Vector3 gravity = Vector3.zero;
gravity += spaceManager.GetGravity(m_pieceOfDebris.transform.position);
m_pieceOfDebris.transform.position += (m_direction * currentSpeed * deltaTime) + Vector3.ClampMagnitude(gravity, 1.0f);
m_pieceOfDebris.transform.localScale -= Vector3.one * deltaTime;
}
}
//---------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------
//Повернуть точки
private Point3D[] RotatePoints(Point3D[] points, RealMatrix rotationMatrix)
{
RealVector[] vectors = SpaceManager.GetCoordinatesVectors(points);
RealVector[] rotatedVectors = SpaceManager.RotateVectors(vectors, rotationMatrix);
this.RotatedVectors = rotatedVectors; //debug
Point3D[] rotatedPoints = SpaceManager.CreatePoints3DFromVectors(rotatedVectors);
return(rotatedPoints);
}
private void Awake()
{
if (!spaceManagerInstance)
{
spaceManagerInstance = Component.FindObjectOfType <SpaceManager>();
}
cTSInstance = new CancellationTokenSource();
oldPos = transform.position;
oldRot = transform.rotation;
oldScale = transform.localScale;
}
public void UpdateLifeTime(float deltaTime, SpaceManager spaceManager)
{
if (m_elapsedTime > lifeTime)
{
isActive = false;
}
m_elapsedTime += Time.deltaTime;
strength -= m_peakStrength * decay * Time.deltaTime;
speed -= decay * Time.deltaTime;
UpdateDebris(deltaTime, spaceManager);
}
// returns the object if there is a slot open
public GameObject GetAvalibleSpot()
{
for (int i = 0; i < gameObject.transform.childCount; i++)
{
SpaceManager temp = gameObject.transform.GetChild(i).GetComponent <SpaceManager>();
if (temp != null && temp.Reserved == false)
{
return(gameObject.transform.GetChild(i).gameObject);
}
}
return(null);
}
//---------------------------------------------------------------------------------------------
//Перемещение точек
private Point3D[] DisplacePoints(Point3D[] points, Point3D pointsCentre)
{
double value = 500;
Point3D pointVectorN = new Point3D(value, value, value);
double displacementX = pointVectorN.X - pointsCentre.X;
double displacementY = pointVectorN.Y - pointsCentre.Y;
double displacementZ = pointVectorN.Z - pointsCentre.Z;
Point3D[] newPoints = SpaceManager.DisplacePoints
(points, displacementX, displacementY, displacementZ);
return(newPoints);
}
void Start()
{
weaponVisuals = gameObject.transform.Find("visibleLazer").gameObject;
weaponVisuals.transform.parent = gameObject.transform;
weapon = (gameObject.tag == "Team1") ? new Lazer(Color.red, 20.0f, 20.0f, weaponVisuals) : new Lazer(Color.green, 20.0f, 20.0f, weaponVisuals);
m_rigidbody = gameObject.AddComponent <Rigidbody>();
m_rigidbody.useGravity = false;
m_propulsion = new Propulsion(m_rigidbody, gameObject, m_thrust, m_turnRate);
InitializeBlackboard();
spaceManager = GameObject.FindGameObjectWithTag("SpaceManager").GetComponent <SpaceManager>();
}
private void Start()
{
lineContainer = new GameObject();
lineContainer.name = "spline";
line = lineContainer.AddComponent <LineRenderer>();
line.material = lineMaterial;
line.loop = false;
thisPursuerInstance = GetComponent <Pursuer>();
spaceManagerinstance = Component.FindObjectOfType <SpaceManager>();
trajectory = new List <Vector3>();
toOldPos = toPoint.position;
fromOldPos = transform.position;
}
public AStar(double omega, SpaceManager spaceManagerInstance, object cTInstance, IGraph graph, IVertex start, IVertex goal, int pathfindingLevel)
{
if (omega > 1 || omega < 0)
{
throw new ArgumentException();
}
this.omega = omega;
this.graph = graph;
this.start = start;
this.goal = goal;
this.cTInstance = (CancellationToken)cTInstance;
this.spaceManagerInstance = spaceManagerInstance;
this.pathfindingLevel = pathfindingLevel;
}
// returns the current number of patrons in the group
public int GetCurrGroupAmount()
{
int amount = 0;
for (int i = 0; i < gameObject.transform.childCount; ++i)
{
SpaceManager temp = gameObject.transform.GetChild(i).GetComponent <SpaceManager>();
if (temp != null && temp.Taken == true)
{
++amount;
}
}
return(amount);
}
public void CanAssignTailLinks()
{
ISpaceManager sm = new SpaceManager();
var space = sm.CreateSpace<string>(new Space3DConfig());
var dims = space.Dimensions;
sm.AddPoint(space, "17,-51", 17, 0, -51);
sm.AddPoint(space, "19,-55", 19, 0, -55);
sm.AddPoint(space, "15,-61", 15, 0, -61);
sm.AddPoint(space, "21,-57", 21, 0, -57);
sm.AddPoint(space, "22,-60", 22, 0, -60);
sm.AddPoint(space, "22,-55", 22, 0, -55);
sm.AddPoint(space, "23,-52", 23, 0, -52);
sm.AddPoint(space, "24,-52", 24, 0, -52);
dims[0].HeadDimPoint.TailLink.ToString().ShouldBe("DimensionLink(15)");
dims[0].TailDimPoint.TailLink.ToString().ShouldBe("DimensionLink(24)");
dims[2].HeadDimPoint.TailLink.ToString().ShouldBe("DimensionLink(-61)");
dims[2].TailDimPoint.TailLink.ToString().ShouldBe("DimensionLink(-51)");
}
public void CanFindNearestSpacePointCase2()
{
ISpaceManager sm = new SpaceManager();
var space = sm.CreateSpace<string>(new Space3DConfig());
Helper.PopulatePoints(sm, space);
SpacePoint<string> center;
sm.TryFindFirstSpacePoint(space, out center, 1, -1, -1);
var point = sm.FindNearest(center, 10);
Assert.That(point, Is.Not.Null);
Assert.That(point.Value, Is.EqualTo(Helper.p0));
}
public void CanFindSpacePointByCoordinates()
{
ISpaceManager sm = new SpaceManager();
var space = sm.CreateSpace<string>(new Space3DConfig());
sm.AddPoint(space, "A", 0, 0, 0);
sm.AddPoint(space, "B", 1, 5, -3);
sm.AddPoint(space, "C", 2, -6, 1);
sm.AddPoint(space, "D", 0, 8, 8);
SpacePoint<string> point;
var r = sm.TryFindFirstSpacePoint(space, out point, 2, -6, 1);
Assert.That(r, Is.True);
Assert.That(point, Is.Not.Null);
Assert.That(point.Value, Is.EqualTo("C"));
}
public void CanFindSpacePointsWithin()
{
ISpaceManager sm = new SpaceManager();
var space = sm.CreateSpace<string>(new Space3DConfig());
sm.AddPoint(space, "17,-51", 17, 52, -51);
sm.AddPoint(space, "19,-55", 19, -20, -55);//IN
sm.AddPoint(space, "15,-61", 15, 0, -61);
sm.AddPoint(space, "21,-57", 21, 300, -57);//IN
sm.AddPoint(space, "22,-60", 22, -59, -60);
sm.AddPoint(space, "22,-55", 22, 2, -55);//IN
sm.AddPoint(space, "23,-52", 23, -500, -52);//IN
sm.AddPoint(space, "24,-52", 24, 100, -52);
var center = new[] {20.5f, 0f, -55.5f};
var points =
sm.FindSpacePointsWithin(space, 4.5f, DimensionSelector.OnlyDimXZ, center);
var list = new List<SpacePoint<string>>(points);
list.Count.ShouldBe(4);
list.Select(sp => sp.Value).ShouldContain("19,-55");
list.Select(sp => sp.Value).ShouldContain("21,-57");
list.Select(sp => sp.Value).ShouldContain("22,-55");
list.Select(sp => sp.Value).ShouldContain("23,-52");
list.Select(sp => sp.Value).ShouldNotContain("15,-61");
list.Select(sp => sp.Value).ShouldNotContain("17,-51");
list.Select(sp => sp.Value).ShouldNotContain("22,-60");
list.Select(sp => sp.Value).ShouldNotContain("24,-52");
}
public void CanRepositionPoint()
{
ISpaceManager sm = new SpaceManager();
var space = sm.CreateSpace<string>(new Space3DConfig());
Helper.PopulatePoints(sm, space);
SpacePoint<string> point;
sm.TryFindFirstSpacePoint(space, out point, 0, 0, 0);
var r = sm.Reposition(point, 9.5f, -9.5f, 9.5f);
Assert.That(r, Is.True,"Expeted to return true from Reposition method");
Assert.That(point.Dimensions[0], Is.Not.Null, "Dim 0 should not be null");
Assert.That(point.Dimensions[1], Is.Not.Null, "Dim 1 should not be null");
Assert.That(point.Dimensions[2], Is.Not.Null, "Dim 2 should not be null");
Assert.That(point.Dimensions[0].Position, Is.EqualTo(9.5));
Assert.That(point.Dimensions[1].Position, Is.EqualTo(-9.5));
Assert.That(point.Dimensions[2].Position, Is.EqualTo(9.5));
}
