public static IDisposable RegisterOperations(SpatialOperations operations)
{
var originalValue = SpatialImplementation.CurrentImplementation.Operations;
SpatialImplementation.CurrentImplementation.Operations = operations;
return(new ActionOnDispose(() =>
{
SpatialImplementation.CurrentImplementation.Operations = originalValue;
}));
}
public void SetShipPosition(IShip s)
{
float tempx = 0;
float tempy = 0;
SpatialOperations.GetRandomPointInRadius(ref tempx, ref tempy, Size, Size + 1);
s.PosX = tempx;
s.PosY = tempy;
s.VelX = 0;
s.VelY = 0;
}
public override void SetEntryPosition(IHasPosition warpingObject, IArea oldArea)
{
if (oldArea == null)
{
warpingObject.PosX = 0;
warpingObject.PosY = 0;
warpingObject.SetRandomPointInRadius(Star.Radius + .1f, Star.Radius + 1f);
}
else
{
switch (oldArea.AreaType)
{
case AreaTypes.System:
{
SetEntryPositionFromSystem(warpingObject);
break;
}
case AreaTypes.Planet:
case AreaTypes.Port:
case AreaTypes.StarBase:
{
warpingObject.PosX = oldArea.PosX;
warpingObject.PosY = oldArea.PosY;
warpingObject.SetRandomPointInRadius(oldArea.AreaSize / 100f + .1f, oldArea.AreaSize / 100f + 1.5f);
break;
}
case AreaTypes.Colony:
{
var pa = oldArea.GetParentArea();
float parentPosX = pa.PosX;
float parentPosY = pa.PosY;
SpatialOperations.GetRandomPointInRadius(ref parentPosX, ref parentPosY, pa.AreaSize / 100f + .1f, pa.AreaSize / 100f + 1.5f);
warpingObject.PosX = parentPosX;
warpingObject.PosY = parentPosY;
break;
}
}
}
}
/// <summary>
/// Exports the shapes from the inputSF which fall within the given polygon, saving to the resultSF provided.
/// </summary>
/// <returns>False if an error occurs, true otherwise.</returns>
public static bool SelectPolygonsWithPolygon(ref MapWinGIS.Shapefile inputSF, ref MapWinGIS.Shape polygon, ref MapWinGIS.Shapefile resultSF, bool SkipMWShapeID)
{
MapWinUtility.Logger.Dbg("SelectPolygonsWithPolygon(inputSF: " + Macro.ParamName(inputSF) + ",\n" +
" polygon: " + Macro.ParamName(polygon) + ",\n" +
" resultSF: ref " + Macro.ParamName(resultSF) + ",\n" +
" SkipMWShapeID: " + SkipMWShapeID.ToString() + ")");
int numShapes = inputSF.NumShapes;
int shpIndex = 0;
if (Globals.CopyFields(ref inputSF, ref resultSF) == false)
{
return(false);
}
for (int i = 0; i <= numShapes - 1; i++)
{
MapWinGIS.Shape currShape = new MapWinGIS.ShapeClass();
currShape = inputSF.get_Shape(i);
bool boundsIntersect = Globals.CheckBounds(ref currShape, ref polygon);
if (boundsIntersect)
{
//check that actual intersection occurs
MapWinGIS.Shape intersectShp = new MapWinGIS.ShapeClass();
intersectShp = SpatialOperations.Intersection(currShape, polygon);
if (intersectShp != null && intersectShp.numPoints > 0)
{
//shape has at least a small portion inside polygon
shpIndex = resultSF.NumShapes;
if (resultSF.EditInsertShape(currShape, ref shpIndex) == false)
{
gErrorMsg = "Problem inserting shape into result file: " + resultSF.get_ErrorMsg(resultSF.LastErrorCode);
Debug.WriteLine(gErrorMsg);
Error.SetErrorMsg(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
//add the table values
int numFields = resultSF.NumFields;
for (int j = 0; j <= numFields - 1; j++)
{
if (resultSF.EditCellValue(j, shpIndex, inputSF.get_CellValue(j, i)) == false)
{
gErrorMsg = "Problem inserting value into DBF table: " + resultSF.get_ErrorMsg(resultSF.LastErrorCode);
Debug.WriteLine(gErrorMsg);
Error.SetErrorMsg(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
} //end of looping through table
} //end of checking for intersection
} //end of checking bounds
} //end of looping through shapes
if (resultSF.NumShapes > 0)
{
if (resultSF.NumFields == 0 || !SkipMWShapeID)
{
//add the ID field and values
if (Globals.DoInsertIDs(ref resultSF) == false)
{
return(false);
}
}
MapWinUtility.Logger.Dbg("Finished SelectPolygonsWithPolygon");
return(true);
}
else
{
MapWinUtility.Logger.Dbg("Finished SelectPolygonsWithPolygon");
return(false);
}
}
public void SupportedLinqQueries_GeometryPoint_OrderByDistanceFromLiteralToLiteral()
{
// Verify URI and results for LINQ queries that are valid only for GeometryPoint, orderby with literals
Func <DataServiceContext, LinqTestCase[]> getTests =
context =>
{
var allEntities = new GeometricEntity <GeometryPoint>[]
{
new GeometricEntity <GeometryPoint>()
{
ID = 1,
Property1 = GeometryFactory.Point(1, 2),
Property2 = GeometryFactory.Point(3, 4),
},
};
return(new LinqTestCase[]
{
new LinqTestCase()
{
Query = from t in context.CreateQuery <GeometricEntity <GeometryPoint> >("TripLegs")
orderby GeometryFactory.Point(5, 6).Build().Distance(GeometryFactory.Point(0, 0).Build())
select t,
ExpectedUri = "?$orderby=1.0",
ExpectedResults = allEntities,
ServerPayload = GetSampleFeedPayload(allEntities, null),
ExpectKeyInUri = false,
},
new LinqTestCase()
{
Query = from t in context.CreateQuery <GeometricEntity <GeometryPoint> >("TripLegs")
orderby GeometryFactory.Point(5, 6).Build().Distance(null)
select t,
ExpectedUri = "?$orderby=null",
ExpectedResults = allEntities,
ServerPayload = GetSampleFeedPayload(allEntities, null),
ExpectKeyInUri = false,
},
new LinqTestCase()
{
Query = from t in context.CreateQuery <GeometricEntity <GeometryPoint> >("TripLegs")
orderby((GeometryPoint)null).Distance(GeometryFactory.Point(5, 6).Build())
select t,
ExpectedUri = "?$orderby=null",
ExpectedResults = allEntities,
ServerPayload = GetSampleFeedPayload(allEntities, null),
ExpectKeyInUri = false,
},
new LinqTestCase()
{
Query = from t in context.CreateQuery <GeometricEntity <GeometryPoint> >("TripLegs")
orderby((GeometryPoint)null).Distance(null)
select t,
ExpectedUri = "?$orderby=null",
ExpectedResults = allEntities,
ServerPayload = GetSampleFeedPayload(allEntities, null),
ExpectKeyInUri = false,
},
});
};
SpatialOperations previousOperations = SpatialImplementation.CurrentImplementation.Operations;
SpatialImplementation.CurrentImplementation.Operations = new DistanceOperationImplementation();
try
{
TestSupportedLinqQueries(getTests);
}
finally
{
SpatialImplementation.CurrentImplementation.Operations = previousOperations;
}
}
/// <summary>
/// Removes portions of the lineSF that fall within the erase polygon
/// </summary>
/// <param name="lineSF">The shapefile of lines to be erased.</param>
/// <param name="erasePoly">The polygon to be used for erasing portion of the line shapefile.</param>
/// <param name="resultSF">The resulting line shapefile with portions removed.</param>
/// <param name="CopyAttributes">Indicates whether to copy attributes</param>
/// <returns>False if an error was encountered, true otherwise.</returns>
public static bool EraseLineSFWithPoly(ref MapWinGIS.Shapefile lineSF, ref MapWinGIS.Shape erasePoly, ref MapWinGIS.Shapefile resultSF, bool CopyAttributes)
{
MapWinUtility.Logger.Dbg("EraseLineSFWithPoly(lineSF: " + Macro.ParamName(lineSF) + ",\n" +
" erasePoly: " + Macro.ParamName(erasePoly) + ",\n" +
" resultSF: " + Macro.ParamName(resultSF) + ",\n" +
" CopyAttributes: " + CopyAttributes.ToString() + ")");
if (lineSF == null || erasePoly == null || resultSF == null)
{
gErrorMsg = "One of the input parameters is null.";
Error.SetErrorMsg(gErrorMsg);
Debug.WriteLine(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
if (CopyAttributes)
{
string tmpName;
MapWinGIS.Field tmpField, currField;
for (int f = 0; f <= lineSF.NumFields - 1; f++)
{
tmpField = new MapWinGIS.Field();
currField = lineSF.get_Field(f);
tmpName = currField.Name;
tmpField.Name = tmpName;
tmpField.Width = currField.Width;
tmpField.Type = currField.Type;
tmpField.Precision = currField.Precision;
tmpField.Key = currField.Key;
resultSF.EditInsertField(tmpField, ref f, null);
}
}
int shpIndex = 0;
int numLines = lineSF.NumShapes;
for (int i = 0; i <= numLines - 1; i++)
{
MapWinGIS.Shape currLine = new MapWinGIS.ShapeClass();
currLine.Create(lineSF.ShapefileType);
currLine = lineSF.get_Shape(i);
MapWinGIS.Shape lineEnvelope = new MapWinGIS.ShapeClass();
lineEnvelope.Create(MapWinGIS.ShpfileType.SHP_POLYGON);
//create lineExtents' points out of the line extent points
MapWinGIS.Point lTop, rTop, rBottom, lBottom;
lTop = new MapWinGIS.PointClass();
lTop.x = currLine.Extents.xMin;
lTop.y = currLine.Extents.yMax;
rTop = new MapWinGIS.PointClass();
rTop.x = currLine.Extents.xMax;
rTop.y = currLine.Extents.yMax;
rBottom = new MapWinGIS.PointClass();
rBottom.x = currLine.Extents.xMax;
rBottom.y = currLine.Extents.yMin;
lBottom = new MapWinGIS.PointClass();
lBottom.x = currLine.Extents.xMin;
lBottom.y = currLine.Extents.yMin;
//now add the extent points to the new polygon shape: lineEnvelope
int ptIndex = 0;
lineEnvelope.InsertPoint(lTop, ref ptIndex);
ptIndex++;
lineEnvelope.InsertPoint(rTop, ref ptIndex);
ptIndex++;
lineEnvelope.InsertPoint(rBottom, ref ptIndex);
ptIndex++;
lineEnvelope.InsertPoint(lBottom, ref ptIndex);
ptIndex++;
lineEnvelope.InsertPoint(lTop, ref ptIndex);
//remove COM points from memory
while (Marshal.ReleaseComObject(lTop) != 0)
{
;
}
while (Marshal.ReleaseComObject(rTop) != 0)
{
;
}
while (Marshal.ReleaseComObject(rBottom) != 0)
{
;
}
while (Marshal.ReleaseComObject(lBottom) != 0)
{
;
}
//Check if line extents and polygon extents overlap
if (Globals.CheckBounds(ref lineEnvelope, ref erasePoly))
{
//make the envelope polygon slightly larger
MapWinGIS.Shape lgEnvelope = new MapWinGIS.ShapeClass();
lgEnvelope.Create(MapWinGIS.ShpfileType.SHP_POLYGON);
SpatialOperations.BufferPolygon(ref lineEnvelope, 0.5, Enumerations.Buffer_HoleTreatment.Ignore, Enumerations.Buffer_CapStyle.Pointed, out lgEnvelope);
//take the difference of the envelope polygon with the erase polygon.
MapWinGIS.Shape diff = new MapWinGIS.ShapeClass();
diff.Create(MapWinGIS.ShpfileType.SHP_POLYGON);
diff = SpatialOperations.Difference(lgEnvelope, erasePoly);
if (diff.numPoints > 0)
{
//the difference shape represents the line envelope
//minus the area of the erase polygon.
MapWinGIS.Shapefile inputLine = new MapWinGIS.ShapefileClass();
string tempPath = System.IO.Path.GetTempPath() + "tempInputLine.shp";
//CDM 8/4/2006 inputLine.CreateNew(tempPath, lineSF.ShapefileType);
Globals.PrepareResultSF(ref tempPath, ref inputLine, lineSF.ShapefileType);
shpIndex = 0;
inputLine.EditInsertShape(currLine, ref shpIndex);
int numParts = diff.NumParts;
if (numParts == 0)
{
numParts = 1;
}
if (numParts > 1)
{
//separate and test each part individually
MapWinGIS.Shape[] diffParts = new MapWinGIS.Shape[numParts];
Globals.SeparateParts(ref diff, out diffParts);
for (int j = 0; j <= numParts - 1; j++)
{
//don't check inside of holes
if (Globals.IsClockwise(ref diffParts[j]))
{
MapWinGIS.Shapefile tempLineResult = new MapWinGIS.ShapefileClass();
string tempLineFile = System.IO.Path.GetTempPath() + "tempLines.shp";
DataManagement.DeleteShapefile(ref tempLineFile);
//CDM 8/4/2006 tempLineResult.CreateNew(tempLineFile, lineSF.ShapefileType);
Globals.PrepareResultSF(ref tempLineFile, ref tempLineResult, lineSF.ShapefileType);
tempLineResult.StartEditingShapes(true, null);
SpatialOperations.ClipShapesWithPolygon(ref inputLine, ref diffParts[j], out tempLineResult, false);
int numResults = tempLineResult.NumShapes;
if (numResults > 0)
{
//add results to the final result file.
for (int k = 0; k <= numResults - 1; k++)
{
shpIndex = resultSF.NumShapes;
resultSF.EditInsertShape(tempLineResult.get_Shape(k), ref shpIndex);
if (CopyAttributes)
{
for (int f = 0; f <= lineSF.NumFields - 1; f++)
{
bool tmpbool = resultSF.EditCellValue(f, shpIndex, lineSF.get_CellValue(f, i));
}
}
}
} //clipping successful
} //done checking islands
} //done looping through parts of the difference shape
}
else
{
MapWinGIS.Shapefile tempLineResult = new MapWinGIS.ShapefileClass();
string tempLineFile = System.IO.Path.GetTempPath() + "tempLines.shp";
DataManagement.DeleteShapefile(ref tempLineFile);
//CDM 8/4/2006 tempLineResult.CreateNew(tempLineFile, lineSF.ShapefileType);
Globals.PrepareResultSF(ref tempLineFile, ref tempLineResult, lineSF.ShapefileType);
tempLineResult.StartEditingShapes(true, null);
SpatialOperations.ClipShapesWithPolygon(ref inputLine, ref diff, out tempLineResult, false);
int numResults = tempLineResult.NumShapes;
if (numResults > 0)
{
//add results to the final result file.
for (int k = 0; k <= numResults - 1; k++)
{
shpIndex = resultSF.NumShapes;
resultSF.EditInsertShape(tempLineResult.get_Shape(k), ref shpIndex);
if (CopyAttributes)
{
for (int f = 0; f <= lineSF.NumFields - 1; f++)
{
bool tmpbool = resultSF.EditCellValue(f, shpIndex, lineSF.get_CellValue(f, i));
}
}
}
} //clipping successful
}
} //difference operation successful
} //bounds overlapped
else
{
shpIndex = resultSF.NumShapes;
resultSF.EditInsertShape(currLine, ref shpIndex);
if (CopyAttributes)
{
for (int f = 0; f <= lineSF.NumFields - 1; f++)
{
bool tmpbool = resultSF.EditCellValue(f, shpIndex, lineSF.get_CellValue(f, i));
}
}
}
} //end of looping through lines in the input shapefile
MapWinUtility.Logger.Dbg("Finished EraseLineSFWithPoly");
return(true);
}
/// <summary>
/// Removes portions of the input polygon shapefile that are within the erase polygons.
/// </summary>
/// <param name="inputSF">The input polygon shapefile.</param>
/// <param name="eraseSF">The erase polygon shapefile.</param>
/// <param name="resultSF">The resulting shapefile, with portions removed.</param>
/// <returns>False if an error was encountered, true otherwise.</returns>
public static bool ErasePolySFWithPolySF(ref MapWinGIS.Shapefile inputSF, ref MapWinGIS.Shapefile eraseSF, ref MapWinGIS.Shapefile resultSF)
{
MapWinUtility.Logger.Dbg("ErasePolySFWithPolySF(inputSF: " + Macro.ParamName(inputSF) + ",\n" +
" eraseSF: " + Macro.ParamName(eraseSF) + ",\n" +
" resultSF: " + Macro.ParamName(resultSF) + ",\n");
if (inputSF == null || eraseSF == null || resultSF == null)
{
gErrorMsg = "One of the input parameters is null.";
Error.SetErrorMsg(gErrorMsg);
Debug.WriteLine(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
int numInputs = inputSF.NumShapes;
int shpIndex = 0;
//create the result shapefile out of the original inputSF
for (int i = 0; i <= numInputs - 1; i++)
{
shpIndex = resultSF.NumShapes;
resultSF.EditInsertShape(inputSF.get_Shape(i), ref shpIndex);
}
int numErase = eraseSF.NumShapes;
for (int i = 0; i <= numErase - 1; i++)
{
MapWinGIS.Shape eraseShape = new MapWinGIS.ShapeClass();
eraseShape = eraseSF.get_Shape(i);
MapWinGIS.Shape resultShp = new MapWinGIS.ShapeClass();
for (int j = 0; j <= numInputs - 1; j++)
{
MapWinGIS.Shape currShape = new MapWinGIS.ShapeClass();
currShape = resultSF.get_Shape(j);
//if bounds intersect, then check if all polygon points are inside the currShape
if (Globals.CheckBounds(ref currShape, ref eraseShape))
{
int numPts = eraseShape.numPoints;
bool allInside = true;
int numParts = eraseShape.NumParts;
if (numParts == 0)
{
numParts = 1;
}
Globals.Vertex[][] vertArray = new Globals.Vertex[numParts][];
Globals.ConvertPolyToVertexArray(ref currShape, out vertArray);
for (int k = 0; k <= numPts - 1; k++)
{
double x = eraseShape.get_Point(k).x;
double y = eraseShape.get_Point(k).y;
if (Utils.PointInPoly(ref vertArray, x, y) == false)
{
allInside = false;
break;
}
}
if (allInside == true)
{
resultShp = new MapWinGIS.ShapeClass();
resultShp.Create(inputSF.ShapefileType);
//we want the symmetric difference of these two shapes
//which should leave us with a hole where the erase polygon was in the currShape
resultShp = SpatialOperations.SymmetricDifference(eraseShape, currShape);
}
else
{
//erase overlapping section and add result to the file.
MapWinGIS.Shape intersect = new MapWinGIS.ShapeClass();
intersect.ShapeType = inputSF.ShapefileType;
intersect = SpatialOperations.Intersection(eraseShape, currShape);
if (intersect.numPoints > 0)
{
MapWinGIS.Shape diff = new MapWinGIS.ShapeClass();
diff.ShapeType = eraseShape.ShapeType;
diff = SpatialOperations.Difference(currShape, eraseShape);
int numPoints = diff.numPoints;
if (numPoints > 0)
{
resultShp = new MapWinGIS.ShapeClass();
resultShp.Create(inputSF.ShapefileType);
resultShp = diff;
} //difference operation successful
} //intersect operation successful
else
{
//no intersection, shapes do not collide
resultShp = currShape;
}
} //all points of erase polygon are not inside currShape
if (resultShp.numPoints > 0)
{
shpIndex = j;
resultSF.EditDeleteShape(shpIndex);
resultSF.EditInsertShape(resultShp, ref shpIndex);
}
} //end of bounds intersect
} //end of looping through input polygons
} //end of looping through erase polygons
MapWinUtility.Logger.Dbg("Finsihed ErasePolySFWithPolySF");
return(true);
}
/// <summary>
/// Erases the portions of the polygon shapefile that are within the polygon shape.
/// </summary>
/// <param name="polySF">The polygon shapefile.</param>
/// <param name="polygon">The erase polygon.</param>
/// <param name="resultSF">The resulting shapefile, with portions removed.</param>
/// <param name="CopyAttributes">Indicates whether to copy attributes or not.</param>
/// <returns>False if an error was encountered, true otherwise.</returns>
public static bool ErasePolySFWithPoly(ref MapWinGIS.Shapefile polySF, ref MapWinGIS.Shape polygon, ref MapWinGIS.Shapefile resultSF, bool CopyAttributes)
{
MapWinUtility.Logger.Dbg("ErasePolySFWithPoly(polySF: " + Macro.ParamName(polySF) + ",\n" +
" polygon: " + Macro.ParamName(polygon) + ",\n" +
" resultSF: " + Macro.ParamName(resultSF) + "\n" +
" CopyAttributes: " + CopyAttributes.ToString());
if (polySF == null || polygon == null || resultSF == null)
{
gErrorMsg = "One of the input parameters is null.";
Error.SetErrorMsg(gErrorMsg);
Debug.WriteLine(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
if (CopyAttributes)
{
string tmpName;
MapWinGIS.Field tmpField, currField;
for (int f = 0; f <= polySF.NumFields - 1; f++)
{
tmpField = new MapWinGIS.Field();
currField = polySF.get_Field(f);
tmpName = currField.Name;
tmpField.Name = tmpName;
tmpField.Width = currField.Width;
tmpField.Type = currField.Type;
tmpField.Precision = currField.Precision;
tmpField.Key = currField.Key;
resultSF.EditInsertField(tmpField, ref f, null);
}
}
int numShapes = polySF.NumShapes;
int shpIndex = 0;
for (int i = 0; i <= numShapes - 1; i++)
{
MapWinGIS.Shape currShape = new MapWinGIS.Shape();
MapWinGIS.Shape resultShp = new MapWinGIS.Shape();
currShape = polySF.get_Shape(i);
//if bounds intersect, then check if all polygon points are inside the currShape
if (Globals.CheckBounds(ref currShape, ref polygon))
{
int numPts = polygon.numPoints;
bool allInside = true;
int numParts = currShape.NumParts;
if (numParts == 0)
{
numParts = 1;
}
Globals.Vertex[][] vertArray = new Globals.Vertex[numParts][];
Globals.ConvertPolyToVertexArray(ref currShape, out vertArray);
for (int j = 0; j <= numPts - 1; j++)
{
double x = polygon.get_Point(j).x;
double y = polygon.get_Point(j).y;
if (Utils.PointInPoly(ref vertArray, x, y) == false)
{
allInside = false;
break;
}
}
if (allInside == true)
{
resultShp = new MapWinGIS.ShapeClass();
resultShp.Create(polygon.ShapeType);
//we want the symmetric difference of these two shapes
//which should leave us with a hole where the erase polygon was in the currShape
resultShp = SpatialOperations.SymmetricDifference(polygon, currShape);
}
else
{
//erase overlapping section and add result to the file.
MapWinGIS.Shape intersect = new MapWinGIS.ShapeClass();
intersect.ShapeType = polygon.ShapeType;
intersect = SpatialOperations.Intersection(polygon, currShape);
if (intersect.numPoints > 0)
{
//there might be parts in the difference result that do not belong,
//perform an intersection operation with currShape to remove them.
MapWinGIS.Shape diff = new MapWinGIS.ShapeClass();
diff.ShapeType = polygon.ShapeType;
//diff = SpatialOperations.SymmetricDifference(intersect, currShape);
diff = SpatialOperations.Difference(currShape, polygon);
int numPoints = diff.numPoints;
if (numPoints > 0)
{
resultShp = diff;
} //difference operation successful
} //intersect operation successful
else
{
//no intersection, shapes do not collide
resultShp = currShape;
}
} //all points of erase polygon are not inside currShape
if (resultShp.numPoints > 0)
{
shpIndex = resultSF.NumShapes;
if (resultSF.EditInsertShape(resultShp, ref shpIndex) == false)
{
gErrorMsg = "ErasePolySF: problem inserting shape into result file: " + resultSF.get_ErrorMsg(resultSF.LastErrorCode);
Debug.WriteLine(gErrorMsg);
Error.SetErrorMsg(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
if (CopyAttributes)
{
for (int f = 0; f <= polySF.NumFields - 1; f++)
{
bool tmpbool = resultSF.EditCellValue(f, shpIndex, polySF.get_CellValue(f, i));
}
}
}
} //end of if bounds intersect
else
{
//the erase object does not intersect with the current polygon,
//add current polygon to resultSF in unchanged form
shpIndex = resultSF.NumShapes;
if (resultSF.EditInsertShape(currShape, ref shpIndex) == false)
{
gErrorMsg = "ErasePolySF: problem inserting shape into result file: " + resultSF.get_ErrorMsg(resultSF.LastErrorCode);
Debug.WriteLine(gErrorMsg);
Error.SetErrorMsg(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
if (CopyAttributes)
{
for (int f = 0; f <= polySF.NumFields - 1; f++)
{
bool tmpbool = resultSF.EditCellValue(f, shpIndex, polySF.get_CellValue(f, i));
}
}
}
} //end of looping through shapes in shapefile
MapWinUtility.Logger.Dbg("Finished ErasePolySFWithPoly");
return(true);
}
/// <summary>
/// Returns all portions of the shapefile polygons that fall within the clipper polygon.
/// </summary>
/// <param name="polySFPath">The full path to the shapefile of polygons to be clipped.</param>
/// <param name="polygon">The polygon used for clipping the shapefile.</param>
/// <param name="resultSFPath">The full path to the result file for where the clipped polygons should be saved.</param>
/// <param name="copyAttributes">True if copying attrs</param>
/// <returns>False if an error was encountered, true otherwise.</returns>
public static bool ClipPolygonSFWithPolygon(ref string polySFPath, ref MapWinGIS.Shape polygon, ref string resultSFPath, bool copyAttributes)
{
MapWinUtility.Logger.Dbg("ClipPolygonSFWithPolygon(polySFPath: " + polySFPath + ",\n " +
" polygon: + " + Macro.ParamName(polygon) + ",\n" +
" resultsSFPath: " + resultSFPath + ",\n" +
" copyAttributes: " + copyAttributes + ",\n");
MapWinGIS.Shapefile resultSF = new MapWinGIS.ShapefileClass();
MapWinGIS.Shapefile polySF = new MapWinGIS.ShapefileClass();
polySF.Open(polySFPath, null);
MapWinGIS.ShpfileType sfType = polySF.ShapefileType;
int shapeIndex = 0;//insert new shapes at the beginning of the shapefile
string tmpName;
if (Globals.PrepareResultSF(ref resultSFPath, ref resultSF, sfType, copyAttributes) == false)
{
polySF.Close();
return(false);
}
if (copyAttributes)
{
MapWinGIS.Field tmpField, currField;
for (int f = 0; f <= polySF.NumFields - 1; f++)
{
tmpField = new MapWinGIS.Field();
currField = polySF.get_Field(f);
tmpName = currField.Name;
if (tmpName.Contains("MWShapeID"))
{
tmpField.Name = "Last_" + tmpName;
}
else
{
tmpField.Name = tmpName;
}
tmpField.Width = currField.Width;
tmpField.Type = currField.Type;
tmpField.Precision = currField.Precision;
tmpField.Key = currField.Key;
resultSF.EditInsertField(tmpField, ref f, null);
}
}
if (sfType == MapWinGIS.ShpfileType.SHP_POLYGON || sfType == MapWinGIS.ShpfileType.SHP_POLYGONM || sfType == MapWinGIS.ShpfileType.SHP_POLYGONZ)
{
MapWinGIS.Shape resultShape = new MapWinGIS.ShapeClass();
MapWinGIS.Extents shpExtents = new MapWinGIS.ExtentsClass();
int numShapes = polySF.NumShapes;
bool boundsIntersect = false;
for (int i = 0; i <= numShapes - 1; i++)
{
MapWinGIS.Shape currPoly = new MapWinGIS.ShapeClass();
currPoly = polySF.get_Shape(i);
//check to see if bounds intersect before sending shape to GPC clip function
boundsIntersect = Globals.CheckBounds(ref currPoly, ref polygon);
if (boundsIntersect == true)
{
//find the shape resulting from intersection
resultShape = SpatialOperations.Intersection(currPoly, polygon);
if (resultShape.numPoints != 0)
{
//save the new shape to the result shapefile
if (resultSF.EditInsertShape(resultShape, ref shapeIndex) == false)
{
gErrorMsg = "Problem inserting shape: " + resultSF.get_ErrorMsg(resultSF.LastErrorCode);
Debug.WriteLine(gErrorMsg);
Error.SetErrorMsg(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
if (copyAttributes)
{
for (int f = 0; f <= polySF.NumFields - 1; f++)
{
bool tmpbool = resultSF.EditCellValue(f, shapeIndex, polySF.get_CellValue(f, i));
}
}
}
}
}
}
if (copyAttributes)
{
MapWinGIS.Field ID = new MapWinGIS.FieldClass();
ID.Name = "MWShapeID";
ID.Type = MapWinGIS.FieldType.INTEGER_FIELD;
int fieldIndex = 0;
if (resultSF.EditInsertField(ID, ref fieldIndex, null) == false)
{
gErrorMsg = "Problem inserting field into .dbf table: " + resultSF.get_ErrorMsg(resultSF.LastErrorCode);
Debug.WriteLine(gErrorMsg);
Error.SetErrorMsg(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
}
int numIDs = resultSF.NumShapes;
for (int i = 0; i <= numIDs - 1; i++)
{
if (resultSF.EditCellValue(0, i, i) == false)
{
gErrorMsg = "Problem inserting value into .dbf table for shape " + i + ": " + resultSF.get_ErrorMsg(resultSF.LastErrorCode);
Debug.WriteLine(gErrorMsg);
Error.SetErrorMsg(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
}
if (resultSF.StopEditingShapes(true, true, null) == false)
{
gErrorMsg = "Problem with StopEditingShapes: " + resultSF.get_ErrorMsg(resultSF.LastErrorCode);
Debug.WriteLine(gErrorMsg);
Error.SetErrorMsg(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
resultSF.Close();
polySF.Close();
MapWinUtility.Logger.Dbg("Finished ClipPolygonSFWithPolygon");
return(true);
}
/// <summary>
/// Returns the portions of the polygons in polySF that lie within polygon as a
/// new shapefile of polygons: resultPolySF.
/// </summary>
/// <param name="polySF">The shapefile of polygons that are to be clipped.</param>
/// <param name="polygon">The polygon used for clipping.</param>
/// <param name="resultPolySF">The result shapefile for the resulting polygons to be saved (in-memory).</param>
/// <param name="copyAttributes">True if copying attrs</param>
/// <returns>False if an error was encountered, true otherwise.</returns>
public static bool ClipPolygonSFWithPolygon(ref MapWinGIS.Shapefile polySF, ref MapWinGIS.Shape polygon, out MapWinGIS.Shapefile resultPolySF, bool copyAttributes)
{
MapWinUtility.Logger.Dbg("ClipPolygonSFWithPolygon(polySF: " + Macro.ParamName(polySF) + ",\n" +
" polygon: " + Macro.ParamName(polygon) + ",\n" +
" resultPolySF: out,\n" +
" copyAttributes: " + copyAttributes.ToString() + "\n");
MapWinGIS.Shapefile resultSF = new MapWinGIS.ShapefileClass();
MapWinGIS.ShpfileType sfType = polySF.ShapefileType;
string tempPath = System.IO.Path.GetTempPath() + "resultSF.shp";
DataManagement.DeleteShapefile(ref tempPath);
string tmpName;
Globals.PrepareResultSF(ref tempPath, ref resultSF, sfType, copyAttributes);
if (copyAttributes)
{
MapWinGIS.Field tmpField, currField;
for (int f = 0; f <= polySF.NumFields - 1; f++)
{
tmpField = new MapWinGIS.Field();
currField = polySF.get_Field(f);
tmpName = currField.Name;
if (tmpName.Contains("MWShapeID"))
{
tmpField.Name = "Last_" + tmpName;
}
else
{
tmpField.Name = tmpName;
}
tmpField.Width = currField.Width;
tmpField.Type = currField.Type;
tmpField.Precision = currField.Precision;
tmpField.Key = currField.Key;
resultSF.EditInsertField(tmpField, ref f, null);
}
}
int shapeIndex = 0; //insert new shapes at the beginning of the shapefile
if (polySF.NumShapes != 0 && polygon.numPoints != 0 && (sfType == MapWinGIS.ShpfileType.SHP_POLYGON || sfType == MapWinGIS.ShpfileType.SHP_POLYGONM || sfType == MapWinGIS.ShpfileType.SHP_POLYGONZ))
{
MapWinGIS.Shape resultShape = new MapWinGIS.ShapeClass();
int numShapes = polySF.NumShapes;
bool boundsIntersect = false;
for (int i = 0; i <= numShapes - 1; i++)
{
MapWinGIS.Shape currPoly = new MapWinGIS.ShapeClass();
currPoly = polySF.get_Shape(i);
//check to see if bounds intersect before sending shape to GPC clip function
boundsIntersect = Globals.CheckBounds(ref currPoly, ref polygon);
if (boundsIntersect == true)
{
//find the shape resulting intersection
resultShape = SpatialOperations.Intersection(polySF.get_Shape(i), polygon);
if (resultShape.numPoints != 0)
{
//save the new shape to the result shapefile
if (resultSF.EditInsertShape(resultShape, ref shapeIndex) == false)
{
gErrorMsg = "Problem inserting shape: " + resultSF.get_ErrorMsg(resultSF.LastErrorCode);
Debug.WriteLine(gErrorMsg);
MapWinGeoProc.Error.SetErrorMsg(gErrorMsg);
resultPolySF = resultSF;
return(false);
}
if (copyAttributes)
{
for (int f = 0; f <= polySF.NumFields - 1; f++)
{
bool tmpbool = resultSF.EditCellValue(f, shapeIndex, polySF.get_CellValue(f, i));
}
}
}
}
}
}
resultPolySF = resultSF;
return(true);
}
private static double GetIDWeightBrute(InterpolationPoint CellPoint, InterpolationPoint TestPoint, String ProjUnits, double Power)
{
return(1 / Math.Pow(SpatialOperations.Distance(CellPoint.X, CellPoint.Y, TestPoint.X, TestPoint.Y, ProjUnits), Power));
}
private static double GetIDWeight(double[] InCellPoint, double[] InTestPoint, String ProjUnits, double Power)
{
return(1 / Math.Pow(SpatialOperations.Distance(InCellPoint[0], InCellPoint[1], InTestPoint[0], InTestPoint[1], ProjUnits), Power));
}
/// <summary>
/// Creates a new grid containing data from the input grid that
/// falls within the polygon boundary.
/// </summary>
/// <param name="inputGF">Full path to the input grid file.</param>
/// <param name="poly">The 2D polygon used for clipping the input grid.</param>
/// <param name="resultGF">Full path to where the resulting grid will be saved.</param>
/// <param name="clipToExtents">True if clipping to polygon extents rather than actual polygon shape.</param>
/// <returns>True if clipping was successful, false if an error occurs.</returns>
public static bool ClipGridWithPolygon(ref string inputGF, ref MapWinGIS.Shape poly, ref string resultGF, bool clipToExtents)
{
MapWinUtility.Logger.Dbg("ClipGridWithPolygon(inputGF: " + inputGF + ",\n" +
" poly: " + Macro.ParamName(poly) + ",\n" +
" resultGF: " + resultGF + ",\n" +
" clipToExtents: " + clipToExtents.ToString());
Error.ClearErrorLog();
// System.Diagnostics.PerformanceCounter ramCounter;
// ramCounter = new PerformanceCounter("Memory", "Available Bytes");
// float availableRAM = ramCounter.NextValue();
bool inRAM = true;
//open grid to get info and traverse through points
MapWinGIS.Grid grid = new MapWinGIS.GridClass();
//check memory availability
// availableRAM = ramCounter.NextValue();//amount of RAM in bytes
// Debug.WriteLine("available RAM: " + availableRAM.ToString() + " bytes");
// System.IO.FileInfo fileInfo = new FileInfo(inputGF);
// long fileSize = fileInfo.Length; //size of file in bytes
// Debug.WriteLine("file size: " + fileSize.ToString() + " bytes");
// if(fileSize*2 < availableRAM)
// {//go ahead and load grid into memory
// inRAM = true;
// }
// else
// {
// inRAM = false;
// }
if (grid.Open(inputGF, MapWinGIS.GridDataType.UnknownDataType, inRAM, MapWinGIS.GridFileType.UseExtension, null) == false)
{
gErrorMsg = "Error occurred while trying to open grid: " + grid.get_ErrorMsg(grid.LastErrorCode);
Error.SetErrorMsg(gErrorMsg);
Debug.WriteLine(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
int numCols = grid.Header.NumberCols;
int numRows = grid.Header.NumberRows;
double cellWidth = grid.Header.dX;
double cellHeight = grid.Header.dY;
double xllCenter = grid.Header.XllCenter;
double yllCenter = grid.Header.YllCenter;
//now calculate the UNCOMPRESSED grid file size:
long inputGFSize = numCols * numRows * 8;
//find the grid extents
double minX, maxX, minY, maxY;
minX = xllCenter - (cellWidth / 2);
maxX = xllCenter + (cellWidth * (numCols - 1)) + (cellWidth / 2);
minY = yllCenter - (cellHeight / 2);
maxY = yllCenter + (cellHeight * (numRows - 1)) + (cellHeight / 2);
//see if grid and poly extents cross:
double polyMinX = poly.Extents.xMin;
double polyMaxX = poly.Extents.xMax;
double polyMinY = poly.Extents.yMin;
double polyMaxY = poly.Extents.yMax;
bool boundsIntersect = Globals.CheckBounds(minX, maxX, minY, maxY, polyMinX, polyMaxX, polyMinY, polyMaxY);
if (boundsIntersect == false)
{
grid.Close();
gErrorMsg = "Polygon and Grid boundaries do not overlap.";
Error.SetErrorMsg(gErrorMsg);
Debug.WriteLine(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
double newXll, newYll, firstXPt, firstYPt;
int newNumCols, newNumRows, firstCol, firstRow;
//check if polygon extents are completely inside of grid extents
if ((polyMinX >= minX && polyMinX <= maxX) && (polyMaxX >= minX && polyMaxX <= maxX) &&
(polyMinY >= minY && polyMinY <= maxY) && (polyMaxY >= minY && polyMaxY <= maxY))
{
Debug.WriteLine("Poly extents are inside of grid extents.");
minX = polyMinX;
minY = polyMinY;
maxX = polyMaxX;
maxY = polyMaxY;
//Find the new number of cols, rows, Xll and Yll values.
int lastCol, lastRow;
Globals.ProjToCell(minX, maxY, out firstCol, out firstRow, xllCenter, yllCenter, cellWidth, cellHeight, numRows);
Globals.ProjToCell(maxX, minY, out lastCol, out lastRow, xllCenter, yllCenter, cellWidth, cellHeight, numRows);
newNumCols = (lastCol - firstCol) + 1;
newNumRows = (lastRow - firstRow) + 1;
Debug.WriteLine("New numRows = " + newNumRows + " New numCols = " + newNumCols);
Globals.CellToProj(firstCol, lastRow, out newXll, out newYll, xllCenter, yllCenter, cellWidth, cellHeight, numRows);
Globals.CellToProj(firstCol, firstRow, out firstXPt, out firstYPt, xllCenter, yllCenter, cellWidth, cellHeight, numRows);
}
//check if grid extents are completely inside of polygon extents
//note: there is really no purpose in this, as the new grid is the same
//as the orgiginal grid....but we'll do it anyway.
else if ((minX >= polyMinX && minX <= polyMaxX) && (maxX >= polyMinX && maxX <= polyMaxX) &&
(minY >= polyMinY && minY <= polyMaxY) && (maxY >= polyMinY && maxY <= polyMaxY))
{
Debug.WriteLine("Grid extents are inside of polygon extents.");
//keep min and max values the same....no need to change them.
newNumCols = numCols;
newNumRows = numRows;
newXll = xllCenter;
newYll = yllCenter;
firstCol = 0;
firstRow = 0;
Globals.CellToProj(0, 0, out firstXPt, out firstYPt, xllCenter, yllCenter, cellWidth, cellHeight, numRows);
}
else //part of polygon lies outside of the grid, find intersecting boundary shape
{
Debug.WriteLine("Grid extents and polygon extents overlap.");
//create a new shape out of the grid extents
MapWinGIS.Shape gridEnvelope = new MapWinGIS.ShapeClass();
gridEnvelope.Create(MapWinGIS.ShpfileType.SHP_POLYGON);
MapWinGIS.Point pt = new MapWinGIS.PointClass();
pt.x = minX;
pt.y = maxY;
int ptIndex = 0;
gridEnvelope.InsertPoint(pt, ref ptIndex);
pt = new MapWinGIS.PointClass();
pt.x = maxX;
pt.y = maxY;
ptIndex = 1;
gridEnvelope.InsertPoint(pt, ref ptIndex);
pt = new MapWinGIS.PointClass();
pt.x = maxX;
pt.y = minY;
ptIndex = 2;
gridEnvelope.InsertPoint(pt, ref ptIndex);
pt = new MapWinGIS.PointClass();
pt.x = minX;
pt.y = minY;
ptIndex = 3;
gridEnvelope.InsertPoint(pt, ref ptIndex);
pt = new MapWinGIS.PointClass();
pt.x = minX;
pt.y = maxY;
ptIndex = 4;
gridEnvelope.InsertPoint(pt, ref ptIndex);
//create the final bounding envelope which is
//the intersection of the polygon and grid envelope:
MapWinGIS.Shape envelope = new MapWinGIS.ShapeClass();
envelope.Create(MapWinGIS.ShpfileType.SHP_POLYGON);
envelope = SpatialOperations.Intersection(gridEnvelope, poly);
if (envelope.numPoints == 0)
{
gErrorMsg = "Problem creating the bounding envelope. Aborting ClipGrid().";
Error.SetErrorMsg(gErrorMsg);
Debug.WriteLine(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
//calculate how many rows and columns will exist within the new grid
//that is: how many rows/cols fit within the bounding envelope.
minX = envelope.Extents.xMin;
minY = envelope.Extents.yMin;
maxX = envelope.Extents.xMax;
maxY = envelope.Extents.yMax;
newNumCols = (int)(((maxX - minX) / cellWidth) + 0.5);
newNumRows = (int)(((maxY - minY) / cellHeight) + 0.5);
newXll = minX + (cellWidth / 2);
newYll = minY + (cellHeight / 2);
firstXPt = newXll;
firstYPt = newYll + (cellHeight * (newNumRows - 1));
Globals.ProjToCell(firstXPt, firstYPt, out firstCol, out firstRow, xllCenter, yllCenter, cellWidth, cellHeight, numRows);
//done using COM objects, release them
while (Marshal.ReleaseComObject(pt) != 0)
{
;
}
pt = null;
while (Marshal.ReleaseComObject(gridEnvelope) != 0)
{
;
}
gridEnvelope = null;
while (Marshal.ReleaseComObject(envelope) != 0)
{
;
}
envelope = null;
}
// Chris M 12/13/2006 for BugZilla 377
// Below code:
// The grid header cannot be copied right across like that! The first line creates
// a new grid header; the second line deletes the newly created grid header and
// copies a reference to the original grid's header. Both grids then are using
// the same header; and when the last lines set the XllCenter and YllCenter,
// BOTH grids are updated with that information! A classic example of pointers gone wrong.
//MapWinGIS.GridHeader resultHeader = new MapWinGIS.GridHeaderClass();
//resultHeader = grid.Header;
//resultHeader.NodataValue = grid.Header.NodataValue;
//resultHeader.NumberCols = newNumCols;
//resultHeader.NumberRows = newNumRows;
//resultHeader.XllCenter = newXll;
//resultHeader.YllCenter = newYll;
// The right way to do it:
MapWinGIS.GridHeader resultHeader = new MapWinGIS.GridHeaderClass();
resultHeader.CopyFrom(grid.Header);
// Not really needed due to CopyFrom: resultHeader.NodataValue = grid.Header.NodataValue;
resultHeader.NumberCols = newNumCols;
resultHeader.NumberRows = newNumRows;
resultHeader.XllCenter = newXll;
resultHeader.YllCenter = newYll;
// Not really needed due to CopyFrom: resultHeader.dX = grid.Header.dX;
// Not really needed due to CopyFrom: resultHeader.dY = grid.Header.dY;
// Not really needed due to CopyFrom: resultHeader.Projection = grid.Header.Projection;
//create the new grid object
MapWinGIS.Grid resultGrid = new MapWinGIS.GridClass();
DataManagement.DeleteGrid(ref resultGF);
//check memory availability
// availableRAM = ramCounter.NextValue();//amount of RAM in bytes
// Debug.WriteLine("available RAM: " + availableRAM.ToString() + " bytes");
long resultGFSize = newNumCols * newNumRows * 8; //projected size of grid in bytes
// if(resultGFSize * 2 < availableRAM)
// {//go ahead and load grid into memory
// inRAM = true;
// }
// else
// {
// inRAM = false;
// }
if (resultGrid.CreateNew(resultGF, resultHeader, grid.DataType, grid.Header.NodataValue, inRAM, MapWinGIS.GridFileType.UseExtension, null) == false)
{
gErrorMsg = "Problem creating the result grid: " + resultGrid.get_ErrorMsg(resultGrid.LastErrorCode);
Debug.WriteLine(gErrorMsg);
Error.SetErrorMsg(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
//close the grids, we need to use the wrapper class now due to memory issues
resultGrid.Save(resultGF, MapWinGIS.GridFileType.UseExtension, null);
resultGrid.Close();
while (Marshal.ReleaseComObject(resultGrid) != 0)
{
;
}
resultGrid = null;
grid.Close();
while (Marshal.ReleaseComObject(grid) != 0)
{
;
}
grid = null;
//fill the result grid with values from the original grid
try
{
Debug.WriteLine("newNumRows = " + newNumRows + " newNumCols = " + newNumCols);
int rowClearCount = Globals.DetermineRowClearCount(newNumRows, newNumCols);
Debug.WriteLine("Clearing COM resources every " + rowClearCount + " rows.");
if (FillGrid(ref inputGF, ref resultGF, ref poly, newNumRows, newNumCols, rowClearCount, firstCol, firstRow, firstXPt, firstYPt, clipToExtents) == false)
{
MapWinUtility.Logger.Dbg("Error running FillGrid\n");
return(false);
}
} //end of try block
catch (Exception e)
{
gErrorMsg = e.Message + e.ToString();
Debug.WriteLine(gErrorMsg);
Error.SetErrorMsg(gErrorMsg);
MapWinUtility.Logger.Dbg(gErrorMsg);
return(false);
}
//NOTE: The need for trimGrid has been removed from this function.
//It will always return the smallest possible grid because we
//build it based on the intersection boundary.
DataManagement.CopyGridLegend(inputGF, resultGF);
MapWinUtility.Logger.Dbg("Finished ClipGridWithPolygon");
return(true);
}
public IShip KillShip(IShip s, ICanFire killingObject)
{
if (s.IsDead)
{
ConsoleManager.WriteLine("Killing a ship which was already dead.", ConsoleMessageType.Warning);
return(s);
}
s.IsDead = true;
s.KillTimeStamp = TimeKeeper.MsSinceInitialization;
s.RespawnTimeDelay = 3000;//TODO: This will be a problem later, if a IShip warps into a new system where a dead IShip is waiting to respawn, the warping IShip will see a live ship. Needs to be fully implemented.
s.CurrentHealth = 0;
if (s.GetPlayer().IsTrading)
{
_tradeTerminator.TerminateTrade(s.Id, true);
}
var currentArea = s.GetArea();
if (currentArea.NumOnlinePlayers > 0)
{
MessageRemoveKillRevive msgData = new MessageRemoveKillRevive();
msgData.ActionType = ActionType.Kill;
msgData.ObjectType = RemovableObjectTypes.Ship;
msgData.ObjectIDs.Add(s.Id);
currentArea.BroadcastMessage(new NetworkMessageContainer(msgData, MessageTypes.RemoveKillRevive));
// Send chat messages
if (killingObject is IShip)
{
((IShip)killingObject).GetPlayer().PlayersKilled++;
var killingPlayer = ((IShip)killingObject).GetPlayer();
killingPlayer.PlayersKilled++;
var killText = string.Format("{0} was shot down by {1}!", s.GetPlayer().Username, killingPlayer.Username);
_chatManager.BroadcastSimpleChat(s.GetArea(), "", killText, ChatTypes.None);
}
else if (killingObject is Turret)
{
_playerLocator.GetPlayerAsync(((Turret)killingObject).OwnerID).Result.PlayersKilled++;
var killedPlayer = s.GetPlayer();
var defensesOwner = _playerLocator.GetPlayerAsync(((Turret)killingObject).OwnerID).Result.Username;
var killText = string.Format("{0} was shot down by defenses of {1}!", killedPlayer.Username, defensesOwner);
_chatManager.BroadcastSimpleChat(s.GetArea(), "", killText, ChatTypes.None);
}
}
#region Modules
//For now, just make the ship drop one mod to space. Later we'll figure out how many to destroy/keep with the ship
var moduleToRemove = s.Cargo.GetAnyStatefulCargo(StatefulCargoTypes.Module);
if (moduleToRemove != null)
{
var ct = new TransactionRemoveStatefulCargo(s, StatefulCargoTypes.Module, moduleToRemove.Id);
ct.OnCompletion += s.CargoRemoved;
ct.OnCompletion += _messageManager.NotifyCargoRemoved;
ct.OnCompletion += _addCargoToArea;
var mod = moduleToRemove as Module;
mod.PosX = s.PosX;
mod.PosY = s.PosY;
mod.Rotation = s.Rotation;
mod.NextAreaID = (int)s.CurrentAreaId;
_cargoSynchronizer.RequestTransaction(ct);
}
#endregion
s.CurrentHealth = s.ShipStats.MaxHealth;
//s.IsDead = false;
float tempx = 0;
float tempy = 0;
SpatialOperations.GetRandomPointInRadius(ref tempx, ref tempy, 10, 20);
s.PosX = tempx;
s.PosY = tempy;
return(s);
}
private void LoadSpatialOperations(SpatialOperations[] spatialOps)
{
btnSpatial.Visible = (spatialOps.Length > 0);
foreach (SpatialOperations op in spatialOps)
{
ToolStripMenuItem item = null;
switch (op)
{
case SpatialOperations.SpatialOperations_Contains:
{
item = new ToolStripMenuItem();
item.Text = item.Name = "Contains";
item.Tag = op;
item.Click += delegate(object sender, EventArgs e) { InsertText("<geometry property> CONTAINS GeomFromText('<geometry text>')"); };
}
break;
case SpatialOperations.SpatialOperations_CoveredBy:
{
item = new ToolStripMenuItem();
item.Text = item.Name = "Covered By";
item.Tag = op;
item.Click += delegate(object sender, EventArgs e) { InsertText("<geometry property> COVEREDBY GeomFromText('<geometry text>')"); };
}
break;
case SpatialOperations.SpatialOperations_Crosses:
{
item = new ToolStripMenuItem();
item.Text = item.Name = "Crosses";
item.Tag = op;
item.Click += delegate(object sender, EventArgs e) { InsertText("<geometry property> CROSSES GeomFromText('<geometry text>')"); };
}
break;
case SpatialOperations.SpatialOperations_Disjoint:
{
item = new ToolStripMenuItem();
item.Text = item.Name = "Disjoint";
item.Tag = op;
item.Click += delegate(object sender, EventArgs e) { InsertText("<geometry property> DISJOINT GeomFromText('<geometry text>')"); };
}
break;
case SpatialOperations.SpatialOperations_EnvelopeIntersects:
{
item = new ToolStripMenuItem();
item.Text = item.Name = "Envelope Intersects";
item.Tag = op;
item.Click += delegate(object sender, EventArgs e) { InsertText("<geometry property> INTERSECTS GeomFromText('<geometry text>')"); };
}
break;
case SpatialOperations.SpatialOperations_Equals:
{
item = new ToolStripMenuItem();
item.Text = item.Name = "Equals";
item.Tag = op;
item.Click += delegate(object sender, EventArgs e) { InsertText("<geometry property> EQUALS GeomFromText('<geometry text>')"); };
}
break;
case SpatialOperations.SpatialOperations_Inside:
{
item = new ToolStripMenuItem();
item.Text = item.Name = "Inside";
item.Tag = op;
item.Click += delegate(object sender, EventArgs e) { InsertText("<geometry property> INSIDE GeomFromText('<geometry text>')"); };
}
break;
case SpatialOperations.SpatialOperations_Intersects:
{
item = new ToolStripMenuItem();
item.Text = item.Name = "Intersects";
item.Tag = op;
item.Click += delegate(object sender, EventArgs e) { InsertText("<geometry property> INTERSECTS GeomFromText('<geometry text>')"); };
}
break;
case SpatialOperations.SpatialOperations_Overlaps:
{
item = new ToolStripMenuItem();
item.Text = item.Name = "Overlaps";
item.Tag = op;
item.Click += delegate(object sender, EventArgs e) { InsertText("<geometry property> OVERLAPS GeomFromText('<geometry text>')"); };
}
break;
case SpatialOperations.SpatialOperations_Touches:
{
item = new ToolStripMenuItem();
item.Text = item.Name = "Touches";
item.Tag = op;
item.Click += delegate(object sender, EventArgs e) { InsertText("<geometry property> TOUCHES GeomFromText('<geometry text>')"); };
}
break;
case SpatialOperations.SpatialOperations_Within:
{
item = new ToolStripMenuItem();
item.Text = item.Name = "Within";
item.Tag = op;
item.Click += delegate(object sender, EventArgs e) { InsertText("<geometry property> WITHIN GeomFromText('<geometry text>')"); };
}
break;
}
if (item != null)
btnSpatial.DropDown.Items.Add(item);
}
}
