// funkce 2.4
public static GP VypisGPDetail(int id, Database pDb = null)
{
Database db;
if (pDb == null)
{
db = new Database();
db.Connect();
}
else
{
db = (Database)pDb;
}
SqlCommand command = db.CreateCommand(SQL_SELECT_DETAIL);
command.Parameters.AddWithValue("@id", id);
SqlDataReader reader = db.Select(command);
GP GP = CteniGPDetail(reader);
reader.Close();
if (pDb == null)
{
db.Close();
}
return(GP);
}
public override void Run(RenderControl renderer)
{
var ellipse = SketchBuilder.MakeEllipse(GP.Origin(), 10, 5, GP.DX(), GP.DZ());
renderer.ShowShape(ellipse, Vector3.Blue);
ParametricCurve pc = new ParametricCurve(ellipse);
var paramsList = pc.SplitByUniformLength(1, 0.01);
uint itemCount = (uint)paramsList.Count;
var points = new ParticleSceneNode(itemCount, Vector3.Green, 5.0f);
var lines = new SegmentsSceneNode(itemCount, Vector3.Red, 2);
Random random = new Random();
for (int ii = 0; ii < paramsList.Count; ++ii)
{
var value = pc.D1(paramsList[ii]);
var pos = value.GetPoint();
var dir = value.GetVectors()[0];
var end = new GPnt(pos.XYZ().Added(dir.XYZ()));
lines.SetPositions((uint)ii, Vector3.From(pos), Vector3.From(end));
lines.SetColors((uint)ii, Vector3.Red, Vector3.From(random.NextDouble(), random.NextDouble(), random.NextDouble()));
points.SetPosition((uint)ii, Vector3.From(pos));
}
renderer.ShowSceneNode(points);
renderer.ShowSceneNode(lines);
}
public override void Run(RenderControl render)
{
var material = MeshStandardMaterial.Create("workpiece");
material.SetColor(new Vector3(0.9f));
material.SetFaceSide(EnumFaceSide.DoubleSide);
var shape = ShapeBuilder.MakeCylinder(GP.YOZ(), 5, 50, 0);
mWorkpiece = BrepSceneNode.Create(shape, material, null);
render.ShowSceneNode(mWorkpiece);
var coord = new GAx2(new GPnt(0, 0, 5), GP.DZ());
var toolShape = ShapeBuilder.MakeCone(coord, 0, 2, 5, 0);
var toolNode = render.ShowShape(toolShape, ColorTable.Blue);
render.ShowSceneNode(mMotionTrail);
// Initialize Animation
mAnimation = new RigidAnimation();
var rotation = Matrix4.makeRotationAxis(new Vector3(1, 0, 0), (float)Math.PI);
var trf = Matrix4.makeTranslation(-50, 0, 0) * rotation;
mAnimation.Add(new MatrixAnimationClip(mWorkpiece, mWorkpiece.GetTransform(), trf, 0, 10));
mAnimation.Add(new MatrixAnimationClip(toolNode, toolNode.GetTransform(), trf, 10, 15));
mAnimation.Add(new RotateAnimationClip(toolNode, Vector3.UNIT_Z, (float)Math.PI * 4, 16, 20));
}
public override Shape drawShape(Graphics g)
{
Point[] po =
{
new Point(x, y),
new Point(300 + x, y),
new Point(300 + x, 100 + y),
new Point(200 + x, 100 + y),
new Point(200 + x, 150 + y),
new Point(100 + x, 150 + y), // start
new Point(100 + x, 100 + y), // end
new Point(x, 100 + y),
new Point(x, y)
};
lineStart = new Point(100 + x, 150 + y);
lineEnd = new Point(100 + x, 100 + y);
xlineStart = 100 + x;
ylineStart = 150 + y;
xlineEnd = 100 + x;
ylineEnd = 100 + y;
GP.Reset();
GP.AddPolygon(po);
g.DrawPath(new Pen(myColor, 5), GP);
return(this);
}
public override void Run(RenderControl render)
{
// 1. Make face with a hole.
var c1 = SketchBuilder.MakeCircle(GP.Origin(), 30, GP.DZ());
var c2 = SketchBuilder.MakeCircle(GP.Origin(), 100, GP.DZ());
var face = SketchBuilder.MakePlanarFace(c2);
var face2 = SketchBuilder.MakePlanarFace(c1);
var shape = BooleanTool.Cut(face, face2);
//render.ShowShape(shape, ColorTable.Blue);
var faces = shape.GetChildren(EnumTopoShapeType.Topo_FACE);
// 2. Hatch the face.
foreach (var item in faces)
{
HatchHatcher hh = new HatchHatcher(item);
hh.Build();
var material = BasicMaterial.Create("line");
material.SetColor(new Vector3(0.5f, 0.5f, 1.0f));
var node = hh.Create(material);
// 3. Show the hatching lines.
render.ShowSceneNode(node);
}
}
public override void Run(RenderControl render)
{
RedMaterial = MeshPhongMaterial.Create("phong.color");
RedMaterial.SetColor(Vector3.Red);
GrayMaterial = MeshPhongMaterial.Create("phong.color");
GrayMaterial.SetColor(Vector3.LightGray);
GrayMaterial.SetTransparent(true);
GrayMaterial.SetOpacity(0.5f);
var tube = ShapeBuilder.MakeTube(new GPnt(0, 0, 5), GP.DZ(), 10, 2, 50);
TubeNode = BrepSceneNode.Create(tube, RedMaterial, null);
var cylinder = ShapeBuilder.MakeCylinder(GP.XOY(), 10, 60, 0);
CylinderNode = BrepSceneNode.Create(cylinder, GrayMaterial, null);
render.ShowSceneNode(TubeNode);
render.ShowSceneNode(CylinderNode);
var cone = ShapeBuilder.MakeCone(GP.YOZ(), 5, 0, 10, 0);
var bs = new BufferShape(cone, RedMaterial, null, 0.1);
bs.Build();
ConeNode1 = new BrepSceneNode(bs);
ConeNode2 = new BrepSceneNode(bs);
render.ShowSceneNode(ConeNode1);
render.ShowSceneNode(ConeNode2);
}
private bool PAUSE()
{
PauseOn = true;
Pause = new PauseScreen();
if (Pause.TriState == 0 || Pause.TriState == 1)
{
if (Pause.TriState == 0)
{
Saving.SaveGame();
}
Quit = true;
return(true);
}
Console.Clear();
Refresh();
GP.DrawGamePanelInvoker();
Draw.Few($"[{(++Score).ToString()}]", 35, 9);
DrawNextShape();
Console.CursorVisible = false;
PauseOn = false;
return(false);
}
public static int UpravaGPUzivatel(GP GP, Database pDb = null)
{
Database db;
if (pDb == null)
{
db = new Database();
db.Connect();
}
else
{
db = (Database)pDb;
}
SqlCommand command = db.CreateCommand(SQL_UPDATE_UZIVATEL);
command.Parameters.AddWithValue("@nazev", GP.Nazev);
command.Parameters.AddWithValue("@datum", GP.Datum);
command.Parameters.AddWithValue("@delka", GP.Delka_okruhu);
command.Parameters.AddWithValue("@pocet", GP.Pocet_kol);
command.Parameters.AddWithValue("@stat", GP.Staty_ID);
command.Parameters.AddWithValue("@id", GP.Uzivatel_ID);
int ret = db.ExecuteNonQuery(command);
if (pDb == null)
{
db.Close();
}
return(ret);
}
GroupSceneNode CreateFrames(double width, double height, double deep, double radius)
{
var baseSketch = CreateSketch(radius, deep);
//TopLeft
var s11 = Project(baseSketch, new GPnt(0, 0, height), new GDir(-1, 0, -1), GP.DZ());
//BottomLeft
var s20 = Project(baseSketch, GP.Origin(), new GDir(-1, 0, 1), GP.DZ());
//BottomRight
var s12 = Project(s20, new GPnt(width, 0, 0), new GDir(1, 0, 1), GP.DX());
//TopRight
var s21 = Project(s11, new GPnt(width, 0, height), new GDir(-1, 0, 1), GP.DX());
var frame1 = FeatureTool.Loft(s11, s20, false);
var frame2 = FeatureTool.Loft(s20, s12, false);
var frame3 = FeatureTool.Loft(s12, s21, false);
var frame4 = FeatureTool.Loft(s21, s11, false);
var frameMaterial = MeshStandardMaterial.Create("window-frame");
frameMaterial.SetColor(Vector3.LightGray);
frameMaterial.SetMetalness(0.5f);
frameMaterial.SetFaceSide(EnumFaceSide.DoubleSide);
var group = new GroupSceneNode();
group.AddNode(BrepSceneNode.Create(frame1, frameMaterial, null));
group.AddNode(BrepSceneNode.Create(frame2, frameMaterial, null));
group.AddNode(BrepSceneNode.Create(frame3, frameMaterial, null));
group.AddNode(BrepSceneNode.Create(frame4, frameMaterial, null));
return(group);
}
static void Funkce2(Database db)
{
db.BeginTransaction();
Console.WriteLine("");
Console.WriteLine("Funkce 2 --------------------------");
Console.WriteLine("");
// funkce 2.1 je zakomponovaná ve funkci 1.1
Console.WriteLine("Vypis vsech GP (funkce 2.4):");
Collection <GP> GP = EvidenceGP.VypisGP(db); // funkce 2.4
foreach (GP Polozka in GP)
{
Console.WriteLine(Polozka.ID + "\t" + Polozka.Nazev + "\t" + Polozka.Datum);
}
// funkce 2.3 zakomponovaná ve funkci 1.3
Console.WriteLine("");
Console.WriteLine("Vypis detailu GP (funkce 2.5):");
GP Vypis = EvidenceGP.VypisGPDetail(5, db); // funkce 2.5
Console.WriteLine();
Console.WriteLine(Vypis.ID + "\t" + Vypis.Nazev + "\t" + Vypis.Datum + "\t" + Vypis.Delka_okruhu + "\t" + Vypis.Pocet_kol + "\t" + Vypis.Staty_ID);
EvidenceGP.UpravaGP(Vypis, db); // funkce 2.2
db.EndTransaction();
}
double Orient3D_Checked(double[] pa, double[] pb, double[] pc, double[] pd)
{
// Call Orient3D in all the possible ways, and check that the results agree
var P1 = GP.Orient3D(pa, pb, pc, pd);
var P2 = GP.Orient3D(pb, pc, pa, pd);
var P3 = GP.Orient3D(pc, pa, pb, pd);
var p1 = GP.Orient3D(pa, pc, pb, pd);
var p2 = GP.Orient3D(pc, pb, pa, pd);
var p3 = GP.Orient3D(pb, pa, pc, pd);
var p1X = GP.Orient3DExact(pa, pb, pc, pd);
var p2X = GP.Orient3DExact(pb, pc, pa, pd);
var p3X = GP.Orient3DExact(pc, pa, pb, pd);
var p1R = GP.Orient3DExact(pa, pc, pb, pd);
var p2R = GP.Orient3DExact(pc, pb, pa, pd);
var p3R = GP.Orient3DExact(pb, pa, pc, pd);
var p1s = GP.Orient3DSlow(pa, pb, pc, pd);
var p2s = GP.Orient3DSlow(pb, pc, pa, pd);
var p3s = GP.Orient3DSlow(pc, pa, pb, pd);
var p1r = GP.Orient3DSlow(pa, pc, pb, pd);
var p2r = GP.Orient3DSlow(pc, pb, pa, pd);
var p3r = GP.Orient3DSlow(pb, pa, pc, pd);
AssertEqual(p1X, p2X, p3X, -p1R, -p2R, -p3R, p1s, p2s, p3s, -p1r, -p2r, -p3r);
// AssertClose(p1X, P2, P3, -p1, -p2, -p3);
AssertSameSign(p1X, P1, P2, P3, -p1, -p2, -p3);
// TODO: Add a check that shows adaptive is 'close' to exact.
return(P1);
}
public IHttpActionResult SaveGps(string Latitude, string Longitude)
{
try
{
using (kernels1_itiEntities DB = new kernels1_itiEntities())
{
DATA.GP gps = new GP();
gps.lat = Latitude;
gps.longitude = Longitude;
gps.updatedDate = DateTime.UtcNow;
gps.deviceid = "1";
DB.GPS.Add(gps);
DB.SaveChanges();
}
var response = new
{
Success = true,
Message = "GPS Coorinates saved Successfully",
};
return(Ok(response));
}
catch (Exception)
{
return(Content(HttpStatusCode.BadRequest, "Error Found"));
}
}
public override void Run(RenderControl render)
{
var arc = SketchBuilder.MakeArcOfCircle(new GCirc(GP.XOY(), 10), 0, Math.PI);
var points = new GPntList
{
new GPnt(0, 0, 0),
new GPnt(2, 5, 0),
new GPnt(15, 15, 0)
};
var line = SketchBuilder.MakeBSpline(points);
var extrema = new ExtremaCurveCurve();
extrema.Initialize(arc, line);
int count = extrema.GetPointCount();
for (int ii = 0; ii < count; ++ii)
{
var point = extrema.GetPoint1(ii);
var node = new PrimitiveSceneNode(GeometryBuilder.AtomSphere(), EnumPrimitiveType.TRIANGLES, null);
node.SetTransform(Matrix4.makeTranslation(Vector3.From(point)));
render.ShowSceneNode(node);
}
render.ShowShape(arc, Vector3.Red);
render.ShowShape(line, Vector3.Green);
}
public override void Run(RenderControl render)
{
var paramCurve = Sketch2dBuilder.MakeLine(new GPnt2d(0, 0), new GPnt2d(Math.PI * 20, 20));
// curve one cone
{
var cone = ShapeBuilder.MakeCone(GP.XOY(), 1, 10, 20, 0);
var coneFace = cone.FindChild(EnumTopoShapeType.Topo_FACE, 0);
var curveOnConeSurface = SketchBuilder.MakeCurveOnSurface(paramCurve, coneFace);
var material = LineDashedMaterial.Create("my.dashed.material");
material.SetColor(ColorTable.Hex(0x0FFAA));
var node = BrepSceneNode.Create(curveOnConeSurface, null, material);
node.ComputeLineDistances(); // Enable dashed line style.
render.ShowSceneNode(node);
}
// curve one cylinder
{
var cylinder = ShapeBuilder.MakeCylinder(GP.XOY(), 2, 20, 0);
var cylinderFace = cylinder.FindChild(EnumTopoShapeType.Topo_FACE, 0);
var curveOnCylinderSurface = SketchBuilder.MakeCurveOnSurface(paramCurve, cylinderFace);
var node2 = BrepSceneNode.Create(curveOnCylinderSurface, null, null);
render.ShowSceneNode(node2);
}
}
public override void Run(RenderControl render)
{
var sketch = SketchBuilder.MakeEllipse(GP.Origin(), 5, 3, GP.DX(), GP.DZ());
// 1. Sweep
{
GPntList points = new GPntList {
GP.Origin(), new GPnt(20, 10, 30), new GPnt(50, 50, 50),
};
var path = SketchBuilder.MakeBSpline(points);
render.ShowShape(path, Vector3.Green);
var feature = FeatureTool.Sweep(sketch, path, EnumGeomFillTrihedron.ConstantNormal);
render.ShowShape(feature, Vector3.Blue);
}
// 2. Revol
{
var feature = FeatureTool.Revol(sketch, new GAx1(new GPnt(-20, 0, 0), GP.DY()), 90);
render.ShowShape(feature, Vector3.Green);
}
// 3. Loft
{
var baseWire = SketchBuilder.MakeRectangle(new GAx2(new GPnt(50, -50, 0), GP.DZ()), 20, 20, 5, false);
var topWire = SketchBuilder.MakeCircle(new GPnt(60, -40, 40), 5, GP.DZ());
var loft = FeatureTool.Loft(baseWire, topWire, true);
render.ShowShape(loft, Vector3.Red);
}
}
public void InitializeGPandGrammar(Grammar grm)
{
this.grm = grm;
gp = new GP();
gp.createPopulation(POPSIZE, GENOME_SIZE);
gp.minimizeFitness = grm.minimizeFitness;
}
public override void Run(RenderControl renderer)
{
string fileName = GetResourcePath("Holes.stp");
var shape = StepIO.Open(fileName);
if (shape == null)
{
return;
}
renderer.ShowShape(shape, Vector3.LightGray);
var bbox = shape.GetBBox();
var shape2 = ShapeBuilder.MakeBox(new GAx2(bbox.CornerMax(), GP.DZ()), 100, 100, 10);
renderer.ShowShape(shape2, Vector3.LightGray);
ExtremaShapeShape ess = new ExtremaShapeShape();
if (!ess.Initialize(shape, shape2, 0.001))
{
return;
}
var pt1 = ess.GetPointOnShape1(0);
var pt2 = ess.GetPointOnShape2(0);
var line = SketchBuilder.MakeLine(pt1, pt2);
renderer.ShowShape(line, Vector3.Red);
}
public override void Run(RenderControl render)
{
var material = MeshStandardMaterial.Create("workpiece");
material.SetColor(new Vector3(0.9f));
material.SetFaceSide(EnumFaceSide.DoubleSide);
var shape = ShapeBuilder.MakeCylinder(GP.YOZ(), 5, 50, 0);
mWorkpiece = BrepSceneNode.Create(shape, material, null);
render.ShowSceneNode(mWorkpiece);
{
var coord = new GAx2(new GPnt(0, 0, 5), GP.DZ());
var toolShape = ShapeBuilder.MakeCone(coord, 0, 2, 5, 0);
render.ShowShape(toolShape, Vector3.Blue);
}
render.ShowSceneNode(mMotionTrail);
mLength = 0;
mTheta = 0;
}
private void DoWork()
{
GP.ExecuteSecure(() => Work(Cts.Token, (a) => Invoke(a), new Progress <ProgressMessage>(ProgressHandler)));
Action update = Close;
this.Invoke(update);
}
public async Task Create()
{
var bytes = await File.ReadAllBytesAsync("../../../test.gp3");
var gpfile = GP.Create("test.gp3", bytes);
Assert.NotNull(gpfile);
}
public static void InsertGP(GP gp)
{
using (var context = new MyDBEntities())
{
context.GPs.Add(gp);
context.SaveChanges();
}
}
public override bool OnParameterChanged(Element instance, ParameterDict parameters)
{
var shape = CastShapeElement(instance);
var radius = parameters.AsDouble("Radius", 5.0f);
shape.SetShape(ShapeBuilder.MakeSphere(GP.Origin(), radius));
return(true);
}
public void btn_submit_Clicked()
{
// NEED TO DO VERIFICATION ON FORM. TRY CATCH ON REQUIRED EMPTY VARIABLES?
if (string.IsNullOrEmpty(view.getMiddleName()))
{
personBuilder
.WithNoMiddleName((Prefix)Enum.Parse(typeof(Prefix), view.getTitle()), view.getFirstName(), view.getLastName());
if (string.IsNullOrEmpty(view.getEmergency()))
{
personBuilder
.WithPrimaryContactOnly(view.getPhone());
if (string.IsNullOrEmpty(view.getSecondLine()) && string.IsNullOrEmpty(view.getThirdLine()))
{
addressBuilder
.OneLineAddress(view.getFirstLine(), view.getCity(), view.getCounty(), view.getPostcode());
}
else if (string.IsNullOrEmpty(view.getThirdLine()))
{
addressBuilder
.TwoLineAddress(view.getFirstLine(), view.getSecondLine(), view.getCity(), view.getCounty(), view.getPostcode());
}
else
{
addressBuilder
.ThreeLineAddress(view.getFirstLine(), view.getSecondLine(), view.getThirdLine(), view.getCity(), view.getCounty(), view.getPostcode());
}
}
else
{
personBuilder
.WithAllContacts(view.getPhone(), view.getEmergency());
}
}
else
{
personBuilder
.WithMiddleName((Prefix)Enum.Parse(typeof(Prefix), view.getTitle()), view.getFirstName(), view.getMiddleName(), view.getLastName());
}
gp = personBuilder.Build();
address = addressBuilder.Build();
GP practice = new GP();
practice.GPPractice = view.getPracticeName();
MemberDB.InsertGP(gp);
AddressDB.InsertAddress(address);
GPDB.InsertGP(practice);
ConfirmationForm cForm = new ConfirmationForm();
ConfirmationPresenter cPresenter = new ConfirmationPresenter(cForm);
cForm.Show();
}
public async Task CreateMidi()
{
var bytes = await File.ReadAllBytesAsync("../../../test.gp3");
var gpfile = GP.Create("test.gp3", bytes);
var song = new NativeFormat(gpfile);
var midi = song.toMidi();
Assert.NotNull(midi);
}
/// <summary>
/// Returns the hash code of this field
/// </summary>
///
/// <returns>The hash code</returns>
public override int GetHashCode()
{
int hash = N * 31;
hash += K * 31;
hash += GF.GetHashCode();
hash += GP.GetHashCode();
hash += P1.GetHashCode();
return(hash);
}
public PR(EP ep, GP gp)
{
if (ep.Value == 0)
{
Value = 0;
}
else
{
Value = ep.Value / gp.Value;
}
}
public override void Run(RenderControl render)
{
var rect1 = SketchBuilder.MakeRectangle(GP.XOY(), 10, 5, 1, true);
var rect2 = SketchBuilder.MakeRectangle(new GAx2(new GPnt(1, 1, 0), GP.DZ(), GP.DX()), 8, 3, 1, true);
var cut = BooleanTool.Cut(rect1, rect2);
var extrude = FeatureTool.Extrude(cut, 100, GP.DZ());
render.ShowShape(extrude, Vector3.Blue);
}
private static void LoadJsonData(IProgress <ProgressMessage> progress = null)
{
progress?.Report(new ProgressMessage(0, "Processing Boss data"));
var exePath = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
var rawDataJson = GP.ReadJsonFile(exePath + @"\Data\DataConfig.json");
progress?.Report(new ProgressMessage(0.5, "Processing Boss data"));
Helper.DataBuilder.LoadDataJson(rawDataJson);
Profession.Init(exePath + @"\Data\ProfessionData.json",
new Progress <double>(p => progress?.Report(new ProgressMessage((p * 0.5) + 0.5, "Processing Class data"))));
}
public override void Run(RenderControl renderer)
{
string fileName = GetResourcePath("Holes.stp");
var shape = StepIO.Open(fileName);
if (shape == null)
{
return;
}
var face = shape.FindChild(EnumTopoShapeType.Topo_FACE, 148);
var surface = new ParametricSurface(face);
var wireExp = new WireExplor(face);
var wires = wireExp.GetInnerWires();
foreach (var wire in wires)
{
// Show wire
renderer.ShowShape(wire, Vector3.Red);
var curve = new ParametricCurve(wire);
var paramList = curve.SplitByUniformLength(1, 0.01);
var lines = new SegmentsSceneNode((uint)paramList.Count, Vector3.Green, 2);
uint idx = 0;
foreach (var p in paramList)
{
var pt = curve.Value(p);
var pointSur = new ExtremaPointSurface();
if (pointSur.Initialize(surface, pt, GP.Resolution(), GP.Resolution()))
{
var uv = pointSur.GetParameter(0);
var normal = surface.GetNormal(uv.X(), uv.Y());
lines.SetPositions(idx++, Vector3.From(pt), Vector3.From(pt.XYZ().Added(normal.XYZ())));
}
}
lines.UpdateBoundingBox();
renderer.ShowSceneNode(lines);
}
// Show face
var faceMaterial = MeshStandardMaterial.Create("pbr.face");
faceMaterial.SetColor(Vector3.LightGray);
faceMaterial.SetFaceSide(EnumFaceSide.DoubleSide);
var faceNode = BrepSceneNode.Create(face, faceMaterial, null);
faceNode.SetDisplayFilter(EnumShapeFilter.Face);
renderer.ShowSceneNode(faceNode);
}
public void InstantHideTrail()
{
foreach (GroundPiece GP in tailGroundPieces)
{
if (GP.collectingSnake == this)
{
GP.tailPiece.FadeImmediate();
}
GP.RemoveCollectingSnake(this);
}
tailGroundPieces.Clear();
}
public void LoadConfiguration(GP.MetaData.GPMetaData serviceInfo, Uri taskEndPoint)
{
if (serviceInfo == null)
return;
TaskEndPoint = taskEndPoint;
TaskName = Title = serviceInfo.DisplayName;
HelpUrl = serviceInfo.HelpUrl;
if (InputParameters == null)
InputParameters = new List<ParameterSupport.ParameterConfig>();
else
InputParameters.Clear();
if (OutputParameters == null)
OutputParameters = new List<ParameterSupport.ParameterConfig>();
else
OutputParameters.Clear();
if (LayerOrder == null)
LayerOrder = new ObservableCollection<string>();
else
LayerOrder.Clear();
Collection<LayerInformation> resultMapserviceLayerInfos = string.IsNullOrEmpty(serviceInfo.ResultMapServerName) || string.IsNullOrEmpty(serviceInfo.CurrentVersion) ? null : new Collection<LayerInformation>();
#region Get parameter configs
if (serviceInfo.Parameters != null)
{
int layerId = 0;
foreach (ESRI.ArcGIS.Mapping.GP.MetaData.GPParameter param in serviceInfo.Parameters)
{
ParameterConfig config = null;
if (param.DataType == "GPFeatureRecordSetLayer")
{
if (!string.IsNullOrEmpty(serviceInfo.ResultMapServerName) && param.Direction != "esriGPParameterDirectionInput")
{
if (!string.IsNullOrEmpty(serviceInfo.CurrentVersion)) // A resultmapservice can only be accessed at http://.../<resultMapservice>/MapServer/jobs/<jobId> when server version can be determined.
resultMapserviceLayerInfos.Add(ToLayerInfo(param, layerId++));
else
{
MapServiceLayerParameterConfig layerConfig = new MapServiceLayerParameterConfig
{
Name = param.Name,
LayerName = param.DisplayName,
Type = GPParameterType.MapServiceLayer,
SupportsJobResource = false,
Opacity = 1,
};
OutputParameters.Add(layerConfig);
LayerOrder.Add(layerConfig.Name);
}
}
else
{
#region No result GP mapserver
GP.ParameterSupport.FeatureLayerParameterConfig layerConfig = new ParameterSupport.FeatureLayerParameterConfig() { ShownAtRunTime = true };
layerConfig.Name = param.Name;
layerConfig.Label = layerConfig.DisplayName = string.IsNullOrEmpty(param.DisplayName) ? param.Name : param.DisplayName;
layerConfig.Mode = ParameterSupport.FeatureLayerParameterConfig.InputMode.SketchLayer;
layerConfig.Type = GPParameterType.FeatureLayer;
layerConfig.Required = param.ParameterType == "esriGPParameterTypeRequired";
ESRI.ArcGIS.Mapping.GP.MetaData.GPFeatureRecordSetLayer frs = param.DefaultValue as ESRI.ArcGIS.Mapping.GP.MetaData.GPFeatureRecordSetLayer;
if (frs != null)
{
if (frs.GeometryType == "esriGeometryPolyline")
{
layerConfig.GeometryType = ESRI.ArcGIS.Mapping.Core.GeometryType.Polyline;
layerConfig.HelpText = Resources.Strings.DrawLine;
}
else if (frs.GeometryType == "esriGeometryPolygon")
{
layerConfig.GeometryType = ESRI.ArcGIS.Mapping.Core.GeometryType.Polygon;
layerConfig.HelpText = Resources.Strings.DrawPolygon;
}
else if (frs.GeometryType == "esriGeometryPoint")
{
layerConfig.GeometryType = ESRI.ArcGIS.Mapping.Core.GeometryType.Point;
layerConfig.HelpText = Resources.Strings.DrawPoint;
}
else if (frs.GeometryType == "esriGeometryMultipoint")
{
layerConfig.GeometryType = ESRI.ArcGIS.Mapping.Core.GeometryType.MultiPoint;
layerConfig.HelpText = Resources.Strings.DrawPoint;
}
#region Layer with field info, geometry type and renderer
GraphicsLayer layer = new GraphicsLayer();
if (frs.Fields != null && frs.Fields.Length > 0)
{
Collection<ESRI.ArcGIS.Mapping.Core.FieldInfo> fields = new Collection<ESRI.ArcGIS.Mapping.Core.FieldInfo>();
List<string> doubleFields = new List<string>();
List<string> singleFields = new List<string>();
foreach (MetaData.Field field in frs.Fields)
{
#region Get Single and Double Fields
string type = field.Type;
if (type.StartsWith(GPConfiguration.esriFieldType, StringComparison.Ordinal))
{
type = type.Substring(GPConfiguration.esriFieldType.Length);
ESRI.ArcGIS.Client.Field.FieldType fieldType =
(ESRI.ArcGIS.Client.Field.FieldType)Enum.Parse(typeof(ESRI.ArcGIS.Client.Field.FieldType), type, true);
if (fieldType == ESRI.ArcGIS.Client.Field.FieldType.Double)
doubleFields.Add(field.Name);
else if (fieldType == Client.Field.FieldType.Single)
singleFields.Add(field.Name);
}
#endregion
#region Get FieldInfos
if (field.Type == "esriGeometry")
continue;
fields.Add(new ESRI.ArcGIS.Mapping.Core.FieldInfo()
{
DisplayName = field.Alias,
FieldType = mapFieldType(field.Type),
Name = field.Name,
VisibleInAttributeDisplay = true,
VisibleOnMapTip = true,
});
#endregion
}
ESRI.ArcGIS.Mapping.Core.LayerExtensions.SetFields(layer, fields);
layerConfig.SingleFields = singleFields.ToArray();
layerConfig.DoubleFields = doubleFields.ToArray();
}
ESRI.ArcGIS.Mapping.Core.LayerExtensions.SetGeometryType(layer, layerConfig.GeometryType);
layer.Renderer = FeatureLayerParameterConfig.GetSimpleRenderer(layerConfig.GeometryType);
// Disable pop-ups by default for input layers
if (param.Direction == "esriGPParameterDirectionInput")
LayerProperties.SetIsPopupEnabled(layer, false);
layerConfig.Layer = layer;
#endregion
}
else
{
layerConfig.GeometryType = ESRI.ArcGIS.Mapping.Core.GeometryType.Unknown;
layerConfig.HelpText = Resources.Strings.UnknownGeometryType;
}
layerConfig.LayerName = layerConfig.Label;
layerConfig.ToolTip = layerConfig.HelpText;
layerConfig.Opacity = 1;
config = layerConfig;
LayerOrder.Add(layerConfig.Name);
#endregion
}
}
else if (param.DataType == "GPRasterDataLayer" || param.DataType == "GPRasterData")
{
if (string.IsNullOrEmpty(serviceInfo.ResultMapServerName) || param.Direction == "esriGPParameterDirectionInput")
{
config = new RasterDataParameterConfig()
{
Name = param.Name,
ShownAtRunTime = true,
FormatToolTip = "e.g. tif, jpg",
Type = param.DataType == "GPRasterDataLayer" ? GPParameterType.RasterDataLayer : GPParameterType.RasterData,
ToolTip = param.DataType == "GPRasterDataLayer" ? Resources.Strings.EnterUrlForRasterDataLayer : Resources.Strings.EnterUrlForRasterData,
HelpText = param.DataType == "GPRasterDataLayer" ? Resources.Strings.EnterUrlForRasterDataLayer : Resources.Strings.EnterUrlForRasterData,
Label = param.DisplayName,
DisplayName = param.DisplayName,
Required = param.ParameterType == "esriGPParameterTypeRequired",
Input = param.Direction == "esriGPParameterDirectionInput"
};
}
else if (string.IsNullOrEmpty(serviceInfo.CurrentVersion))
{
MapServiceLayerParameterConfig layerConfig = new MapServiceLayerParameterConfig
{
Name = param.Name,
LayerName = param.DisplayName,
Type = GPParameterType.MapServiceLayer,
SupportsJobResource = false,
Opacity = 1,
};
OutputParameters.Add(layerConfig);
LayerOrder.Add(layerConfig.Name);
}
else
resultMapserviceLayerInfos.Add(ToLayerInfo(param, layerId++));
}
else
{
#region other param types
if (param.DataType == "GPMultiValue:GPString")
config = new MultiValueStringConfig() { ShownAtRunTime = true };
else
config = new ParameterConfig() { ShownAtRunTime = true };
config.Name = param.Name;
config.Label = config.DisplayName = param.DisplayName;
config.Required = param.ParameterType == "esriGPParameterTypeRequired";
string defaultString = param.DefaultValue == null ? null : param.DefaultValue.ToString();
switch (param.DataType)
{
#region
case "GPBoolean":
config.Type = GPParameterType.Boolean;
if (param.DefaultValue != null)
config.DefaultValue = new Client.Tasks.GPBoolean(param.Name, (bool)param.DefaultValue);
break;
case "GPDouble":
config.Type = GPParameterType.Double;
if (!string.IsNullOrEmpty(defaultString))
{
double val = 0;
if (double.TryParse(defaultString, System.Globalization.NumberStyles.Any, CultureHelper.GetCurrentCulture(), out val))
config.DefaultValue = new Client.Tasks.GPDouble(param.Name, val);
}
break;
case "GPLong":
config.Type = GPParameterType.Long;
if (!string.IsNullOrEmpty(defaultString))
{
int val = 0;
if (int.TryParse(defaultString, out val))
config.DefaultValue = new ESRI.ArcGIS.Client.Tasks.GPLong(param.Name, val);
}
break;
case "GPDate":
config.Type = GPParameterType.Date;
if (!string.IsNullOrEmpty(defaultString))
{
long ticks = 0;
if (long.TryParse(defaultString, out ticks))
config.DefaultValue = new ESRI.ArcGIS.Client.Tasks.GPDate(param.Name, Epoch.AddMilliseconds(ticks));
}
break;
case "GPLinearUnit":
config.Type = GPParameterType.LinearUnit;
if (param.DefaultValue is ESRI.ArcGIS.Mapping.GP.MetaData.GPLinearUnit)
{
ESRI.ArcGIS.Mapping.GP.MetaData.GPLinearUnit value = (param.DefaultValue as ESRI.ArcGIS.Mapping.GP.MetaData.GPLinearUnit);
config.DefaultValue = new ESRI.ArcGIS.Client.Tasks.GPLinearUnit(param.Name,
(ESRI.ArcGIS.Client.Tasks.esriUnits)(Enum.Parse(typeof(ESRI.ArcGIS.Client.Tasks.esriUnits), value.Units, true)),
value.Distance);
}
break;
case "GPString":
config.Type = GPParameterType.String;
config.DefaultValue = new ESRI.ArcGIS.Client.Tasks.GPString(param.Name, defaultString);
if (param.ChoiceList != null && param.ChoiceList.Length > 0)
{
config.ChoiceList = new List<Choice>(param.ChoiceList.Length);
for (int i = 0; i < param.ChoiceList.Length; i++)
{
config.ChoiceList.Add(new Choice()
{
DisplayText = param.ChoiceList[i],
Value =
new ESRI.ArcGIS.Client.Tasks.GPString(param.Name, param.ChoiceList[i])
});
}
}
break;
case "GPMultiValue:GPString":
config.Type = GPParameterType.MultiValueString;
object[] defaultStrings = param.DefaultValue as object[];
// the default value could be an array of strings
if (defaultStrings != null && defaultStrings.Length > 0)
{
List<GPString> list =
(from string s in defaultStrings select new GPString(param.Name, s)).ToList();
config.DefaultValue = new GPMultiValue<GPString>(param.Name, list);
}
if (param.ChoiceList != null && param.ChoiceList.Length > 0)
{
config.ChoiceList = new List<Choice>(param.ChoiceList.Length);
foreach (string t in param.ChoiceList)
{
config.ChoiceList.Add(new Choice
{
DisplayText = t,
Value = new GPString(param.Name, t)
});
}
}
break;
case "GPRecordSet":
config.Type = GPParameterType.RecordSet;
config.ToolTip = config.HelpText = Resources.Strings.EnterUrlForRecordset;
break;
case "GPDataFile":
config.Type = GPParameterType.DataFile;
config.ToolTip = config.HelpText = Resources.Strings.EnterUrlForFile;
break;
default:
break;
#endregion
}
#endregion
}
if (config != null)
{
if (param.Direction == "esriGPParameterDirectionInput")
{
config.Input = true;
InputParameters.Add(config);
}
else
{
config.Input = false;
OutputParameters.Add(config);
}
}
}
}
if (!string.IsNullOrEmpty(serviceInfo.ResultMapServerName) && !string.IsNullOrEmpty(serviceInfo.CurrentVersion))
{
MapServiceLayerParameterConfig layerConfig = new MapServiceLayerParameterConfig
{
Name = serviceInfo.ResultMapServerName,
LayerName = serviceInfo.ResultMapServerName,
Type = GPParameterType.MapServiceLayer,
LayerInfos = resultMapserviceLayerInfos,
SupportsJobResource = true,
Opacity = 1,
};
OutputParameters.Add(layerConfig);
LayerOrder.Add(layerConfig.Name);
}
#endregion
}
public bool CanPlaceFeature(GP[,] feature, ref GP[,] map, int hPos, int vPos)
{
for (var h = hPos; h < hPos + feature.GetLength(0); ++h)
{
for (var v = vPos; v < vPos + feature.GetLength(1); ++v)
{
if(map[h,v] != GP.I)
return false;
}
}
return true;
}
public void CreateGameBoard(GP[,] pieceArray)
{
var board = GameManager.Instance.Board;
var width = pieceArray.GetLength(0);
var height = pieceArray.GetLength(1);
board.CreateBoard(width, height);
for (var h = 0; h < width; ++h)
{
for (var v = 0; v < height; ++v)
{
// create the piece
var piece = GameObject.Instantiate(PrefabFromGP(pieceArray[h,v]));
// always add a floor piece even if piece isn't a floor piece.
var isFloor = piece.IsFloorPiece;
if (!isFloor)
{
var floorFirst = GameObject.Instantiate(FloorPiecePrefab);
board.SetPiece(h, v, floorFirst);
}
// tell the game NonFloorPieces
board.SetPiece(h, v, piece);
}
}
}
public static final short IMAGE_REL_MIPS_GPREL 16-bit signed displacement of the target relative to the Global Pointer (GP) register.
public GP[,] GenerateMap()
{
GP[,] generatedMap = new GP[7*20, 7*20];
// mark every area as unset
for(var i = 0; i < generatedMap.GetLength(0); ++i)
for(var j = 0; j < generatedMap.GetLength(1); ++j)
generatedMap[i,j] = GP.I;
// place the white house randomly (special one time only chunk)
var presidentPlaced = false;
while(!presidentPlaced)
{
presidentPlaced = TryToPlaceFeatureRandomly(whiteHouse, ref generatedMap);
}
// Try to add some other features! The map is 140x140, keep in mind feature size and the fact that some will fail
var features = new GP[][,] { survivorSmallHouse /* 7 */, bigHouse /* 14 */, emptyStreetWithDebrisOrTrees /* 7 */ };
var maxToPlace = new int[]{ 30, 20, 40 };
for (var i = 0; i < features.Length; ++i)
{
var addedCount = 0;
for (var tries = 0; tries < maxToPlace[i]; ++tries)
{
addedCount += TryToPlaceFeatureRandomly(features[i], ref generatedMap) ? 1 : 0;
}
Debug.Log(string.Format("Feature {2}: added {0}/{1}", addedCount, maxToPlace[i], i));
}
// Place some random starting zombies.
var startingZombies = 2;
var zombiesAdded = 0;
while (zombiesAdded < startingZombies)
{
zombiesAdded += TryToPlaceFeatureRandomly(zombie, ref generatedMap) ? 1 : 0;
}
// Replace all remaining empty spaces with floors
for (var i = 0; i < generatedMap.GetLength(0); ++i)
for (var j = 0; j < generatedMap.GetLength(1); ++j)
if (generatedMap[i, j] == GP.I)
generatedMap[i, j] = GP.F;
return generatedMap;
}
public void PlaceFeature(GP[,] feature, ref GP[,] map, int hPos, int vPos)
{
for (var h = hPos; h < hPos + feature.GetLength(0); ++h)
{
for (var v = vPos; v < vPos + feature.GetLength(1); ++v)
{
map[h,v] = feature[h-hPos, v-vPos];
}
}
}
public GamePiece PrefabFromGP(GP gp)
{
switch (gp)
{
case GP.C:
return CopPiecePrefab;
case GP.F:
return FloorPiecePrefab;
case GP.V:
return CivPiecePrefab;
case GP.W:
return WallPiecePrefab;
case GP.Z:
return ZombiePiecePrefab;
case GP.P:
return PresidentPiecePrefab;
case GP.H:
return HazmatPiecePrefab;
case GP.O:
return FatZombie;
case GP.S:
return SkinnyZombie;
default:
return null;
}
}
public bool TryToPlaceFeatureRandomly(GP[,] feature, ref GP[,] map)
{
var randomH = UnityEngine.Random.Range(0, map.GetLength(0)-feature.GetLength(0));
var randomV = UnityEngine.Random.Range(0, map.GetLength(1)-feature.GetLength(1));
if(CanPlaceFeature(feature, ref map, randomH, randomV))
{
PlaceFeature(feature, ref map, randomH, randomV);
return true;
}
return false;
}
