public void UpdateDisappear()
{
for (int i = 0; i < IndexesToDisappear.Count; i++)
{
if (IndexesToDisappear[i].Count == 2)
{
var heartPosition = VectorUtility.MidPoints(PositionUtils.TransIndexToPosition(IndexesToDisappear[i][0]), PositionUtils.TransIndexToPosition(IndexesToDisappear[i][1]));
EffectViewManager.Instance.GenerateEffects("heart", heartPosition, 0.3f);
}
else if (IndexesToDisappear[i].Count >= 3)
{
var heartPosition1 = VectorUtility.MidPoints(PositionUtils.TransIndexToPosition(IndexesToDisappear[i][0]), PositionUtils.TransIndexToPosition(IndexesToDisappear[i][1]));
var heartPosition2 = VectorUtility.MidPoints(PositionUtils.TransIndexToPosition(IndexesToDisappear[i][IndexesToDisappear[i].Count - 2]), PositionUtils.TransIndexToPosition(IndexesToDisappear[i][IndexesToDisappear[i].Count - 1]));
EffectViewManager.Instance.GenerateEffects("heart", heartPosition1, 0.3f);
EffectViewManager.Instance.GenerateEffects("heart", heartPosition2, 0.3f);
}
}
if (IndexesToDisappear.Count > 0)
{
for (int i = 0; i < IndexesToDisappear.Count; i++)
{
for (int j = 0; j < IndexesToDisappear[i].Count; j++)
{
var tilesPos = PositionUtils.TransIndexToPosition(IndexesToDisappear[i][j]);
var tileUnitPos = PositionUtils.TransIndexToUnitPosition(IndexesToDisappear[i][j]);
var tile = tiles[(int)tileUnitPos.x, (int)tileUnitPos.y];
EffectViewManager.Instance.GenerateEffects("vanish", tilesPos, 0.3f);
GameTilesViewManager.Instance.RemoveView(IndexesToDisappear[i][j]);
RemoveGameTile((int)tileUnitPos.x, (int)tileUnitPos.y);
}
}
}
}
public static Vector3 ConvertPointInSceneToUnityPosition(Vector3 pos, Vector2Int scenePoint)
{
Vector3 scenePosition = Utils.GridToWorldPosition(scenePoint.x, scenePoint.y) + pos;
Vector3 worldPosition = PositionUtils.WorldToUnityPosition(scenePosition);
return(worldPosition);
}
private bool RecordPoint()
{
if (paused || routePoint >= secretRoute.Count)
{
return(false);
}
Position curPos = secretRoute[routePoint]; routePoint++;
if (RoutePoints.Count > 0)
{
jDistance += PositionUtils.DistanceBetween(RoutePoints.Last(), curPos, Settings.UseMetric);
TimeSpan ts = DateTime.Now - lastStart;
jTime += ts.TotalSeconds;
lastStart = DateTime.Now;
}
RoutePoints.Add(curPos);
JourneyDistance = string.Format("{0:0.00} ", jDistance) + (Settings.UseMetric ? "km" : "mi");
JourneyTime = TimeUtils.FormatSecMultiple(jTime);
IsRecording = routePoint < secretRoute.Count;
return(IsRecording);
}
public void eat(float speedMultiplier)
{
if (this.body != null)
{
Body node = this.body;
while (node != null)
{
// did we find our last link?
if (node.Child == null)
{
break;
}
node = node.Child;
}
// create our new link
List <TargetPosition> clonedTargets = new List <TargetPosition>();
clonedTargets.AddRange(this.tail.TargetPositions);
node.Child = new Body(this.content, this.tail.Position, this.tail.Heading, this.tail.Rotation, clonedTargets);
// we need to push the tail back
Vector2 delta = PositionUtils.getDelta(-this.tail.Heading, Constants.TILE_SIZE - Constants.OVERLAP);
this.tail.Position += delta;
// increase our speed
this.currentSpeed += speedMultiplier;
}
}
public void RotateCubes()
{
if (CubeDataManager.Instance.UpdateLock)
{
return;
}
List <int> cubeIndex = new List <int>();
for (int i = 0; i < currentControlCubes.Length; i++)
{
cubeIndex.Add(currentControlCubes[i].GetComponent <GameTileView>().Index);
}
for (int i = 0; i < currentControlCubes.Length; i++)
{
int newIndex = 0;
if (i == 0)
{
newIndex = cubeIndex[cubeIndex.Count - 1];
}
else
{
newIndex = cubeIndex[i - 1];
}
GameTileView view = currentControlCubes[i].GetComponent <GameTileView>();
view.UpdateTartgetPosition(VectorUtility.MinusPosition(PositionUtils.TransIndexToPosition(view.Index), PositionUtils.TransIndexToPosition(newIndex)));
view.Index = newIndex;
}
changeDirectBufferTime = 0;
}
private List <PowerStorageInterface> GetAdjacentBatteries()
{
List <PowerStorageInterface> powerStoages = new List <PowerStorageInterface>();
PositionUtils.GetSegmentPos(_machineSides.Front,
_quantumStorageController.mnX, _quantumStorageController.mnY, _quantumStorageController.mnZ,
out long segmentX, out long segmentY, out long segmentZ);
GetAdjacentBattery(segmentX, segmentY, segmentZ, ref powerStoages);
PositionUtils.GetSegmentPos(_machineSides.Right,
_quantumStorageController.mnX, _quantumStorageController.mnY, _quantumStorageController.mnZ,
out segmentX, out segmentY, out segmentZ);
GetAdjacentBattery(segmentX, segmentY, segmentZ, ref powerStoages);
PositionUtils.GetSegmentPos(_machineSides.Left,
_quantumStorageController.mnX, _quantumStorageController.mnY, _quantumStorageController.mnZ,
out segmentX, out segmentY, out segmentZ);
PositionUtils.GetSegmentPos(_machineSides.Top,
_quantumStorageController.mnX, _quantumStorageController.mnY, _quantumStorageController.mnZ,
out segmentX, out segmentY, out segmentZ);
PositionUtils.GetSegmentPos(_machineSides.Bottom,
_quantumStorageController.mnX, _quantumStorageController.mnY, _quantumStorageController.mnZ,
out segmentX, out segmentY, out segmentZ);
return(powerStoages);
}
protected AbstractQuantumIoMachine(MachineEntityCreationParameters parameters) : base(parameters)
{
mbNeedsLowFrequencyUpdate = true;
mbNeedsUnityUpdate = true;
PositionUtils.SetupSidesPositions(parameters.Flags, MachineSides);
StorageIoService = new StorageIoService(this, MachineSides);
}
public void APointBackwardOfADirectionIsZero()
{
var forward = new float3(0, 0, 1);
var sign = PositionUtils.GetRelativeDirection(forward, -forward, math.up());
Assert.AreEqual(sign, 0, "Sign mismatch, should return 0 for a point in front of the direction!");
}
bool CurrentCubeSetted()
{
foreach (var cube in currentControlCubes)
{
var originPos = PositionUtils.TransIndexToUnitPosition(cube.GetComponent <GameTileView>().Index);
if (originPos.y >= sizeY)
{
return(false);
}
if (!CubeDataManager.Instance.IsEmpty((int)originPos.x, (int)originPos.y))
{
Debug.Log("CurrentCubeSetted Error 1");
return(false);
}
else
{
var gameTileView = cube.GetComponent <GameTileView>();
CubeDataManager.Instance.AddGameTile((int)originPos.x, (int)originPos.y, gameTileView.Tile);
}
}
return(true);
}
public QuantumStorageMachine(MachineEntityCreationParameters parameters, int maxCapacity) : base(parameters)
{
mbNeedsUnityUpdate = true;
_maxCapacity = maxCapacity;
_items = new List <ItemBase>(_maxCapacity);
PositionUtils.SetupSidesPositions(parameters.Flags, MachineSides);
}
private void handleInput()
{
// get key press for new direction and log the pivot point
Vector2 previousHeading = this.heading;
if (InputManager.getInstance().wasKeyPressed(controls.Left) && this.heading != Constants.HEADING_RIGHT && this.heading != Constants.HEADING_LEFT)
{
this.heading = Constants.HEADING_LEFT;
createPivotPoint(PositionUtils.getRotation(previousHeading, this.heading));
}
else if (InputManager.getInstance().wasKeyPressed(controls.Right) && this.heading != Constants.HEADING_LEFT && this.heading != Constants.HEADING_RIGHT)
{
this.heading = Constants.HEADING_RIGHT;
createPivotPoint(PositionUtils.getRotation(previousHeading, this.heading));
}
else if (InputManager.getInstance().wasKeyPressed(controls.Up) && this.heading != Constants.HEADING_DOWN && this.heading != Constants.HEADING_UP)
{
this.heading = Constants.HEADING_UP;
createPivotPoint(PositionUtils.getRotation(previousHeading, this.heading));
}
else if (InputManager.getInstance().wasKeyPressed(controls.Down) && this.heading != Constants.HEADING_UP && this.heading != Constants.HEADING_DOWN)
{
this.heading = Constants.HEADING_DOWN;
createPivotPoint(PositionUtils.getRotation(previousHeading, this.heading));
}
}
private void ProcessConnectedStorage(Vector3 side, ref List <SegmentEntity> segments, List <SegmentEntity> adjacentSegments)
{
PositionUtils.GetSegmentPos(side, mnX, mnY, mnZ, out long segmentX, out long segmentY,
out long segmentZ);
Segment adjacentSegment = AttemptGetSegment(segmentX, segmentY, segmentZ);
if (adjacentSegment != null &&
CubeHelper.HasEntity(adjacentSegment.GetCube(segmentX, segmentY, segmentZ)))
{
var segmentEntity = adjacentSegment.SearchEntity(segmentX, segmentY, segmentZ);
if (segmentEntity is IQuantumStorage quantumStorageEntity)
{
adjacentSegments.Add(segmentEntity);
if (!segments.Contains(segmentEntity))
{
segments.Add(segmentEntity);
quantumStorageEntity.GetConnectedSegments(ref segments);
}
}
else if (segmentEntity is IQuantumIo || segmentEntity is QuantumStorageControllerMachine)
{
if (!segments.Contains(segmentEntity))
{
segments.Add(segmentEntity);
}
}
}
}
public void UpdatePositionWithITweenAnimation()
{
if (Tile != null && Index != Tile.Index && Index >= 0)
{
Index = Tile.Index;
MoveAnimation(PositionUtils.TransIndexToPosition(Index));
}
}
public void APointLeftOfADirectionIsNegOne()
{
var forward = new float3(0, 0, 1);
var left = new float3(-1, 0, 0);
var sign = PositionUtils.GetRelativeDirection(forward, left, math.up());
Assert.AreEqual(sign, -1, "Sign mismatch, should return -1 for a point left of the direction!");
}
public void APointRightOfADirectionIsPosOne()
{
var forward = new float3(0, 0, 1);
var right = new float3(1, 0, 0);
var sign = PositionUtils.GetRelativeDirection(forward, right, math.up());
Assert.AreEqual(sign, 1, "Sign mismatch, should return 1 for a point right of the direction!");
}
public void AddGameTile(int x, int y, GameTile tile)
{
if (tile != null)
{
tiles[x, y] = tile;
tile.SetNewIndex(PositionUtils.TransUnitPositionToIndex(new Vector2(x, y)));
}
}
public QuantumStorageControllerMachine(MachineEntityCreationParameters parameters) : base(parameters)
{
mbNeedsLowFrequencyUpdate = true;
mbNeedsUnityUpdate = true;
PositionUtils.SetupSidesPositions(parameters.Flags, _machineSides);
_storageControllerService = new StorageControllerService(this, _machineStorage, _machineSides);
_storageControllerPowerService = new StorageControllerPowerService(this, _machinePower, _machineSides);
_itemInputRules = new List <ItemInputRule>();
}
public void updateMovement(float distance)
{
Vector2 position = base.Position;
float rotation = base.Rotation;
PositionUtils.handleChildMovement(distance, ref this.heading, ref position, ref rotation, ref this.targetPositions);
base.Position = position;
base.Rotation = rotation;
}
public MyHexPosition ToGlobalPosition(MyHexPosition position)
{
var localPositionCube = PositionUtils.AxialToCube(position);
for (int i = 0; i < _globalCenterOrientation.ClockwiseIndex(); i++)
{
localPositionCube = RotateRightByOneStep(localPositionCube);
}
return(PositionUtils.CubeToAxial(localPositionCube) + _globalCenterPosition);
}
private void MainForm_Paint(object sender, PaintEventArgs e)
{
e.Graphics.DrawCircle(LocalPen, LocalX, LocalY, 5);
if (NetworkedX != NetworkedTargetX || NetworkedY != NetworkedTargetY)
{
NetworkedX = PositionUtils.Lerp(NetworkedOldX, NetworkedTargetX, 1.0f / Program.DeltaFactor);
NetworkedY = PositionUtils.Lerp(NetworkedOldY, NetworkedTargetY, 1.0f / Program.DeltaFactor);
}
e.Graphics.DrawCircle(NetworkedPen, NetworkedX, NetworkedY, 5);
}
public void InitializeGroupDataAndPosition(GameTileView[] group)
{
Vector2 tileStartUnitPos = GameSettings.spawnStartPoint;
for (int i = 0; i < group.Length; i++)
{
group[i].transform.SetParent(gameTilesGroupContent);
group[i].transform.localPosition = PositionUtils.TransUnitPositionToPosition(new Vector3(tileStartUnitPos.x, tileStartUnitPos.y + i));
group[i].InitializeIndex(PositionUtils.TransPositionToIndex(group[i].transform.position));
}
}
public MyHexPosition ToLocalPosition(MyHexPosition globalPosition)
{
var localPositionBeforeOrientation = globalPosition - _globalCenterPosition;
var localPositionCube = PositionUtils.AxialToCube(localPositionBeforeOrientation);
for (int i = 0; i < _globalCenterOrientation.ClockwiseIndex(); i++)
{
localPositionCube = RotateLeftByOneStep(localPositionCube);
}
return(PositionUtils.CubeToAxial(localPositionCube));
}
public override void SetData(LoadParcelScenesMessage.UnityParcelScene data)
{
this.sceneData = data;
contentProvider = new ContentProvider();
contentProvider.baseUrl = data.baseUrl;
contentProvider.contents = data.contents;
contentProvider.BakeHashes();
if (DCLCharacterController.i != null)
{
gameObject.transform.position = PositionUtils.WorldToUnityPosition(Utils.GridToWorldPosition(data.basePosition.x, data.basePosition.y));
}
}
public void ParseQuery(object payload, string sceneId)
{
IParcelScene scene = Environment.i.world.state.loadedScenes[sceneId];
if (!(payload is RaycastQuery raycastQuery))
{
return;
}
Vector3 worldOrigin = raycastQuery.ray.origin + Utils.GridToWorldPosition(scene.sceneData.basePosition.x, scene.sceneData.basePosition.y);
raycastQuery.ray.unityOrigin = PositionUtils.WorldToUnityPosition(worldOrigin);
raycastQuery.sceneId = sceneId;
PhysicsCast.i.Query(raycastQuery);
}
public Vector2 generateSpawn(bool surround = true, bool markGeneratedPosition = true)
{
Vector2 position;
do
{
position = new Vector2(PositionUtils.getPosition(rand.Next(1, Constants.MAX_X_TILES - 1)),
PositionUtils.getPosition(rand.Next(1, Constants.MAX_Y_TILES - 1)) + Constants.HUD_OFFSET + Constants.TILE_SIZE / 2 + Constants.OVERLAP);
} while (!isPositionSafe(position));
if (markGeneratedPosition)
{
markPosition(position, false, surround);
}
return(position);
}
public int CheckIfItemExistAndReturnIndex()
{
for (int j = 0; j < sizeY; j++)
{
for (int i = 0; i < sizeX; i++)
{
if (tiles[i, j] != null && tiles[i, j].itemType == ItemType.Item)
{
return(PositionUtils.TransUnitPositionToIndex(new Vector2(i, j)));
}
}
}
return(-1);
}
public static Vector3 ConvertUnityToScenePosition(Vector3 pos, IParcelScene scene = null)
{
if (scene == null)
{
scene = GetCurrentScene();
if (scene == null)
{
return(pos);
}
}
Vector3 worldPosition = PositionUtils.UnityToWorldPosition(pos);
return(worldPosition - Utils.GridToWorldPosition(scene.sceneData.basePosition.x, scene.sceneData.basePosition.y));
}
public bool CheckTiles()
{
IndexesToDisappear = new List <List <int> >();
for (int j = 0; j < sizeY; j++)
{
for (int i = 0; i < sizeX; i++)
{
int index = PositionUtils.TransUnitPositionToIndex(new Vector2(i, j));
if (i <= sizeX - 2 && CheckLeftRightTiles(tiles[i, j], tiles[i + 1, j]))
{
IndexesToDisappear.Add(new List <int>()
{
index, index + 1
});
ScoreManager.Instance.AddScore(DestroyType.Kiss, 2);
}
else if (i <= sizeX - 3)
{
int lastReturnPosX = CheckMiddleKiss(new Vector2(i, j));
if (lastReturnPosX != -1)
{
List <int> middleKissIndexes = new List <int>();
for (int z = 0; z <= lastReturnPosX - i; z++)
{
middleKissIndexes.Add(index + z);
}
IndexesToDisappear.Add(middleKissIndexes);
ScoreManager.Instance.AddScore(DestroyType.Kiss, middleKissIndexes.Count);
}
}
}
}
if (IndexesToDisappear.Count > 0)
{
return(true);
}
else
{
return(false);
}
}
public ItemConsumerInterface GetItemConsumer()
{
PositionUtils.GetSegmentPos(_machineSides.Back, _machine.mnX, _machine.mnY, _machine.mnZ, out long segmentX, out long segmentY,
out long segmentZ);
Segment adjacentSegment = _machine.AttemptGetSegment(segmentX, segmentY, segmentZ);
if (adjacentSegment != null &&
CubeHelper.HasEntity(adjacentSegment.GetCube(segmentX, segmentY, segmentZ)) &&
adjacentSegment.SearchEntity(segmentX, segmentY, segmentZ) is ItemConsumerInterface adjacentItemConsumer)
{
return(adjacentItemConsumer);
}
else
{
return(null);
}
}
public void updateMovement(float distance)
{
Vector2 currentPosition = base.Position;
Vector2 position = base.Position;
float rotation = base.Rotation;
PositionUtils.handleChildMovement(distance, ref this.heading, ref position, ref rotation, ref this.targetPositions);
base.Position = position;
base.Rotation = rotation;
PositionGenerator.getInstance().updateLocation(currentPosition, position);
if (this.child != null)
{
this.child.updateMovement(distance);
}
}
