private void OnDrawGizmos()
{
Gizmos.color = Color.green;
foreach (Square point in squares)
{
Gizmos.DrawSphere(point.pos, 0.1f);
}
if (Pathing?.MasterPath == null)
{
return;
}
Gizmos.color = Color.red;
int enteranceKey = GridUtilities.TwoToOne(enterances[enterance]);
if (!Pathing.MasterPath.ContainsKey(enteranceKey))
{
return;
}
var enterancePaths = Pathing.MasterPath[enteranceKey];
int key = GridUtilities.TwoToOne(exits[exit]);
if (!enterancePaths.ContainsKey(key))
{
return;
}
var exitPaths = enterancePaths[key];
DrawPath(exitPaths);
}
List <Vector2Int> GetCellsWithinRange()
{
cellPositionsInRange.Clear();
Vector2Int playerPosition = gameObject.GetComponent <GridPosition2d>().GridPosition;
Vector2Int offset = new Vector2Int();
int Range = movementPointsPerTurn;
for (int x = Range; x >= -Range; x--)
{
for (int y = Range; y >= -Range; y--)
{
if ((Mathf.Abs(x) + Mathf.Abs(y) > Range) == false)// Check if movement is out of player's range without diagonal movement.
{
offset.x = x;
offset.y = y;
if (GridUtilities.IsGridCellOccupied(ParentGrid, playerPosition + offset) == false)
{
cellPositionsInRange.Add(playerPosition + offset);
}
}
}
}
return(cellPositionsInRange);
}
public void SaveGrid(string NameOrIdentity = "")
{
GridResult Result = new GridResult(true);
//Gets grids player is looking at
if (!Result.GetGrids(Chat, AdminUserCharacter, NameOrIdentity))
{
return;
}
GridStamp stamp = Result.GenerateGridStamp();
PlayerHangar PlayersHanger = new PlayerHangar(Result.OwnerSteamID, Chat, true);
GridUtilities.FormatGridName(PlayersHanger, stamp);
if (PlayersHanger.SaveGridsToFile(Result, stamp.GridName))
{
PlayersHanger.SaveGridStamp(stamp, true);
Chat?.Respond("Save Complete!");
}
else
{
Chat?.Respond("Saved Failed!");
return;
}
}
protected void setFollowUpMatrix(Label lblMatrix, decimal?quoted, decimal?actual, int opportunitiesCount, string action)
{
string formattedValue = "";
switch (GridUtilities.GetActivityPhaseEnum(action))
{
case Enums.OpportunitySteps.Qualifying:
{
formattedValue = string.Format("{0} Active, {1:c}", opportunitiesCount, quoted) + " estimated";
break;
}
case Enums.OpportunitySteps.Responding:
{
formattedValue = string.Format("{0} Active, {1:c}", opportunitiesCount, quoted) + " quoted";
break;
}
case Enums.OpportunitySteps.Completing:
{
formattedValue = string.Format("{0} Active, {1:c}", opportunitiesCount, quoted) + " quoted / " + string.Format("{0:c}", actual) + " actual";
break;
}
}
lblMatrix.Text = formattedValue;
}
private void SpawnedGridsSuccessful(HashSet <MyCubeGrid> Grids)
{
GridUtilities.BiggestGrid(Grids, out MyCubeGrid BiggestGrid);
if (BiggestGrid != null && IdentityID != 0)
{
GpsSender.SendGps(BiggestGrid.PositionComp.GetPosition(), BiggestGrid.DisplayName, IdentityID);
}
}
string DrawPathIndexesString()
{
string output = "";
foreach (int index in drawPathIndexes)
{
output += GridUtilities.OneToTwo(index).ToString();
output += ", ";
}
return(output);
}
public IEnumerator BuildTask(BuildingBase building)
{
Vector3Int gridPos = GridUtilities.WorldToCell(TilemapManager.instance.wallTilemap, building.transform.position);
yield return(StartCoroutine(MoveTo(gridPos)));
yield return(StartCoroutine(RotateTowards(building.transform.position)));
yield return(StartCoroutine(BuildBuilding(building)));
CompleteTask();
}
///////////////////
// TASK HANDLING //
///////////////////
public IEnumerator MineTask(MineableWall mineableWall)
{
Vector3Int gridPos = GridUtilities.WorldToCell(TilemapManager.instance.wallTilemap, mineableWall.transform.position);
yield return(StartCoroutine(MoveTo(gridPos)));
yield return(StartCoroutine(RotateTowards(mineableWall.transform.position)));
yield return(StartCoroutine(MineWall(mineableWall)));
CompleteTask();
}
public override void Complete()
{
GridUtilities gridUtil = new GridUtilities(TilemapManager.instance.wallTilemap);
List <Vector3Int> openPositions = gridUtil.GetEmptyNeighbors(owner.gameObject);
if (openPositions.Count > 0)
{
Miner newMiner = Instantiate(minerPrefab, openPositions[0] + new Vector3(0.5f, 0.5f, 0), Quaternion.Euler(Vector3.zero));
MinerManager.instance.AddMiner(newMiner);
base.Complete();
}
}
public List <Tile> CalculateAdamPath()
{
var pointedPath = GetPointedTile();
if (_adamMoveTargets.Contains(pointedPath))
{
return(GridUtilities.CalculatePath(_tiles, adam.currentTile, GetPointedTile()));
}
else
{
return(GridUtilities.EmptyTileList);
}
}
public IEnumerator MeleeAttackTask(BuildingBase building)
{
needsNewTask = false;
Vector3Int gridPos = GridUtilities.WorldToCell(TilemapManager.instance.wallTilemap, building.transform.position);
yield return(StartCoroutine(MoveTo(gridPos)));
yield return(StartCoroutine(RotateTowards(building.transform.position)));
yield return(StartCoroutine(MeleeAttack(building)));
needsNewTask = true;
}
public IActionResult GetListEmployee([FromBody] CustomDataSourceRequest request)
{
try
{
var Employee = _UserProvider.GetListEmployee();
DataSourceRequest req = GridUtilities.ConvertToKendoFromCustomRequest(request);
var filter = Employee.ToDataSourceResult(req);
return(Ok(filter));
}
catch (Exception ex)
{
throw;
}
}
public IActionResult Get([FromBody] CustomDataSourceRequest request)
{
try
{
var superior = _browseProvider.GetList();
DataSourceRequest req = GridUtilities.ConvertToKendoFromCustomRequest(request);
var filter = superior.ToDataSourceResult(req);
return(Ok(filter));
}
catch (Exception ex)
{
throw;
}
}
public IActionResult GetListCity([FromBody] CustomDataSourceRequest request, int provinceID)
{
try
{
var city = _cityProvider.GetList(provinceID);
DataSourceRequest req = GridUtilities.ConvertToKendoFromCustomRequest(request);
var filter = city.ToDataSourceResult(req);
return(Ok(filter));
}
catch (Exception ex)
{
throw;
}
}
public IActionResult GetListProvince([FromBody] CustomDataSourceRequest request, int countryID)
{
try
{
var province = _provinceProvider.GetListByCountryID(countryID);
DataSourceRequest req = GridUtilities.ConvertToKendoFromCustomRequest(request);
var filter = province.ToDataSourceResult(req);
return(Ok(filter));
}
catch (Exception ex)
{
throw;
}
}
void CheckNextPath(ref Path currentPath, Square next, int pathInt, Vector2Int dir)
{
if (next != null && !next.hasBox &&
!PathIds.Contains(GridUtilities.TwoToOne(next.gridCoord)))
{
Path nextPath = new Path(next, currentPath);
nextPath = DownPath(nextPath, pathInt, dir);
if (nextPath != null)
{
currentPath.FutureSquares.Add(nextPath);
}
}
}
public IActionResult Get([FromBody] CustomDataSourceRequest request)
{
try
{
var employeeFilter = _employeeFilterProvider.List();
DataSourceRequest req = GridUtilities.ConvertToKendoFromCustomRequest(request);
var filter = employeeFilter.ToDataSourceResult(req);
return(Ok(filter));
}
catch (Exception ex)
{
throw ex;
}
}
public IActionResult GetSpesificationList([FromBody] CustomDataSourceRequest request, int id)
{
try
{
var jobTitle = _jobTitleProvider.GetSpesificationList(id);
DataSourceRequest req = GridUtilities.ConvertToKendoFromCustomRequest(request);
var filter = jobTitle.ToDataSourceResult(req);
return(Ok(filter));
}
catch (Exception ex)
{
throw;
}
}
public IActionResult GetListGradeDetail([FromBody] CustomDataSourceRequest request, int headerID)
{
try
{
var grades = _groupGradeProvider.ListGradeDetail(headerID);
DataSourceRequest req = GridUtilities.ConvertToKendoFromCustomRequest(request);
var filter = grades.ToDataSourceResult(req);
return(Ok(filter));
}
catch (Exception ex)
{
throw ex;
}
}
public ActionResult ListMajorSelected([FromBody] CustomDataSourceRequest request, int JobTitleID, string unselectedID)
{
try
{
int[] selectedIDDes = JsonConvert.DeserializeObject <int[]>(unselectedID);
var result = _jobTitleProvider.ListMajorSelected(JobTitleID, selectedIDDes);
DataSourceRequest req = GridUtilities.ConvertToKendoFromCustomRequest(request);
var filter = result.ToDataSourceResult(req);
return(Ok(filter));
}
catch (Exception)
{
throw;
}
}
public IActionResult GetListLocation([FromBody] CustomDataSourceRequest request, int organizationID)
{
try
{
var location = _organizationUnitProvider.ListLocation(organizationID);
DataSourceRequest req = GridUtilities.ConvertToKendoFromCustomRequest(request);
var filter = location.ToDataSourceResult(req);
return(Ok(filter));
}
catch (Exception ex)
{
throw ex;
}
}
public IActionResult GetDescriptionList([FromBody] CustomDataSourceRequest request, string id)
{
try
{
var ID = EncryptionHelper.DecryptUrlParam(id);
var jobTitle = _JobFamilyProvider.GetMajorList(Convert.ToInt32(ID));
DataSourceRequest req = GridUtilities.ConvertToKendoFromCustomRequest(request);
var filter = jobTitle.ToDataSourceResult(req);
return(Ok(filter));
}
catch (Exception ex)
{
throw;
}
}
public void SetEnterancesAndExits(List <Vector2Int> enterances, List <Vector2Int> exits)
{
Entrances = new List <int>();
Exits = new List <int>();
foreach (Vector2Int coord in enterances)
{
Entrances.Add(GridUtilities.TwoToOne(coord));
}
foreach (Vector2Int coord in exits)
{
Exits.Add(GridUtilities.TwoToOne(coord));
}
}
private void Update()
{
if (showBox)
{
Ray ray = Camera.main.ScreenPointToRay(mousePos);
RaycastHit groundHit;
bool hitDetect = Physics.BoxCast(
ray.origin,
currentObject.transform.localScale,
ray.direction,
out groundHit,
currentObject.transform.rotation,
10000,
groundMask
);
if (hitDetect)
{
boxLegal = !Physics.BoxCast(
ray.origin,
currentObject.transform.localScale / 2,
ray.direction,
currentObject.transform.rotation,
10000,
illegalMask
);
// Find the position of one of the corners.
Vector3 corner = new Vector3(
groundHit.point.x - currentObject.transform.localScale.x / 2,
currentObject.transform.position.y,
groundHit.point.z - currentObject.transform.localScale.z / 2
);
// Make sure the corner is aligned with the 8x8 grid.
corner = GridUtilities.RoundToNearestSquare(corner);
// Then convert back to the center position.
Vector3 center = new Vector3(
corner.x + currentObject.transform.localScale.x / 2,
corner.y,
corner.z + currentObject.transform.localScale.z / 2
);
currentObject.transform.position = center;
currentObject.GetComponent <MeshRenderer>().material = boxLegal ? legalPlan : illegalPlan;
}
}
}
public IActionResult Get([FromBody] CustomDataSourceRequest request)
{
try
{
//DataClaim.GetClaim(Request);
var orgUnitChange = _orgUnitChangeProvider.List();
DataSourceRequest req = GridUtilities.ConvertToKendoFromCustomRequest(request);
var filter = orgUnitChange.ToDataSourceResult(req);
return(Ok(filter));
}
catch (Exception ex)
{
throw;
}
}
public ActionResult ListEmployeeStatusUnselected([FromBody] CustomDataSourceRequest request, int ID)
{
try
{
int[] selectedIDDes = request.SelectedID.Select(int.Parse).ToArray();
//int[] selectedIDDes = JsonConvert.DeserializeObject<int[]>(selectedID);
var result = _employeeFilterProvider.ListStatusUnselected(ID, selectedIDDes);
DataSourceRequest req = GridUtilities.ConvertToKendoFromCustomRequest(request);
var filter = result.ToDataSourceResult(req);
return(Ok(filter));
}
catch (Exception)
{
throw;
}
}
public IActionResult Get([FromBody] CustomDataSourceRequest request)
{
try
{
DataClaim.GetClaim(Request);
var groupGrades = _groupGradeProvider.GetList();
DataSourceRequest req = GridUtilities.ConvertToKendoFromCustomRequest(request);
var filter = groupGrades.ToDataSourceResult(req);
return(Ok(filter));
}
catch (Exception ex)
{
throw ex;
}
}
public IActionResult Get([FromBody] CustomDataSourceRequest request)
{
try
{
DataClaim.GetClaim(Request);
var CostCenter = _SIUPClassProvider.GetList();
DataSourceRequest req = GridUtilities.ConvertToKendoFromCustomRequest(request);
var filter = CostCenter.ToDataSourceResult(req);
return(Ok(filter));
}
catch (Exception ex)
{
throw;
}
}
public IActionResult Get([FromBody] CustomDataSourceRequest request)
{
try
{
var levels = _LineOfBusinessProvider.GetList();
DataSourceRequest req = GridUtilities.ConvertToKendoFromCustomRequest(request);
var filter = levels.ToDataSourceResult(req);
return(Ok(filter));
}
catch (Exception ex)
{
throw;
}
}
public ActionResult ListSelected([FromBody] CustomDataSourceRequest request, int menuID)
{
try
{
//convert ke array
int[] unselectedIDDes = request.UnselectedID.Select(int.Parse).ToArray();
//int[] selectedIDDes = JsonConvert.DeserializeObject<int[]>(request);
var result = _menuProvider.ListSelected(menuID, unselectedIDDes);
DataSourceRequest req = GridUtilities.ConvertToKendoFromCustomRequest(request);
var filter = result.ToDataSourceResult(req);
return(Ok(filter));
}
catch (Exception)
{
throw;
}
}
