/// <summary>
/// Creates a PropertyOrder that comes after the passed in token.
/// </summary>
/// <param name="reference">The reference token</param>
/// <returns>The new PropertyOrder</returns>
/// <exception cref="ArgumentNullException">When reference is null</exception>
public static PropertyOrder CreateAfter(OrderToken reference)
{
if (reference == null)
throw FxTrace.Exception.ArgumentNull("reference");
return new PropertyOrder(OrderTokenPrecedence.After, reference, OrderTokenConflictResolution.Lose);
}
private static bool IsOrderTokenValid(OrderToken orderToken)
{
var isValid = orderToken != null &&
!string.IsNullOrWhiteSpace(orderToken.Email) &&
!string.IsNullOrWhiteSpace(orderToken.OrderNumber);
return(isValid);
}
/// <summary>
/// Creates a PropertyOrder that comes after the passed in token.
/// </summary>
/// <param name="reference">The reference token</param>
/// <returns>The new PropertyOrder</returns>
/// <exception cref="ArgumentNullException">When reference is null</exception>
public static PropertyOrder CreateAfter(OrderToken reference)
{
if (reference == null)
{
throw FxTrace.Exception.ArgumentNull("reference");
}
return(new PropertyOrder(OrderTokenPrecedence.After, reference, OrderTokenConflictResolution.Lose));
}
public SeaTerritory(string name, int numShips, House houseOccupied, bool isOccupied, OrderToken orderToken, List<string> landConnections, List<string> seaConnections)
{
this.name = name;
this.numShips = numShips;
this.houseOccupied = houseOccupied;
this.orderToken = orderToken;
this.landConnections = landConnections;
this.seaConnections = seaConnections;
this.isOccupied = isOccupied;
}
public void WHEN_token_is_null_SHOULD_throw_ArgumentNullException()
{
//Arrange
OrderToken param = null;
//Act
var ex = Assert.Throws <ArgumentNullException>(() => GuestOrderTokenizer.GenerateOrderToken(param));
//Assert
ex.Should().NotBeNull();
ex.ParamName.Should().NotBeNullOrWhiteSpace();
}
public bool Equals(OrderToken orderToken)
{
bool returnBool = false;
if(orderToken is ConsolidatePower)
{
ConsolidatePower consolidatePower = (ConsolidatePower)orderToken;
if (consolidatePower.getStar() == this.getStar())
{
returnBool = true;
}
}
return returnBool;
}
public bool Equals(OrderToken orderToken)
{
bool returnBool = false;
if (orderToken is RaidOrder)
{
RaidOrder raidOrder = (RaidOrder)orderToken;
if (raidOrder.getStar() == this.getStar())
{
returnBool = true;
}
}
return returnBool;
}
public bool Equals(OrderToken orderToken)
{
bool returnBool = false;
if (orderToken is MarchOrder)
{
MarchOrder marchOrder = (MarchOrder)orderToken;
if (marchOrder.getStar() == this.getStar() && marchOrder.getNegToken() == this.getNegToken() && marchOrder.getZeroToken() == this.getZeroToken())
{
returnBool = true;
}
}
return returnBool;
}
public bool Equals(OrderToken orderToken)
{
bool returnBool = false;
if (orderToken is SupportOrder)
{
SupportOrder supportOrder = (SupportOrder)orderToken;
if (this.getStar() == supportOrder.getStar())
{
returnBool = true;
}
}
return returnBool;
}
public override int Compare(PropertyEntry x, PropertyEntry y)
{
SceneNodeProperty sceneNodeProperty1 = (SceneNodeProperty)x;
SceneNodeProperty sceneNodeProperty2 = (SceneNodeProperty)y;
PropertyOrder propertyOrder1 = (PropertyOrder)sceneNodeProperty1.PropertyOrder;
PropertyOrder propertyOrder2 = (PropertyOrder)sceneNodeProperty2.PropertyOrder;
int num = !OrderToken.op_Equality((OrderToken)propertyOrder1, (OrderToken)propertyOrder2) ? ((OrderToken)propertyOrder1).CompareTo((OrderToken)propertyOrder2) : 0;
if (num != 0)
{
return(num);
}
return(x.get_PropertyName().CompareTo(y.get_PropertyName()));
}
public bool Equals(OrderToken orderToken)
{
bool returnBool = false;
if (orderToken is DefenseOrder)
{
DefenseOrder defenseOrder = (DefenseOrder)orderToken;
if (defenseOrder.getStar() == this.getStar())
{
returnBool = true;
}
}
return returnBool;
}
public void WHEN_token_ok_SHOULD_return_encrypted_token()
{
//Arrange
var param = new OrderToken
{
Email = GetRandom.Email(),
OrderNumber = GetRandom.String(6)
};
//Act
var token = GuestOrderTokenizer.GenerateOrderToken(param);
//Assert
token.Should().NotBeNullOrWhiteSpace();
token.Should().NotContainEquivalentOf(param.Email);
token.Should().NotContainEquivalentOf(param.OrderNumber);
}
public LandTerritory(string name, int numSupply, int numCrowns, int numInfantry, int numKnight, int numSiegeEngine,
bool hasCastle, bool hasStronghold, bool isOccupied, House houseOccupied, OrderToken orderToken, Button button, List<string> connections)
{
this.name = name;
this.numSupply = numSupply;
this.numCrowns = numCrowns;
this.hasCastle = hasCastle;
this.hasStronghold = hasStronghold;
this.numInfantry = numInfantry;
this.numKnight = numKnight;
this.isOccupied = isOccupied;
this.numSiegeEngine = numSiegeEngine;
this.houseOccupied = houseOccupied;
this.orderToken = orderToken;
this.connections = connections;
this.button = button;
}
public void WHEN_orderNumber_is_invalid_SHOULD_throw_ArgumentNullException(string orderNumber)
{
//Arrange
OrderToken param = new OrderToken
{
Email = GetRandom.Email(),
OrderNumber = orderNumber
};
//Act
var ex = Assert.Throws <ArgumentException>(() => GuestOrderTokenizer.GenerateOrderToken(param));
//Assert
ex.Should().NotBeNull();
ex.ParamName.Should().NotBeNullOrWhiteSpace();
ex.Message.Should().NotBeNullOrWhiteSpace();
}
public void WHEN_token_is_valid_SHOULD_return_dto()
{
//Arrange
var param = new OrderToken
{
Email = GetRandom.Email(),
OrderNumber = GetRandom.String(7)
};
var token = GuestOrderTokenizer.GenerateOrderToken(param);
//Act
var dto = GuestOrderTokenizer.DecypherOrderToken(token);
//Assert
dto.Should().NotBeNull();
dto.Email.Should().NotBeNullOrWhiteSpace();
dto.Email.Should().Be(param.Email);
dto.OrderNumber.Should().Be(param.OrderNumber);
}
/* Not used on gamelogic level
*
* --Missing--
* Notify player hand class when this happens.
* */
public void ReturnOrderToken(OrderToken ot)
{
UnusedOrderTokens.Add(ot);
}
private AdornerOrder(OrderTokenPrecedence precedence, OrderToken reference, OrderTokenConflictResolution conflictResolution)
: base(precedence, reference, conflictResolution)
{
}
private PropertyOrder(OrderTokenPrecedence precedence, OrderToken reference, OrderTokenConflictResolution conflictResolution)
: base(precedence, reference, conflictResolution)
{
}
protected override int ResolveConflict(OrderToken left, OrderToken right)
{
return(0);
}
/* Used on gamelogic level
* Return an order token from a territory to the players hand
* */
public void ReturnOrderTokenFromTerritory(Territory T, OrderToken ot)
{
T.RemoveOrderToken(ot);
ReturnOrderToken(ot);
}
public string territoryTextToString(string name, int infantry, int knights, int siegeEngine, OrderToken order, LandTerritory land)
{
string returnString = name + "- ";
if (infantry > 0)
{
returnString += " F: " + infantry;
}
if (knights > 0)
{
returnString += " K: " + knights;
}
if (siegeEngine > 0)
{
returnString += " SE: " + siegeEngine;
}
returnString += order.toString();
return returnString;
}
/* Used on gamelogic level
* Place an order token on a territory from the players hand
* */
public void PlaceOrderTokenOnTerritory(Territory T, OrderToken ot)
{
T.PlaceOrderToken(ot);
PlaceOrderToken(ot);
}
/// <summary>
/// Treat equal orders as equal
/// </summary>
/// <param name="left">Left token</param>
/// <param name="right">Right token</param>
/// <returns>0</returns>
protected override int ResolveConflict(OrderToken left, OrderToken right) {
return 0;
}
/// <summary>
/// Creates a PropertyOrder.
/// </summary>
/// <param name="precedence">Precedence of this token based on the
/// referenced token.</param>
/// <param name="reference">Referenced token.</param>
/// <param name="conflictResolution">Conflict resolution semantics.
/// Winning ConflictResultion semantic should only be used
/// on predefined, default OrderToken instances to ensure
/// their correct placement in more complex chain of order
/// dependencies.</param>
private PropertyOrder(OrderTokenPrecedence precedence, OrderToken reference, OrderTokenConflictResolution conflictResolution)
: base(precedence, reference, conflictResolution) {
}
protected void RenderOrderToken(OrderToken ot)
{
Destroy(RenderedOrderToken);
RenderedOrderToken = new GameObject();
RenderedOrderToken.name = "OrderToken";
RenderedOrderToken.AddComponent<Rigidbody>();
RenderedOrderToken.GetComponent<Rigidbody>().useGravity = false;
RenderedOrderToken.AddComponent<MeshRenderer>();
RenderedOrderToken.GetComponent<Renderer>().receiveShadows = true;
RenderedOrderToken.AddComponent<MeshFilter>();
RenderedOrderToken.GetComponent<MeshFilter>().sharedMesh = (Mesh)((GameObject)Resources.Load("Graphics/Models/Other/OrderToken")).GetComponent<MeshFilter>().sharedMesh;
string MaterialLoad = "Graphics/OrderTokenMaterials/";
if (myTerritory.Owner.HouseCharacter == HouseCharacter.Baratheon)
{
MaterialLoad = MaterialLoad + "BaratheonOrder";
}
else if (myTerritory.Owner.HouseCharacter == HouseCharacter.Greyjoy)
{
MaterialLoad = MaterialLoad + "GreyjoyOrder";
}
else if (myTerritory.Owner.HouseCharacter == HouseCharacter.Lannister)
{
MaterialLoad = MaterialLoad + "LannisterOrder";
}
else if (myTerritory.Owner.HouseCharacter == HouseCharacter.Martell)
{
MaterialLoad = MaterialLoad + "MartellOrder";
}
else if (myTerritory.Owner.HouseCharacter == HouseCharacter.Stark)
{
MaterialLoad = MaterialLoad + "StarkOrder";
}
else if (myTerritory.Owner.HouseCharacter == HouseCharacter.Tyrell)
{
MaterialLoad = MaterialLoad + "TyrellOrder";
}
if (myTerritory.Owner.HouseCharacter == GameBase.myHouse.HouseCharacter)
{
MaterialLoad = "Graphics/OrderTokenMaterials/";
if (myTerritory.PlacedOrderToken.Type == OrderTokenType.ConsolidatePowerOrder && myTerritory.PlacedOrderToken.Strenght == OrderTokenStrenght.Normal)
{
MaterialLoad = MaterialLoad + "Consolidate";
}
else if (myTerritory.PlacedOrderToken.Type == OrderTokenType.ConsolidatePowerOrder && myTerritory.PlacedOrderToken.Strenght == OrderTokenStrenght.Star)
{
MaterialLoad = MaterialLoad + "ConsolidateP";
}
else if (myTerritory.PlacedOrderToken.Type == OrderTokenType.DefendOrder && myTerritory.PlacedOrderToken.Strenght == OrderTokenStrenght.Normal)
{
MaterialLoad = MaterialLoad + "Defense";
}
else if (myTerritory.PlacedOrderToken.Type == OrderTokenType.DefendOrder && myTerritory.PlacedOrderToken.Strenght == OrderTokenStrenght.Star)
{
MaterialLoad = MaterialLoad + "DefenseP";
}
else if (myTerritory.PlacedOrderToken.Type == OrderTokenType.MoveOrder && myTerritory.PlacedOrderToken.Strenght == OrderTokenStrenght.MinusOne)
{
MaterialLoad = MaterialLoad + "MarchM";
}
else if (myTerritory.PlacedOrderToken.Type == OrderTokenType.MoveOrder && myTerritory.PlacedOrderToken.Strenght == OrderTokenStrenght.Normal)
{
MaterialLoad = MaterialLoad + "March";
}
else if (myTerritory.PlacedOrderToken.Type == OrderTokenType.MoveOrder && myTerritory.PlacedOrderToken.Strenght == OrderTokenStrenght.Star)
{
MaterialLoad = MaterialLoad + "MarchP";
}
else if (myTerritory.PlacedOrderToken.Type == OrderTokenType.RaidOrder && myTerritory.PlacedOrderToken.Strenght == OrderTokenStrenght.Normal)
{
MaterialLoad = MaterialLoad + "Raid";
}
else if (myTerritory.PlacedOrderToken.Type == OrderTokenType.RaidOrder && myTerritory.PlacedOrderToken.Strenght == OrderTokenStrenght.Star)
{
MaterialLoad = MaterialLoad + "RaidP";
}
else if (myTerritory.PlacedOrderToken.Type == OrderTokenType.SupportOrder && myTerritory.PlacedOrderToken.Strenght == OrderTokenStrenght.Normal)
{
MaterialLoad = MaterialLoad + "Support";
}
else if (myTerritory.PlacedOrderToken.Type == OrderTokenType.SupportOrder && myTerritory.PlacedOrderToken.Strenght == OrderTokenStrenght.Star)
{
MaterialLoad = MaterialLoad + "SupportP";
}
}
RenderedOrderToken.GetComponent<Renderer>().material = (Material)Resources.Load(MaterialLoad);
RenderedOrderToken.transform.localScale = new Vector3((float)0.5, (float)0.5, (float)0.5);
RenderedOrderToken.transform.position = OrderTokenPos;
RenderedOrderToken.transform.rotation = Quaternion.Euler(270, 0, 0);
}
/* Create order tokens when the game is initiated. */
private static List<OrderToken> CreateOrderTokens(House h)
{
List<OrderToken> Tokens = new List<OrderToken>();
//MoveOrders
OrderToken Token_A_Star = new OrderToken(h, OrderTokenType.MoveOrder, OrderTokenStrenght.Star);
Tokens.Add(Token_A_Star);
OrderToken Token_A_Norm = new OrderToken(h, OrderTokenType.MoveOrder, OrderTokenStrenght.Normal);
Tokens.Add(Token_A_Norm);
OrderToken Token_A_Minus = new OrderToken(h, OrderTokenType.MoveOrder, OrderTokenStrenght.MinusOne);
Tokens.Add(Token_A_Minus);
//SupportOrders
OrderToken Token_S_Star = new OrderToken(h, OrderTokenType.SupportOrder, OrderTokenStrenght.Star);
Tokens.Add(Token_S_Star);
OrderToken Token_S_Norm1 = new OrderToken(h, OrderTokenType.SupportOrder, OrderTokenStrenght.Normal);
Tokens.Add(Token_S_Norm1);
OrderToken Token_S_Norm2 = new OrderToken(h, OrderTokenType.SupportOrder, OrderTokenStrenght.Normal);
Tokens.Add(Token_S_Norm2);
//DefenseOrders
OrderToken Token_D_Star = new OrderToken(h, OrderTokenType.DefendOrder, OrderTokenStrenght.Star);
Tokens.Add(Token_D_Star);
OrderToken Token_D_Norm1 = new OrderToken(h, OrderTokenType.DefendOrder, OrderTokenStrenght.Normal);
Tokens.Add(Token_D_Norm1);
OrderToken Token_D_Norm2 = new OrderToken(h, OrderTokenType.DefendOrder, OrderTokenStrenght.Normal);
Tokens.Add(Token_D_Norm2);
//RaidOrders
OrderToken Token_R_Star = new OrderToken(h, OrderTokenType.RaidOrder, OrderTokenStrenght.Star);
Tokens.Add(Token_R_Star);
OrderToken Token_R_Norm1 = new OrderToken(h, OrderTokenType.RaidOrder, OrderTokenStrenght.Normal);
Tokens.Add(Token_R_Norm1);
OrderToken Token_R_Norm2 = new OrderToken(h, OrderTokenType.RaidOrder, OrderTokenStrenght.Normal);
Tokens.Add(Token_R_Norm2);
//ConsolidatePower
OrderToken Token_C_Star = new OrderToken(h, OrderTokenType.ConsolidatePowerOrder, OrderTokenStrenght.Star);
Tokens.Add(Token_C_Star);
OrderToken Token_C_Norm1 = new OrderToken(h, OrderTokenType.ConsolidatePowerOrder, OrderTokenStrenght.Normal);
Tokens.Add(Token_C_Norm1);
OrderToken Token_C_Norm2 = new OrderToken(h, OrderTokenType.ConsolidatePowerOrder, OrderTokenStrenght.Normal);
Tokens.Add(Token_C_Norm2);
return Tokens;
}
public void setOrderToken(OrderToken orderToken)
{
this.orderToken = orderToken;
}
public bool Equals(OrderToken orderToken)
{
return true;
}
/* Not used on gamelogic level
*
* --Missing--
* Notify player hand class when this happens.
* */
public void PlaceOrderToken(OrderToken ot)
{
UnusedOrderTokens.Remove(ot);
}
public string territoryTextToString(string name, int numShips, OrderToken order, SeaTerritory sea)
{
string returnString = name + "- ";
if (numShips > 0)
{
returnString += " S: " + numShips;
}
returnString += order.toString();
return returnString;
}
