public MapChangeArgs(MapData map, HexPoint updatedTile)
{
_map = map;
_updatedTiles = new List<HexPoint>();
_updatedTiles.Add(updatedTile);
}
public void ZCoordTest(
[ValueSource("s_AllPoints")] TestHexPoint hexPoint)
{
// Arrange
var point = new HexPoint(hexPoint.x, hexPoint.y);
// Assert
Assert.AreEqual(hexPoint.z, point.z);
}
public void XZCreationTest(
[ValueSource("s_AllPoints")] TestHexPoint hexPoint)
{
// Arrange
var point = HexPoint.FromXZ(hexPoint.x, hexPoint.z);
// Assert
Assert.AreEqual(hexPoint.y, point.y);
}
//make another type for def
public Boolean CanMoveTo(HexPoint moveTo)
{
//split for maybe sep messages
//also cant be straight line, need to pathfind to it
if (MoveableInMoveRange().Contains(moveTo))
{
return(true);
}
return(false);
}
public void MoveTo(HexPoint moveTo)
{
if (CanMoveTo(moveTo) && ActiveTurnState[APUseType.Movement] > 0 && ActiveTurnState[APUseType.TotalAp] > 0)//should be checked elsewhere for UI reasons
{
Location = moveTo;
ActorHexGrid.UnHighlightAll();
ActorHexGrid.DebugLines = new List <DebugLine>();
UseAp(APUseType.Movement);
}
}
/// <inheritdoc/>
public virtual HexCoords GetHexCoords(HexPoint point, HexSize autoScroll)
{
// Adjust for origin not as assumed by GetCoordinate().
var grid = new HexSize((int)(GridSizeF.Width * 2F / 3F), (int)GridSizeF.Height);
point -= autoScroll + grid - Margin;
return(HexCoords.NewCanonCoords(GetCoordinate(_matrixX, point),
GetCoordinate(_matrixY, point)));
}
/*
*
* function cube_round(cube):
* var rx = round(cube.x)
* var ry = round(cube.y)
* var rz = round(cube.z)
*
* var x_diff = abs(rx - cube.x)
* var y_diff = abs(ry - cube.y)
* var z_diff = abs(rz - cube.z)
*
* if x_diff > y_diff and x_diff > z_diff:
* rx = -ry-rz
* else if y_diff > z_diff:
* ry = -rx-rz
* else:
* rz = -rx-ry
*
* return Cube(rx, ry, rz)
*
* function lerp(a, b, t): # for floats
* return a + (b - a) * t
*
* function cube_lerp(a, b, t): # for hexes
* return Cube(lerp(a.x, b.x, t),
* lerp(a.y, b.y, t),
* lerp(a.z, b.z, t))
*
* function cube_linedraw(a, b):
* var N = cube_distance(a, b)
* var results = []
* for each 0 ≤ i ≤ N:
* results.append(cube_round(cube_lerp(a, b, 1.0/N * i)))
* return results
*/
#region static methods
public static int HexDistance(HexPoint hex1, HexPoint hex2)
{
//https://www.redblobgames.com/grids/hexagons/#range
//get cube cord third value
int cubeValHex1 = -hex1.Q - hex1.R;
int cubeValHex2 = -hex2.Q - hex2.R;
//return max(abs(a.x - b.x), abs(a.y - b.y), abs(a.z - b.z))
return(Math.Max(Math.Max(Math.Abs(hex1.Q - hex2.Q), Math.Abs(hex1.R - hex2.R)), Math.Abs(cubeValHex1 - cubeValHex2)));
}
public List<GlobalObject> this[HexPoint p]
{
get
{
List<GlobalObject> result = new List<GlobalObject>();
if (player.position.TheSameAs(p)) result.Add(player);
foreach (GlobalObject g in gObjects) if (g.position.TheSameAs(p)) result.Add(g);
return result;
}
}
/// <summary><c>HexCoords</c> for the hex at the screen point, with the given AutoScroll position.</summary>
/// <param name="this"></param>
/// <param name="point">Screen point specifying hex to be identified.</param>
/// <param name="autoScroll">AutoScrollPosition for game-display Panel.</param>
static HexCoords GetHexCoordsInner(this IHexgrid @this, HexPoint point, HexSize autoScroll)
{
// Adjust for origin not as assumed by GetCoordinate().
var grid = new HexSize((int)(@this.GridSizeF().Width *2F / 3F), (int)@this.GridSizeF().Height);
point -= autoScroll + grid - @this.Margin;
return(HexCoords.NewCanonCoords(@this.GetCoordinate(@this.MatrixX(), point),
@this.GetCoordinate(@this.MatrixY(), point)));
}
public BasicActor(HexPoint location, string name, Dictionary <string, string> actorData, int rotation, bool PC, string moduleName, HexGrid.HexGrid hexGrid)
{
Name = name;
Location = location;
Controllable = PC;
Rotation = rotation;
ModuleName = moduleName;
ActorHexGrid = hexGrid;
AsignActorData(actorData);
}
/// <summary>
/// Calculate three possible locations for the road to be placed at placement gamephase
/// </summary>
/// <param name="game"></param>
/// <param name="board"></param>
/// <param name="townOrCity"></param>
public RoutePlaces(XmlGame game, BoardVisual board, HexPoint townOrCity)
{
// Add each side to children
foreach (HexSide side in townOrCity.GetNeighbourSides)
{
Point2D newPoint = board.CalculatePosition(side);
HexSideVisual newHexSide = new HexSideVisual(newPoint, side);
Children.Add(newHexSide);
}
}
public float this[HexPoint pt]
{
get
{
return _data[pt.X, pt.Y];
}
set
{
_data[pt.X, pt.Y] = value;
}
}
public bool IsLocalMaximum(HexPoint pt)
{
bool localMaximum = this[pt] > 0;
// local maximum
foreach (HexPoint pts in pt.Neighbors)
if (MainWindow.Game.Map.IsValid(pts))
localMaximum &= (this[pt] >= this[pts]);
return localMaximum;
}
public static void DrawLine(HexPoint a, HexPoint b, ref HexPoint[] output)
{
output = CoordinateSystem.PointsBetweenHexPoints(a, b);
foreach (HexPoint p in output)
{
if (GlobalGameManager.instance.Map[p].CurrentState != HexStates.Highlighted)
{
GlobalGameManager.instance.Map[p].Highlight(true);
}
}
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
HexPoint coordinates = new HexPoint(
property.FindPropertyRelative("x").intValue,
property.FindPropertyRelative("z").intValue
);
label = new GUIContent("Coordinates");
position = EditorGUI.PrefixLabel(position, label);
GUI.Label(position, coordinates.ToString());
}
public static HexTile GetTileAtDirection(HexPoint point, int direction)
{
if (board == null)
{
return(null);
}
HexPoint targetPoint = point + directions[direction];
return(board.GetTile(targetPoint) != null?board.GetTile(targetPoint) : null);
}
public void Apply(HexPoint hexPoint, int value)
{
for (int x = 0; x < _width; ++x)
{
for (int y = 0; y < _height; ++y)
{
int dist = HexPoint.GetDistance(hexPoint.X, hexPoint.Y, x, y);
this[x, y] += value / (float)Math.Pow(2, dist);
}
}
}
public static void CreateRange(HexPoint center, int rangeDistance, ref HexPoint[] range)
{
range = CoordinateSystem.CreateRings(center, rangeDistance);
foreach (HexPoint p in range)
{
if (GlobalGameManager.instance.Map[p].CurrentState != HexStates.Highlighted)
{
GlobalGameManager.instance.Map[p].Highlight(true);
}
}
}
public void SetLink(HexPoint a, HexPoint b)
{
linkedHexpoint[0] = a;
linkedHexpoint[1] = b;
gameObject.name = "Edge between: " + a.name + ", " + b.name;
SetPositionInWorldCoordinate();
UpdateLink();
}
private HexPoint GetCurrentHexPoint(Vector3 worldPos)
{
HexPoint hex = CoordinateSystem.pixel_to_flat_hex(new Vector3(worldPos.x, 0, -worldPos.z), out hex);
if (CoordinateSystem.PointIsOnMap(hex))
{
_currentHexTile = GlobalGameManager.instance.Map[hex];
return(hex);
}
return(_currentHexPoint);
}
private void Start()
{
_tileContainer = _tileContainerData;
min = CalculateWorldPosition(Vector3.zero);
max = CalculateWorldPosition(new Vector3(Screen.width, Screen.height, 0));
CoordinateSystem.width = _tileContainer.Layer(TileHeight.zero).meshSizeX;
HexPoint start = CoordinateSystem.pixel_to_flat_hex(Vector3.zero, out start);
CreateMap(start, _mapRadius);
CoordinateSystem.isInitialized = true;
}
public void Render(Player player, HexPoint selectedHex, List <HexPoint> moves)
{
if (Grid == null)
{
return;
}
foreach (Hex hex in Grid)
{
Vector2 renderPos = Layout.HexCorner(hex.Position, 3);
renderPos.X -= Layout.size / 2f * sqrt3;
renderPos.Y -= Layout.size / 2f;
renderPos.X = (float)Math.Floor(renderPos.X);
renderPos.Y = (float)Math.Floor(renderPos.Y);
Color mask;
if (selectedHex == hex.Position)
{
if (moves != null && moves.Contains(hex.Position))
{
mask = Color.FromArgb(80, 0, 100, 0);
}
else
{
mask = Color.FromArgb(50, Color.Black);
}
}
else if (moves != null && moves.Contains(hex.Position))
{
mask = Color.FromArgb(80, 0, 200, 0);
}
else
{
mask = Color.Transparent;
}
RenderHex(hex.Position, hex.GetTypes(Data), Layout, Color.White, frameCount, Grid);
if (mask.A > 0)
{
TextureRenderer.DrawHex(Textures.Get("Hex\\Mask"), hex.Position, Layout, Vector2.One * Layout.size, mask, null);
}
if (hex.Position == player.Position)
{
TextureRenderer.DrawHex(Textures.Get("Player"), hex.Position, Layout, Vector2.One * Layout.size, player.Color, null);
}
}
frameCount++;
}
protected Edge FindEdgeBetween(HexPoint a, HexPoint b)
{
for (int i = 0; i < edges.Count; i++)
{
if (edges[i].IsLinkBetween(a, b))
{
return(edges[i]);
}
}
return(null);
}
public override long Part1(string input)
{
black = new HashSet <HexPoint>();
var start = new HexPoint(0, 0, 0);
foreach (var line in Utils.splitLines(input))
{
var line2 = line.Replace("se", "a").Replace("sw", "b").Replace("ne", "c").Replace("nw", "d");
var pos = start;
foreach (var move in line2)
{
switch (move)
{
case 'e':
pos = pos.E();
break;
case 'w':
pos = pos.W();
break;
case 'a':
pos = pos.SE();
break;
case 'b':
pos = pos.SW();
break;
case 'c':
pos = pos.NE();
break;
case 'd':
pos = pos.NW();
break;
}
}
if (black.Contains(pos))
{
black.Remove(pos);
}
else
{
black.Add(pos);
}
}
return(black.Count);
}
public HexTile(GameObject worldObject, HexPoint point, TileData data)
{
tileType = TileType.Default;
_currentState = HexStates.Idle;
_q = (int)point.q;
_r = (int)point.r;
_worldtransform = worldObject.transform;
_defaultPosition = _worldtransform.position;
_renderer = worldObject.GetComponentInChildren <MeshRenderer>();
_material = _renderer.material;
_highlightedPosition = _defaultPosition + Vector3.up * 0.1f;
highestPoint = _defaultPosition + Vector3.up * (data.meshSizeY - MapGenerator.DefaultTile.meshSizeY / 2);
}
public HexPoint SelectedHex(Vector2 screenCordinates)
{
var R = (int)Math.Round((2.0f / 3.0f * screenCordinates.Y) / HexYSize);
var Q = (int)Math.Round(((Math.Sqrt(3) / 3 * screenCordinates.X) - (1.0f / 3.0f * screenCordinates.Y)) / HexXSize);
var possiblePoint = new HexPoint(R, Q);
var inGrid = HexStorage.Any(h => h.Key.Equals(possiblePoint));
if (!inGrid)
{
return(null);
}
return(possiblePoint);
}
public int RotateToDirectionMoved(HexPoint dir)
{
//comments for "base" case
//maybe look at ratios for more fine grained turning -> other things should determine rot later though
//dont be lazy just draw it out :TODO
if (dir.Q > 0 && dir.R < 0)//dir.Q == 1 && dir.R == -1
{
return(0);
}
else if (dir.Q > 0 && dir.R == 0)//dir.Q == 1 && dir.R == 0
{
return(1);
}
else if (dir.Q == 0 && dir.R > 0)//dir.Q == 0 && dir.R == 1
{
return(2);
}
else if (dir.Q < 0 && dir.R > 0)//dir.Q == -1 && dir.R == 1
{
return(3);
}
else if (dir.Q < 0 && dir.R == 0)//dir.Q == -1 && dir.R == 0
{
return(4);
}
else if (dir.Q == 0 && dir.R < 0)//if (dir.Q == 0 && dir.R == -1)
{
return(5);
}
else
{
if (dir.Q > 0 && dir.R > 0)
{
if (dir.Q > dir.R)
{
return(1);
}
return(2);
}
if (dir.Q < 0 && dir.R < 0)
{
if (dir.R > dir.Q)
{
return(4);
}
return(5);
}
}
//should never happpen
return(new Random().Next(6));
}
public void GoTo(HexPoint _point)
{
for (int i = 0; i < MapConstants.height; i++)
{
for (int j = 0; j < MapConstants.width; j++)
{
if (_point == MapConstants.cells[i, j].coordinates)
{
SetPosition(MapConstants.cells[i, j]);
return;
}
}
}
}
public void Rotate180Test(
[ValueSource("s_ValidPoints")] TestHexPoint source,
[ValueSource("s_180RotatedValidPoints")] TestHexPoint expected)
{
// Arrange
var point = new HexPoint(source.x, source.y);
var expectedPoint = new HexPoint(expected.x, expected.y);
// Act
point = HexPoint.Rotate180(point);
// Assert
Assert.AreEqual(expectedPoint, point);
}
public int Path(Vector2Int startPos, Vector2Int endPos, out HexPoint[] path)
{
Vector2Int delta = endPos - startPos; // go correct direction
int pathLength = 0;
int diagonalLength = 0;
if (delta.x * delta.y > 0)
{
diagonalLength = Mathf.Abs(delta.x) + Mathf.Abs(delta.y) - Mathf.Abs(delta.x - delta.y);
diagonalLength = (int)(diagonalLength * 0.5f);
pathLength = Mathf.Abs(delta.x) + Mathf.Abs(delta.y) - diagonalLength;
}
else
{
pathLength = Mathf.Abs(delta.x) + Mathf.Abs(delta.y);
}
path = new HexPoint[pathLength + 1];
path[0] = GetPoint(startPos);
int i = 1;
// move in diagonal
while (i <= diagonalLength)
{
path[i] = GetPoint(path[i - 1].positionInBoard + ExdMath.DIRECTION_SIX[2] * (int)Mathf.Sign(delta.x));
i++;
}
// move in x or y axis
if (Mathf.Abs(delta.x) > Mathf.Abs(delta.y))
{
while (i <= pathLength)
{
path[i] = GetPoint(path[i - 1].positionInBoard + ExdMath.DIRECTION_SIX[1] * (int)Mathf.Sign(delta.x));
i++;
}
}
else
{
while (i <= pathLength)
{
path[i] = GetPoint(path[i - 1].positionInBoard + ExdMath.DIRECTION_SIX[3] * (int)Mathf.Sign(delta.y));
i++;
}
}
return(pathLength);
}
public bool IsLinkBetween(HexPoint a, HexPoint b)
{
if (a == linkedHexpoint[0] && b == linkedHexpoint[1])
{
return(true);
}
if (a == linkedHexpoint[1] && b == linkedHexpoint[0])
{
return(true);
}
return(false);
}
public void ReflectZOffsetTest(
[ValueSource("s_ValidPoints")] TestHexPoint source,
[ValueSource("s_OffsetZMirroredValidPoints")] TestHexPoint expected)
{
// Arrange
var point = new HexPoint(source.x, source.y);
var expectedPoint = new HexPoint(expected.x, expected.y);
// Act
point = HexPoint.ReflectZ(point, 1);
// Assert
Assert.AreEqual(expectedPoint, point);
}
public bool IsCellExist(HexPoint _point)
{
for (int i = 0; i < MapConstants.height; i++)
{
for (int j = 0; j < MapConstants.width; j++)
{
if (_point == MapConstants.cells[i, j].coordinates)
{
return(true);
}
}
}
return(false);
}
public void DoubleRightRotateTest(
[Random(-10000, 10000, 5)] int x,
[Random(-10000, 10000, 5)] int y)
{
// Arrange
var point = new HexPoint(x, y);
var expectedPoint = HexPoint.RotateRight(HexPoint.RotateRight(point));
// Act
point = HexPoint.RotateRight120(point);
// Assert
Assert.AreEqual(expectedPoint, point);
}
public string RunPart1(IEnumerable <string> testData)
{
var input = testData.First().Split(',');
// Start at home
var current = new HexPoint(0, 0, 0);
foreach (var direction in input)
{
var point = _actions[direction];
current = current.AddPoint(point);
}
return(current.CalculateDistanceToRoot().ToString());
}
public void Left120OffsetRotateTest(
[ValueSource("s_RightOffsetRotatedValidPoints")] TestHexPoint source,
[ValueSource("s_LeftOffsetRotatedValidPoints")] TestHexPoint expected)
{
// Arrange
var point = new HexPoint(source.x, source.y);
var expectedPoint = new HexPoint(expected.x, expected.y);
var offsetPoint = new HexPoint(s_OffsetPosition.x, s_OffsetPosition.y);
// Act
point = HexPoint.RotateLeft120(point, offsetPoint);
// Assert
Assert.AreEqual(expectedPoint, point);
}
public ForestEntity(HexPoint point)
{
if( model == null )
model = MainApplication.ManagerInstance.Content.Load<Model>("Content\\Models\\forest");
Point = point;
Scale = new Vector3(0.01f);
Rotation = new Vector3(0, (float)(rand.NextDouble() * Math.PI * 2), 0);
int boneCount = model.Bones.Count;
boneVisible = Enumerable.Repeat<bool>(true, boneCount).ToArray();
this.boneTransforms = new Matrix[boneCount];
model.CopyBoneTransformsTo(this.boneTransforms);
this.absoluteBoneTransforms = new Matrix[boneCount];
}
public override BehaviourResult Clicked(RayMeshGeometry3DHitTestResult rayMeshResult, BoardVisual board)
{
Road hsv = rayMeshResult.VisualHit as Road;
if (hsv != null)
{
hsv.IsRoadSelected = true;
}
BuildPointVisual buildPoint = rayMeshResult.VisualHit as BuildPointVisual;
if (buildPoint != null)
{
//board.Game.PlayerOnTurn.Cities.Add(buildPoint.Location);
_Location = buildPoint.Location;
board.SetNeutral();
((BuildCityAction)_OriginatingAction).Location = buildPoint.Location;
return BehaviourResult.Success;
}
return BehaviourResult.NoSuccess;
}
//protected Dictionary<PolicyType, bool> _policies = new Dictionary<PolicyType, bool>();
public ModellingTile(HexPoint pt)
{
_location = pt;
// init rules
_systems.Add(RuleType.Citizen, new CitizenRuleSystem(this,500));
_systems.Add(RuleType.GrowthRate, new GrowthRateRuleSystem(this,1.1));
_systems.Add(RuleType.Pollution, new PollutionRuleSystem(this, 0.0));
_systems.Add(RuleType.GDP, new GrossDomesticProduct(this));
_systems.Add(RuleType.Productivity, new ProductivitySystem(this, 0.0));
_systems.Add(RuleType.Food, new FoodSystem(this, 0.0));
_systems.Add(RuleType.CorporateTaxRate, new CorporateTaxRateSystem(this, 0.0));
_systems.Add(RuleType.Crime, new CrimeSystem(this, 0.0));
_systems.Add(RuleType.AgricultureLevel, new AgricultureSystem(this, 0.0));
_systems.Add(RuleType.EnergyCost, new EnergyCostSystem(this));
_systems.Add(RuleType.Immigration, new ImmigrationRuleSystem(this));
_systems.Add(RuleType.Poverty, new PovertyRuleSystem(this));
// people
_systems.Add(RuleType.LowIncomePeople, new LowIncomePeopleRuleSystem(this));
_systems.Add(RuleType.MidIncomePeople, new MidIncomePeopleRuleSystem(this));
_systems.Add(RuleType.HighIncomePeople, new HighIncomePeopleRuleSystem(this));
// money
_systems.Add(RuleType.LowIncome, new LowIncomeRuleSystem(this));
_systems.Add(RuleType.MidIncome, new MidIncomeRuleSystem(this));
_systems.Add(RuleType.HighIncome, new HighIncomeRuleSystem(this));
//// Tradition
//_policies.Add(PolicyType.Aristocracy, false);
//_policies.Add(PolicyType.Oligarchy, false);
//_policies.Add(PolicyType.Legalism, false);
//_policies.Add(PolicyType.LandedElite, false);
//_policies.Add(PolicyType.Monarchy, false);
//// Liberty
//_policies.Add(PolicyType.CollectiveRule, false);
//_policies.Add(PolicyType.Citizenship, false);
//_policies.Add(PolicyType.Republic, false);
//_policies.Add(PolicyType.Representation, false);
//_policies.Add(PolicyType.Meritocracy, false);
}
public MapRenderer(Manager manager)
{
_manager = manager;
_baseMesh = new Mesh(manager.GraphicsDevice, "ground");
_cursorsMesh = new Mesh(manager.GraphicsDevice, "cursors");
_borderMesh = new Mesh(manager.GraphicsDevice, "cursors");
_roadMesh = new Mesh(manager.GraphicsDevice, "roads");
_farmMesh = new Mesh(manager.GraphicsDevice, "farms");
_riverMesh = new Mesh(manager.GraphicsDevice, "rivers");
TextureManager.Instance.Device = manager.GraphicsDevice;
_hiddenMeshContainer = new TiledMeshContainer(manager);
FogOfWarEnabled = true;
hMesh = new HexMesh(manager.GraphicsDevice);
Center = new HexPoint();
}
public override void Move(HexPoint.HexDirection d)
{
base.Move(d);
foreach (LocalObject c in party) c.fatigue.Add(W.map[position.Shift(d)].type.travelTime * c.hp.Max);
ground.Clear();
crafting.Clear();
foreach (ItemShape s in W.map[position].items) if (W.random.Next(50) <= Sum(Skill.Get("Survival"))) ground.Add(s);
if (barter != null)
{
foreach (Item item in toBuy.Items) if (barter.inventory.CanAdd(item)) barter.inventory.Add(item);
foreach (Item item in toSell.Items) if (inventory.CanAdd(item)) inventory.Add(item);
toBuy.Clear();
toSell.Clear();
barter = null;
}
UpdateVisitedLocations();
}
public Unit(HexPoint point, AbstractPlayerData player, UnitData data)
{
_point = point;
_player = player;
_data = data;
Strength = 10;
_unitAI = _data.DefaultUnitAI;
UpdateSpotting();
InitTransitions();
InitFormation();
_entity = new UnitEntity(player, this, _data.ModelName);
_entity.Point = point;
_entity.Scale = new Vector3(_data.ModelScale);
_unitActionBillboard = new BillboardSystem<UnitAction>(MainApplication.Instance.GraphicsDevice, MainApplication.Instance.Content);
_unitActionBillboard.AddEntity(UnitAction.Idle, Provider.GetAtlas("UnitActionAtlas").GetTexture("Idle"), new Vector2(2, 2));
_unitActionBillboard.AddEntity(UnitAction.Move, Provider.GetAtlas("UnitActionAtlas").GetTexture("Move"), new Vector2(2, 2));
_unitActionBillboard.AddEntity(UnitAction.BuildFarm, Provider.GetAtlas("UnitActionAtlas").GetTexture("BuildFarm"), new Vector2(2, 2));
_unitActionBillboard.AddEntity(UnitAction.BuildRoad, Provider.GetAtlas("UnitActionAtlas").GetTexture("BuildRoad"), new Vector2(2, 2));
_unitActionBillboard.AddEntity(UnitAction.Found, Provider.GetAtlas("UnitActionAtlas").GetTexture("Found"), new Vector2(2, 2));
UpdateUnitAction();
// path mesh
_pathMesh = new Mesh(MainApplication.Instance.GraphicsDevice, "paths");
if( TextureManager.Instance.Device == null )
TextureManager.Instance.Device = MainApplication.Instance.GraphicsDevice;
TextureManager.Instance.Add("paths", MainApplication.Instance.Content.Load<Texture2D>("Content/Textures/Ground/paths"));
_pathMesh.LoadContent(MainApplication.Instance.Content);
}
public City GetCityAt(HexPoint pt)
{
foreach (City c in _cities)
if (c.Point == pt)
return c;
return null;
}
public Unit GetUnitAt(HexPoint pt)
{
foreach (Unit u in _units)
if (u.Point == pt)
return u;
return null;
}
public MapControllingArgs(MapData map, HexPoint point, int controller)
{
_map = map;
_tile = point;
_controller = controller;
}
public MapSpottingArgs(MapData map, HexPoint point, bool spotting)
{
_map = map;
_tile = point;
_spotting = spotting;
}
public City(Point2D point, Color color, HexPoint location)
: base(point, color)
{
Location = location;
Init();
}
private bool HasNearPointOrSelf(List<HexPoint> checkList, HexPoint pointToCheck)
{
// Check if the list contains the point
if (checkList.Contains(pointToCheck)) return true;
// Check if the list contains any of the neightbours
List<HexPoint> neighbours = pointToCheck.GetNeighbours();
if (neighbours.Count != 3) Console.WriteLine("whoa");
foreach (HexPoint neighbour in neighbours)
if (checkList.Contains(neighbour)) return true;
// Nope! the list doesnt contains the point or any of its neighbours
return false;
}
public void AddCity(HexPoint point)
{
// check if this is really possible (controlled by must be -1 or Id)
if (Map[point].ControlledBy != -1 && Map[point].ControlledBy != Id)
throw new Exception("This should not have happend, cities can only be build on tiles that are free or controlled by yourself");
if (!Map[point].Improvements.Contains(road))
Map[point].Improvements.Add(road);
string cityName = GetNextCityName();
City c = new City(point, cityName, this);
c.IsCapital = _cities.Count == 0;
GameFacade.getInstance().SendNotification(
GameNotification.Message,
NotificationType.FoundCity,
string.Format(Strings.TXT_KEY_NOTIFICATION_FOUND_CITY, c.Player.Leader.Title, c.Name),
Civilization,
MessageFilter.Self | MessageFilter.Friends,
c);
c.CityGrowth += delegate(City city, int from, int to)
{
GameFacade.getInstance().SendNotification(
GameNotification.Message,
NotificationType.CityGrowth,
string.Format(Strings.TXT_KEY_NOTIFICATION_CITY_GREW, city.Name, c.Player.Leader.Title, to),
city.Player.Civilization,
MessageFilter.Friends | MessageFilter.Self,
city);
};
c.CityDecline += delegate(City city, int from, int to)
{
GameFacade.getInstance().SendNotification(
GameNotification.Message,
NotificationType.CityDecline,
string.Format(Strings.TXT_KEY_NOTIFICATION_CITY_DECLINE, city.Name, c.Player.Leader.Title, to),
city.Player.Civilization,
MessageFilter.Friends | MessageFilter.Self,
city);
};
c.CityBuild += delegate(City city, Building building)
{
GameFacade.getInstance().SendNotification(
GameNotification.Message,
NotificationType.ProducationReady,
string.Format(Strings.TXT_KEY_NOTIFICATION_CITY_BUILDING, city.Name, c.Player.Leader.Title, building.Title),
city.Player.Civilization,
MessageFilter.Self,
city);
};
c.UnitBuild += delegate(City city, UnitData unit)
{
GameFacade.getInstance().SendNotification(
GameNotification.Message,
NotificationType.ProducationReady,
string.Format(Strings.TXT_KEY_NOTIFICATION_CITY_UNIT, city.Name, c.Player.Leader.Title, unit.Title),
city.Player.Civilization,
MessageFilter.Self,
city);
};
Map.SetControlled(point, Id, false, 1);
_cities.Add(c);
}
public void CenterAt(HexPoint loc)
{
if (Map != null && Map.IsValid(loc))
{
_mapCenter.X = loc.X;
_mapCenter.Y = loc.Y;
_camera.Target = MapData.GetWorldPosition(_mapCenter);
_mapRenderer.Center = _mapCenter;
}
}
private void HandleMouse()
{
MouseState mouseState = Mouse.GetState();
if (mouseState.ScrollWheelValue > _oldMouseState.ScrollWheelValue)
ZoomIn();
else if (mouseState.ScrollWheelValue < _oldMouseState.ScrollWheelValue)
ZoomOut();
if (mouseState.RightButton == ButtonState.Released && _oldMouseState.RightButton == ButtonState.Pressed)
{
City city = MainWindow.Game.GetCityAt(_mapRenderer.Cursor);
// select unit city
if (city != null)
{
if (CityOpened != null)
CityOpened(city);
}
}
else if (mouseState.LeftButton == ButtonState.Pressed && _oldMouseState.LeftButton == ButtonState.Released)
{
_dragStart = _mapRenderer.Cursor;
}
else if (mouseState.LeftButton == ButtonState.Released && _oldMouseState.LeftButton == ButtonState.Pressed)
{
if (_dragStart != _mapRenderer.Cursor)
{
// drag action
Unit unit = MainWindow.Game.GetUnitAt(_dragStart);
if (unit != null)
{
unit.Action = UnitAction.Move;
unit.SetTarget(_mapRenderer.Cursor);
}
}
else
{
Unit unit = MainWindow.Game.GetUnitAt(_mapRenderer.Cursor);
// select unit
if (unit != null)
{
if (unit.Player.IsHuman && HumanUnitsSelected != null)
HumanUnitsSelected(unit);
else if (!unit.Player.IsHuman && EnemyUnitsSelected != null)
EnemyUnitsSelected(unit);
}
else if (UnitsUnselected != null)
UnitsUnselected();
}
}
_oldMouseState = mouseState;
}
/// <summary>
/// Constructs a new movdelvisual with appropriate positions marked where
/// players can build
/// </summary>
/// <param name="b"></param>
public BuildPlaces(BoardVisual b)
{
// Pseudo:
//
// By only checking the 4 points on the right (top, top right,
// lower right, center bottom) points, we can cover the whole
// board if we just iterate over the hexes in uneven rows
//
// 1. Iterate through all hexes in uneven rows
// 2. Add top center buildpoint, if appropriate
// 2a. skip the first hex in a row
// 3. Add top right buildpoint, if appropriate
// 3a. skip last hex in a row
// 4. Add lower right buildpoint, if appropriate
// 4a. skip last hex on the row
// 4b. Skip if hex is on last row
// 5. Add center bottom buildpoint, if appropriate
// 5a. skip last hex on the row
// 5b. Skip if hex is on last row
foreach (Hex h in b.Board.Hexes)
{
//NoneHexes should not get any build point, so skip them
//We are only going to iterate over even rows
if (!(h is NoneHex) && (h.Location.H % 2 != 0))
{
//x offset for positioning the visuals correctly
double offsetx = -(b.Board.Width * Hex.Width) / 2;
//y offset for positioning the visuals correctly
double offsety = -((b.Board.Height * Hex.PartialHeight) + Hex.BottomHeight) / 2;
if (h.Location.W != Hex.Width - 1) //omit last hex in row
{
//0 (point at the top of a hex
if (h.Location.W != 0 && // skip if first hex in the row
CanBuild(b.Board.Hexes[h.Location.W - 1, h.Location.H - 1]) &&
CanBuild(b.Board.Hexes[h.Location.W, h.Location.H - 1]))
{
//when all three sea hexes, there is no possibility to build
if (!(b.Game.Board.Hexes[h.Location.W - 1, h.Location.H - 1] is SeaHex &&
b.Game.Board.Hexes[h.Location.W, h.Location.H - 1] is SeaHex &&
h is SeaHex))
{
HexPoint hexPoint = new HexPoint(h.Location, EPointPositionOnHex.TopMiddle);
Point2D point = b.CalculatePosition(hexPoint);
Children.Add(new BuildPointVisual(point, hexPoint));
}
}
// 1 point at the right top
if (h.Location.W != b.Game.Board.Width - 1 && //skip if last hex in a row
CanBuild(b.Board.Hexes[h.Location.W, h.Location.H - 1]) &&
CanBuild(b.Board.Hexes[h.Location.W + 1, h.Location.H]))
{
//when all three sea hexes, there is no possibility to build
if (!(b.Board.Hexes[h.Location.W, h.Location.H - 1] is SeaHex &&
b.Board.Hexes[h.Location.W + 1, h.Location.H] is SeaHex &&
h is SeaHex))
{
HexPoint hexPoint = new HexPoint(h.Location, EPointPositionOnHex.RightTop);
Point2D point = b.CalculatePosition(hexPoint);
Children.Add(new BuildPointVisual(point, hexPoint));
}
}
if (h.Location.H != Hex.Height - 1) //skip if hex is on last row
{
// 2 point at the right lower position
if (h.Location.W != b.Board.Width - 1 && //skip if last hex in a row (last column)
h.Location.H != b.Board.Height - 1 && //skip if hex is on last row
CanBuild(b.Board.Hexes[h.Location.W + 1, h.Location.H]) &&
CanBuild(b.Board.Hexes[h.Location.W, h.Location.H + 1]))
{
//when all three sea hexes, there is no possibility to build
if (!(b.Board.Hexes[h.Location.W + 1, h.Location.H] is SeaHex &&
b.Board.Hexes[h.Location.W, h.Location.H + 1] is SeaHex &&
h is SeaHex))
{
HexPoint hexPoint = new HexPoint(h.Location, EPointPositionOnHex.RightBottom);
Point2D point = b.CalculatePosition(hexPoint);
Children.Add(new BuildPointVisual(point, hexPoint));
}
}
// 3 point at the bottom
if (h.Location.H != b.Game.Board.Height - 1 && //skip if hex is on last row
h.Location.W != 0 && //skip if first in a row
CanBuild(b.Board.Hexes[h.Location.W, h.Location.H + 1]) &&
CanBuild(b.Board.Hexes[h.Location.W - 1, h.Location.H + 1]))
{
//when all three sea hexes, there is no possibility to build
if (!(b.Board.Hexes[h.Location.W, h.Location.H + 1] is SeaHex &&
b.Board.Hexes[h.Location.W - 1, h.Location.H + 1] is SeaHex &&
h is SeaHex))
{
HexPoint hexPoint = new HexPoint(h.Location, EPointPositionOnHex.BottomMiddle);
Point2D point = b.CalculatePosition(hexPoint);
Children.Add(new BuildPointVisual(point, hexPoint));
}
}
}
}
}
}
}
public bool IsInside(HexPoint pt)
{
return IsInside(pt.X, pt.Y);
}
private void SetUpWaterVertices()
{
float terrainWidth = 200f;
float terrainLength = 200f;
if (MainWindow.Game.Map != null)
{
HexPoint topLeft = new HexPoint(0, 0);
HexPoint bottomRight = new HexPoint(MainWindow.Game.Map.Width, MainWindow.Game.Map.Height);
Vector3 topLeftPt = MapData.GetWorldPosition(topLeft);
Vector3 bottomRightPt = MapData.GetWorldPosition(bottomRight);
terrainWidth = Math.Max( topLeftPt.X, bottomRightPt.X ) + 5f;
terrainLength = Math.Max(topLeftPt.Z, bottomRightPt.Z) + 5f;
}
VertexPositionNormalTexture[] waterVertices = new VertexPositionNormalTexture[6];
waterVertices[0] = new VertexPositionNormalTexture(new Vector3(0, waterHeight - 1f, 0), Vector3.Up, new Vector2(0, 1));
waterVertices[2] = new VertexPositionNormalTexture(new Vector3(terrainWidth, waterHeight - 1f, terrainLength), Vector3.Up, new Vector2(1, 0));
waterVertices[1] = new VertexPositionNormalTexture(new Vector3(0, waterHeight - 1f, terrainLength), Vector3.Up, new Vector2(0, 0));
waterVertices[3] = new VertexPositionNormalTexture(new Vector3(0, waterHeight - 1f, 0), Vector3.Up, new Vector2(0, 1));
waterVertices[5] = new VertexPositionNormalTexture(new Vector3(terrainWidth, waterHeight - 1f, 0), Vector3.Up, new Vector2(1, 1));
waterVertices[4] = new VertexPositionNormalTexture(new Vector3(terrainWidth, waterHeight - 1f, terrainLength), Vector3.Up, new Vector2(1, 0));
waterVertexBuffer = new VertexBuffer(_dDevice, VertexPositionNormalTexture.VertexDeclaration, waterVertices.Length, BufferUsage.WriteOnly);
waterVertexBuffer.SetData(waterVertices);
short[] waterIndexData = new short[6];
waterIndexData[0] = 0;
waterIndexData[1] = 1;
waterIndexData[2] = 2;
waterIndexData[3] = 3;
waterIndexData[4] = 4;
waterIndexData[5] = 5;
_waterIndexBuffer = new IndexBuffer(_dDevice, typeof(short), 6, BufferUsage.WriteOnly);
_waterIndexBuffer.SetData(waterIndexData);
}
public HexPoint CreatePoint(EPointPositionOnHex position, HexLocation location)
{
int w = location.W;
int h = location.H;
HexPoint result = new HexPoint();
switch (position)
{
case EPointPositionOnHex.TopMiddle:
result.Hex1 = new HexLocation(w - 1, h - 1);
result.Hex2 = new HexLocation(w, h - 1);
result.Hex3 = new HexLocation(w, h);
break;
case EPointPositionOnHex.RightTop:
result.Hex1 = new HexLocation(w, h - 1);
result.Hex2 = new HexLocation(w, h);
result.Hex3 = new HexLocation(w + 1, h);
break;
case EPointPositionOnHex.RightBottom:
result.Hex1 = new HexLocation(w, h);
result.Hex2 = new HexLocation(w + 1, h);
result.Hex3 = new HexLocation(w, h + 1);
break;
case EPointPositionOnHex.BottomMiddle:
result.Hex1 = new HexLocation(w, h);
result.Hex2 = new HexLocation(w - 1, h + 1);
result.Hex3 = new HexLocation(w, h + 1);
break;
}
return result;
}
private void UpdateInfluenceMaps()
{
//if (IsHuman)
// return;
if (Map == null)
return;
if (CityLocationMap == null)
{
CityLocationMap = new InfluenceMap(Map.Width, Map.Height);
ImprovementLocationMap = new InfluenceMap(Map.Width, Map.Height);
FriendsInfluence = new InfluenceMap(Map.Width, Map.Height);
EnemyInfluence = new InfluenceMap(Map.Width, Map.Height);
}
for (int x = 0; x < Map.Width; ++x)
{
for (int y = 0; y < Map.Height; ++y)
{
HexPoint pt = new HexPoint(x, y);
#region city found map
MapCell cell = Map[x, y];
if (cell.IsSpotted(this))
{
float value = Map.GetValue(x, y, MapValueType.CityFoundValue);
CityLocationMap[x, y] = value;
ImprovementLocationMap[x, y] = value;
if (_cities.Count == 0)
{
int dist = HexPoint.GetDistance(pt, StartLocation);
if (dist < 2)
CityLocationMap[x, y] += 2;
if (dist < 1)
CityLocationMap[x, y] += 2;
}
if (GetCityAt(pt) != null)
{
CityLocationMap[pt] = 0;
ImprovementLocationMap[pt] = 0;
}
foreach (HexPoint n in pt.Neighbors)
{
if (GetCityAt(n) != null)
{
CityLocationMap[pt] = 0;
ImprovementLocationMap[x, y] *= 1.7f;
}
}
}
else
CityLocationMap[x, y] = 0;
#endregion city found map
}
}
foreach(Unit unit in _units)
FriendsInfluence.Apply(unit.Point, unit.Strength);
//foreach(Unit enemyUnit in _unitsInSight)
//{
//}
_needToUpdateInfluenceMaps = false;
}
void unit_Moved(Unit sender, HexPoint oldPosition, HexPoint newPosition)
{
_needToUpdateInfluenceMaps = true;
}
/// <summary>
/// Calculates a path from start to end. When no path can be found in
/// reasonable time the search is aborted and an incomplete path is returned.
/// When refresh is not set to true a cached path is returned where possible.
/// </summary>
/// <param name="start">start position in 2d map space</param>
/// <param name="end">end position in 2d map space</param>
/// <param name="refresh">force to recalculate the path</param>
/// <returns></returns>
public Path CalculatePath(Unit unit, HexPoint start, HexPoint end, bool refresh = false)
{
// swap points to calculate the path backwards (from end to start)
HexPoint temp = end;
end = start;
start = temp;
// Check whether the requested path is already known
PathRequest request = new PathRequest(unit,start, end);
if (!refresh && knownPaths.ContainsKey(request))
{
return knownPaths[request].Copy();
}
// priority queue of nodes that yet have to be explored sorted in
// ascending order by node costs (F)
PriorityQueue<PathNode> open = new PriorityQueue<PathNode>();
// list of nodes that have already been explored
LinkedList<IGridCell> closed = new LinkedList<IGridCell>();
// start is to be explored first
PathNode startNode = new PathNode(unit,null, map[start], end);
open.Enqueue(startNode);
int steps = 0;
PathNode current;
do
{
// abort if calculation is too expensive
if (++steps > stepLimit) return null;
// examine the cheapest node among the yet to be explored
current = open.Dequeue();
// Finish?
if (current.Cell.Matches(end))
{
// paths which lead to the requested goal are cached for reuse
Path path = new Path(current);
if (knownPaths.ContainsKey(request))
{
knownPaths[request] = path.Copy();
}
else
{
knownPaths.Add(request, path.Copy());
}
return path;
}
// Explore all neighbours of the current cell
ICollection<IGridCell> neighbours = map.GetNeighbourCells(current.Cell);
foreach (IGridCell cell in neighbours)
{
// discard nodes that are not of interest
if (closed.Contains(cell) || (cell.Matches(end) == false && !cell.IsWalkable(unit)))
{
continue;
}
// successor is one of current's neighbours
PathNode successor = new PathNode(unit,current, cell, end);
PathNode contained = open.Find(successor);
if (contained != null && successor.F >= contained.F)
{
// This cell is already in the open list represented by
// another node that is cheaper
continue;
}
else if (contained != null && successor.F < contained.F)
{
// This cell is already in the open list but on a more expensive
// path -> "integrate" the node into the current path
contained.Predecessor = current;
contained.Update();
open.Update(contained);
}
else
{
// The cell is not in the open list and therefore still has to
// be explored
open.Enqueue(successor);
}
}
// add current to the list of the already explored nodes
closed.AddLast(current.Cell);
} while (open.Peek() != null);
return null;
}
public PathRequest(Unit unit, HexPoint start, HexPoint end)
{
data = unit.Data;
this.start = start;
this.end = end;
}
private bool IsAllSea(HexPoint point, XmlBoard board)
{
return false;
/*
if (board.Hexes[point.Hex1] is SeaHex &&
board.Hexes[point.Hex2] is SeaHex &&
board.Hexes[point.Hex3] is SeaHex)
return true;
else
return false;
*/
}
