/// <summary>
/// Constructor
/// </summary>
/// <param name="body"></param>
/// <param name="model"></param>
/// <param name="team"></param>
/// <param name="enemyTeam"></param>
public BotPlayer(AbstractBody body, PrimitiveBuilder model, AbstractTeam team, AbstractTeam enemyTeam)
: base(body, model, team, enemyTeam)
{
this.SetCollisionBehaviors(new CollisionBehaviors(this));
this.MovementBehavior = new MovementBehavior();
this.AttackBehavior = new AttackBehavior();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="body"></param>
/// <param name="model"></param>
/// <param name="team"></param>
public AbstractFlag(AbstractBody body, PrimitiveBuilder model, AbstractTeam team)
: base(body, model)
{
this.Team = team;
this.InitialPosition = body.GetPosition();
EntityTable.Instance.Add(this.Body, this);
}
/// <summary>
/// Default model for ShotGun
/// </summary>
/// <returns></returns>
public static PrimitiveBuilder DefaultModel()
{
PrimitiveBuilder result = new PrimitiveBuilder(Color.HotPink);
result.Add(PrimitiveFactory.Circle(Color.HotPink, 6f, 6));
return result;
}
private IPrimitive CreateMarketOrder(MetaAction action, string side)
{
var code = new CodeBlock();
code.Add("local current_serial = source:serial(period);");
var executeCommandCode = new CodeBlock();
executeCommandCode.Add("last_serial = current_serial;");
var oppositeSide = side == "B" ? "S" : "B";
var closeTradesCode = new CodeBlock();
closeTradesCode
.Add($"local trades = trading:FindTrade():WhenSide(\"{oppositeSide}\"):WhenCustomID(custom_id):All();")
.Add("for _, trade in ipairs(trades) do")
.Add(" trading:Close(trade);")
.Add("end");
executeCommandCode.Add(PrimitiveBuilder
.If("instance.parameters.close_on_opposite")
.Then(closeTradesCode)
.Build(_variables));
executeCommandCode.Add($"local command = trading:MarketOrder(source:instrument()):SetSide(\"{side}\"):SetDefaultAmount():SetCustomID(custom_id);");
AddStop(action, executeCommandCode);
AddLimit(action, executeCommandCode);
executeCommandCode.Add("command:Execute();");
code.Add(new IfStatement(new NotEqualPrimitive("last_serial", "current_serial"),
executeCommandCode, _variables, ""));
return(code);
}
public static void AddMesh <TMaterial, TvG, TvM, TvS>(this MeshBuilder <TMaterial, TvG, TvM, TvS> meshBuilder, Mesh srcMesh, Converter <Material, TMaterial> materialFunc)
where TvG : struct, IVertexGeometry
where TvM : struct, IVertexMaterial
where TvS : struct, IVertexSkinning
{
Guard.NotNull(meshBuilder, nameof(meshBuilder));
Guard.NotNull(materialFunc, nameof(materialFunc));
if (srcMesh == null)
{
return;
}
var materialMap = srcMesh.Primitives
.Select(prim => prim.Material)
.Distinct()
.ToDictionary(mat => mat, mat => materialFunc(mat));
Material currMat = null;
PrimitiveBuilder <TMaterial, TvG, TvM, TvS> currPrim = null;
foreach (var tri in srcMesh.EvaluateTriangles <TvG, TvM, TvS>())
{
if (currMat != tri.Material)
{
currMat = tri.Material;
currPrim = meshBuilder.UsePrimitive(materialMap[currMat]);
}
currPrim.AddTriangle(tri.A, tri.B, tri.C);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="body"></param>
/// <param name="model"></param>
/// <param name="delayInMilliseconds"></param>
public AbstractGun(AbstractBody body, PrimitiveBuilder model, double delayInMilliseconds)
: base(body, model)
{
this.BulletIndex = 0;
this.DelayInMilliseconds = delayInMilliseconds;
// Add Entity table entry that maps the Body to this Entity
EntityTable.Instance.Add(this.Body, this);
}
public PrimitiveBuilder <TMaterial, TvP, TvM, TvJ> UsePrimitive(TMaterial material)
{
if (!_Primitives.TryGetValue(material, out PrimitiveBuilder <TMaterial, TvP, TvM, TvJ> primitive))
{
primitive = new PrimitiveBuilder <TMaterial, TvP, TvM, TvJ>(this, material, StrictMode);
_Primitives[material] = primitive;
}
return(primitive);
}
private static double RadiansOfBulletSpread = Math.PI / 12; // Pi / 12 is 15 degrees
#endregion Fields
#region Constructors
/// <summary>
/// Constructor
/// </summary>
/// <param name="body"></param>
/// <param name="model"></param>
public ShotGun(AbstractBody body, PrimitiveBuilder model)
: base(body, model, BulletDelayInMilliseconds)
{
Bullet[] bullets = new Bullet[100];
for (int i = 0; i < bullets.Length; i++)
{
PrimitiveBuilder bulletModel = new PrimitiveBuilder(Color.Yellow);
bulletModel.Add(PrimitiveFactory.Circle(Color.Yellow, 1f, 5));
bullets[i] = new Bullet(BodyFactory.Circle(false, 1f, BulletSpeed, 1f, false, 1f), bulletModel, this);
}
this.SetBullets(bullets);
this.SetCollisionBehaviors(new CollisionBehaviors(this));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="body"></param>
/// <param name="model"></param>
/// <param name="collisionBehaviors"></param>
public AbstractEntity(AbstractBody body, PrimitiveBuilder model, ICollisionBehaviors collisionBehaviors = null)
{
// Set body
this.Body = body;
// Set model
this._model = model;
// Subscribe to collision event
CollisionPool.Instance.CollisionDetected += CollisionDetected;
// Set collision behaviors
this._collisionBehaviors = collisionBehaviors;
}
protected override void ConstructOuterWalls(Vector2 size)
{
// Left wall
Vector2 leftWallStartPosition = Vector2.Zero;
Vector2 leftWallEndPosition = new Vector2(0f, size.Y);
PrimitiveBuilder leftWallModel = new PrimitiveBuilder(Color.White);
leftWallModel.Add(PrimitiveFactory.Line(Color.White, leftWallStartPosition, leftWallEndPosition));
LineBody leftWallBody = BodyFactory.Line(true, 0f, 0f, 0f, true, leftWallStartPosition, leftWallEndPosition);
this.Walls.Add(new LineWall(leftWallBody, leftWallModel));
// Top wall
Vector2 topWallStartPosition = Vector2.Zero;
Vector2 topWallEndPosition = new Vector2(size.X, 0f);
PrimitiveBuilder topWallModel = new PrimitiveBuilder(Color.White);
topWallModel.Add(PrimitiveFactory.Line(Color.White, topWallStartPosition, topWallEndPosition));
LineBody topWallBody = BodyFactory.Line(true, 0f, 0f, 0f, true, topWallStartPosition, topWallEndPosition);
this.Walls.Add(new LineWall(topWallBody, topWallModel));
// Right wall
Vector2 rightWallStartPosition = new Vector2(size.X, 0f);
Vector2 rightWallEndPosition = new Vector2(size.X, size.Y);
PrimitiveBuilder rightWallModel = new PrimitiveBuilder(Color.White);
rightWallModel.Add(PrimitiveFactory.Line(Color.White, rightWallStartPosition, rightWallEndPosition));
LineBody rightWallBody = BodyFactory.Line(true, 0f, 0f, 0f, true, rightWallStartPosition, rightWallEndPosition);
this.Walls.Add(new LineWall(rightWallBody, rightWallModel));
// Bottom wall
Vector2 bottomWallStartPosition = new Vector2(size.X, size.Y);
Vector2 bottomWallEndPosition = new Vector2(0f, size.Y);
PrimitiveBuilder bottomWallModel = new PrimitiveBuilder(Color.White);
bottomWallModel.Add(PrimitiveFactory.Line(Color.White, bottomWallStartPosition, bottomWallEndPosition));
LineBody bottomWallBody = BodyFactory.Line(true, 0f, 0f, 0f, true, bottomWallStartPosition, bottomWallEndPosition);
this.Walls.Add(new LineWall(bottomWallBody, bottomWallModel));
}
/// <summary>
/// Creates the "default" instance of this class
/// </summary>
/// <param name="color"></param>
/// <param name="team"></param>
/// <param name="enemyTeam"></param>
/// <returns></returns>
public static UserPlayer Default(Color color, AbstractTeam team, AbstractTeam enemyTeam)
{
CircleBody body = BodyFactory.Circle(false,
AppSettingsFacade.PlayerMass,
AppSettingsFacade.PlayerMaxSpeed,
AppSettingsFacade.PlayerFrictionCoefficient,
true,
AppSettingsFacade.PlayerRadius);
PrimitiveBuilder model = new PrimitiveBuilder(color);
model.Add(PrimitiveFactory.Circle(color, AppSettingsFacade.PlayerRadius, 3));
model.Add(PrimitiveFactory.Line(color, Vector2.Zero, Vector2.UnitX * body.GetRadius()));
UserPlayer result = new UserPlayer(body, model, team, enemyTeam);
team.AddPlayer(result);
return result;
}
private void ExportPrimitive(SurfaceBody surfaceBody, Face surfaceFace, PrimitiveBuilder <MaterialBuilder, VertexPositionNormal, VertexEmpty, VertexEmpty> primitive)
{
try
{
int facetCount;
int vertCount;
var coords = new double[] { };
var norms = new double[] { };
var indices = new int[] { };
if (surfaceBody != null)
{
surfaceBody.CalculateFacets((double)exportTolerance, out vertCount, out facetCount, out coords, out norms, out indices);
}
else
{
surfaceFace.CalculateFacets((double)exportTolerance, out vertCount, out facetCount, out coords, out norms, out indices);
}
if (indices.Length % 3 != 0 || coords.Length % 3 != 0)
{
warnings.Add("Invalid mesh calculated!");
return;
}
for (var c = 0; c < indices.Length; c += 3)
{
var indexA = indices[c];
var indexB = indices[c + 1];
var indexC = indices[c + 2];
primitive.AddTriangle(
GetNormsAndCoords(coords, norms, indexA - 1),
GetNormsAndCoords(coords, norms, indexB - 1),
GetNormsAndCoords(coords, norms, indexC - 1)
);
}
}
catch
{
warnings.Add("Unable to export surface body");
}
}
/// <summary>
/// Initialize
/// </summary>
protected override void Initialize()
{
// Build blue team
CaptureTheFlagTeam blueTeam = new CaptureTheFlagTeam(
"Blue team",
new Vector2(25f, 25f),
Color.Blue);
// Build red team
CaptureTheFlagTeam redTeam = new CaptureTheFlagTeam(
"Red team",
new Vector2(AppSettingsFacade.WindowWidth - 25f, AppSettingsFacade.WindowHeight - 25f),
Color.Red);
// Add guns
this.AddGun(new WeakGun(
WeakGun.DefaultBody(this.Size * 0.4f),
WeakGun.DefaultModel()));
this.AddGun(new WeakGun(
WeakGun.DefaultBody(this.Size * 0.6f),
WeakGun.DefaultModel()));
this.AddGun(new ShotGun(
ShotGun.DefaultBody(new Vector2(AppSettingsFacade.WindowWidth / 2, 0.1f * AppSettingsFacade.WindowHeight)),
ShotGun.DefaultModel()));
this.AddGun(new ShotGun(
ShotGun.DefaultBody(new Vector2(AppSettingsFacade.WindowWidth / 2, 0.9f * AppSettingsFacade.WindowHeight)),
ShotGun.DefaultModel()));
// Add spawn points
blueTeam.AddSpawnPoint(blueTeam.GetBasePosition());
blueTeam.AddSpawnPoint(blueTeam.GetBasePosition() + new Vector2(0f, 50f));
// Add players
UserPlayer blueUser = UserPlayer.Default(Color.Blue, blueTeam, redTeam);
BotPlayer blueBot1 = BotPlayer.Default(Color.Blue, blueTeam, redTeam);
blueUser.Spawn();
blueBot1.Spawn();
this.AddTeam(blueTeam);
// Add spawn points
redTeam.AddSpawnPoint(redTeam.GetBasePosition());
redTeam.AddSpawnPoint(redTeam.GetBasePosition() + new Vector2(0f, -50f));
// Add players
BotPlayer redBot1 = BotPlayer.Default(Color.Red, redTeam, blueTeam);
BotPlayer redBot2 = BotPlayer.Default(Color.Red, redTeam, blueTeam);
redBot1.Spawn();
redBot2.Spawn();
this.AddTeam(redTeam);
// Build walls
// Circle wall in the middle of the map
PrimitiveBuilder circleWallModel1 = new PrimitiveBuilder(Color.White);
circleWallModel1.Add(PrimitiveFactory.Circle(Color.White, 100f, 24));
CircleBody circleWallBody1 = (CircleBody)BodyFactory.Circle(true, 0f, 0f, 0f, true, 100f).SetPosition(this.Size / 2);
this.AddWall(new CircleWall(circleWallBody1, circleWallModel1));
// Blue-side circle wall in front of flag
PrimitiveBuilder circleWallModel2 = new PrimitiveBuilder(Color.Blue);
circleWallModel2.Add(PrimitiveFactory.Circle(Color.White, 75f, 24));
CircleBody circleWallBody2 = (CircleBody)BodyFactory.Circle(true, 0f, 0f, 0f, true, 75f).SetPosition(this.Size * 0.25f);
this.AddWall(new CircleWall(circleWallBody2, circleWallModel2));
// Red-side circle wall in front of flag
PrimitiveBuilder circleWallModel3 = new PrimitiveBuilder(Color.Red);
circleWallModel3.Add(PrimitiveFactory.Circle(Color.White, 75f, 24));
CircleBody circleWallBody3 = (CircleBody)BodyFactory.Circle(true, 0f, 0f, 0f, true, 75f).SetPosition(this.Size * 0.75f);
this.AddWall(new CircleWall(circleWallBody3, circleWallModel3));
// Blue-side circle wall in front of flag
PrimitiveBuilder circleWallModel4 = new PrimitiveBuilder(Color.Blue);
circleWallModel4.Add(PrimitiveFactory.Circle(Color.White, 75f, 24));
CircleBody circleWallBody4 = (CircleBody)BodyFactory.Circle(true, 0f, 0f, 0f, true, 75f).SetPosition(new Vector2(this.Size.X * 0.25f, this.Size.Y * 0.75f));
this.AddWall(new CircleWall(circleWallBody4, circleWallModel4));
// Red-side circle wall in front of flag
PrimitiveBuilder circleWallModel5 = new PrimitiveBuilder(Color.Blue);
circleWallModel5.Add(PrimitiveFactory.Circle(Color.White, 75f, 24));
CircleBody circleWallBody5 = (CircleBody)BodyFactory.Circle(true, 0f, 0f, 0f, true, 75f).SetPosition(new Vector2(this.Size.X * 0.75f, this.Size.Y * 0.25f));
this.AddWall(new CircleWall(circleWallBody5, circleWallModel5));
this.ConstructOuterWalls(this.Size);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="body"></param>
/// <param name="model"></param>
/// <param name="team"></param>
/// <param name="enemyTeam"></param>
public UserPlayer(AbstractBody body, PrimitiveBuilder model, AbstractTeam team, AbstractTeam enemyTeam)
: base(body, model, team, enemyTeam)
{
this.SetCollisionBehaviors(new CollisionBehaviors(this));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="body"></param>
/// <param name="model"></param>
/// <param name="team"></param>
public Flag(AbstractBody body, PrimitiveBuilder model, AbstractTeam team)
: base(body, model, team)
{
this.SetCollisionBehaviors(new CollisionBehaviors(this));
}
private static GeometryModel3D[] GetCameraPlanar(CameraPosition camera)
{
List <GeometryModel3D> models = new List <GeometryModel3D>();
var model = new MeshGeometryModel3D();
var length = (camera.FocalLength / Math.Sqrt(Math.Pow(camera.Height, 2) + Math.Pow(camera.Width, 2)));
var p1 = camera.CameraCenter +
length * (CameraPosition.GetCornerPointToAxis(camera, camera.Orientation,
CameraPosition.Direction.TopLeft));
var p2 = camera.CameraCenter +
length * (CameraPosition.GetCornerPointToAxis(camera, camera.Orientation,
CameraPosition.Direction.TopRight));
var p3 = camera.CameraCenter +
length * (CameraPosition.GetCornerPointToAxis(camera, camera.Orientation,
CameraPosition.Direction.BottomRight));
var p4 = camera.CameraCenter +
length * (CameraPosition.GetCornerPointToAxis(camera, camera.Orientation,
CameraPosition.Direction.BottomLeft));
model.Geometry = PrimitiveBuilder.GetRect(p1.ToVector3(), p2.ToVector3(), p3.ToVector3(), p4.ToVector3());
//model.Material = new PhongMaterial
//{
// DiffuseMap = new BitmapImage(new Uri(camera.File))
//};
////model.Material = PhongMaterials.Yellow;
////Viewport.Items.Add(model);
//models.Add(model);
var linemodel = new LineGeometryModel3D();
var lb = new LineBuilder();
lb.AddLine(camera.CameraCenter.ToVector3(), p1.ToVector3());
lb.AddLine(camera.CameraCenter.ToVector3(), p2.ToVector3());
lb.AddLine(camera.CameraCenter.ToVector3(), p3.ToVector3());
lb.AddLine(camera.CameraCenter.ToVector3(), p4.ToVector3());
lb.AddLine(p1.ToVector3(), p2.ToVector3());
lb.AddLine(p2.ToVector3(), p3.ToVector3());
lb.AddLine(p3.ToVector3(), p4.ToVector3());
lb.AddLine(p4.ToVector3(), p1.ToVector3());
lb.AddLine(p1.ToVector3(), p3.ToVector3());
lb.AddLine(p2.ToVector3(), p4.ToVector3());
linemodel.Geometry = lb.ToLineGeometry3D();
linemodel.Color = LUT.GetRandomColor();
linemodel.Name = "PlanarCamera_" + Path.GetFileName(camera.File).Split('.').First() + "_" + camera.Id;
models.Add(linemodel);
MeshBuilder mb = new MeshBuilder();
MeshGeometryModel3D modelCameraCenter = new MeshGeometryModel3D();
mb.AddSphere(camera.CameraCenter.ToVector3(), 0.03);
mb.AddSphere(p1.ToVector3(), 0.03);
modelCameraCenter.Geometry = mb.ToMeshGeometry3D();
modelCameraCenter.Material = new PhongMaterial()
{
DiffuseColor = linemodel.Color,
AmbientColor = linemodel.Color
};
//models.Add(modelCameraCenter);
return(models.ToArray());
}
public static (int, int, int) AddTriangleWithBatchId(this PrimitiveBuilder <MaterialBuilder, VertexPositionNormal, VertexWithBatchId, VertexEmpty> prim, (Vector3, Vector3, Vector3) triangle, Vector3 normal, int batchid)
/// <summary>
/// Default model
/// </summary>
/// <param name="color"></param>
/// <returns></returns>
public static PrimitiveBuilder DefaultModel(Color color)
{
PrimitiveBuilder result = new PrimitiveBuilder(color);
result.Add(PrimitiveFactory.Circle(color, 10f, 3));
return result;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="body"></param>
/// <param name="model"></param>
public CircleWall(AbstractBody body, PrimitiveBuilder model)
: base(body, model)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="body"></param>
/// <param name="model"></param>
/// <param name="team"></param>
protected AbstractPlayer(AbstractBody body, PrimitiveBuilder model, AbstractTeam team, AbstractTeam enemyTeam)
: base(body, model)
{
this.Team = team;
this.EnemyTeam = enemyTeam;
this.Health = AppSettingsFacade.PlayerHealth;
this.HealthLabel = new TextLabel(String.Empty,
SpriteFontRepository.Instance.Get("test"),
Vector2.Zero,
LabelAlignment.Center,
Color.White);
this._messageQueue = new TextLabelQueue(
SpriteFontRepository.Instance.Get("test"),
Vector2.Zero,
LabelAlignment.Center,
Color.White,
3000);
this._healthBar = new CircleProgressBar(new Color(20, 20, 30));
EntityTable.Instance.Add(this.Body, this);
this.IsAlive = true;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="body"></param>
/// <param name="model"></param>
/// <param name="gun"></param>
public Bullet(AbstractBody body, PrimitiveBuilder model, AbstractGun gun)
: base(body, model, gun)
{
this.SetCollisionBehaviors(new CollisionBehaviors(this));
}
private void ExportPrimitive(SurfaceBody surfaceBody, PrimitiveBuilder <MaterialBuilder, VertexPositionNormal, VertexEmpty, VertexEmpty> primitive)
{
ExportPrimitive(surfaceBody, null, primitive);
}
private void ExportPrimitive(Face surfaceFace, PrimitiveBuilder <MaterialBuilder, VertexPositionNormal, VertexEmpty, VertexEmpty> primitive)
{
ExportPrimitive(null, surfaceFace, primitive);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="body"></param>
/// <param name="model"></param>
public RectangleWall(AbstractBody body, PrimitiveBuilder model)
: base(body, model)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="body"></param>
/// <param name="model"></param>
public AbstractWall(AbstractBody body, PrimitiveBuilder model)
: base(body, model)
{
EntityTable.Instance.Add(this.Body, this);
}
