private static void ArgumentCheck(Side side, int m, int n, int k, int ilo, int ihi, Object A, int lda, Object tau, Object C, int ldc) {
if ( A == null ) {
throw new ArgumentNullException("A","A cannot be null.");
}
if ( tau == null ) {
throw new ArgumentNullException("tau","tau cannot be null.");
}
if ( C == null ) {
throw new ArgumentNullException("C","C cannot be null.");
}
if ( m<0 ) {
throw new ArgumentException("m must be at least zero.", "m");
}
if ( n<0 ) {
throw new ArgumentException("n must be at least zero.", "n");
}
if( side == Side.Left ){
if( k < 0 || k > m ){
throw new ArgumentException("k must be positive and less than or equal to m.", "k");
}
if (m>0) {
if (ilo<1 || ilo>m || ilo>ihi)
throw new ArgumentException("ilo must be a positive number and less than or equal to min(ihi,m) if m>0", "ilo");
if (ihi<1 || ihi>m)
throw new ArgumentException("ihi must be between 1 and m if m>0", "ihi");
} else {
if (ilo!=1)
throw new ArgumentException("ilo must be 1 if m=0", "ilo");
if (ihi!=0)
throw new ArgumentException("ihi must be 0 if m=0", "ihi");
}
}else{
if( k < 0 || k > n ){
throw new ArgumentException("k must be positive and less than or equal to n.", "k");
}
if (n>0) {
if (ilo<1 || ilo>n || ilo>ihi)
throw new ArgumentException("ilo must be a positive number and less than or equal to min(ihi,n) if n>0", "ilo");
if (ihi<1 || ihi>n)
throw new ArgumentException("ihi must be a positive number and less than or equal to n if n>0", "ihi");
} else {
if (ilo!=1)
throw new ArgumentException("ilo must be 1 if n=0", "ilo");
if (ihi!=0)
throw new ArgumentException("ihi must be 0 if n=0", "ihi");
}
}
if( side == Side.Left ){
if ( lda < System.Math.Max(1,m) ) {
throw new ArgumentException("lda must be at least max(1,m)", "lda");
}
}else{
if ( lda < System.Math.Max(1,n) ) {
throw new ArgumentException("lda must be at least max(1,n)", "lda");
}
}
if ( ldc < System.Math.Max(1,m) ) {
throw new ArgumentException("ldc must be at least max(1,m)", "ldc");
}
}
public EdgeNGramTokenFilter(LuceneVersion version, TokenStream input, Side side, int minGram, int maxGram)
: base(input)
{
if (version == null)
{
throw new System.ArgumentException("version must not be null");
}
if (version.OnOrAfter(LuceneVersion.LUCENE_44) && side == Side.BACK)
{
throw new System.ArgumentException("Side.BACK is not supported anymore as of Lucene 4.4, use ReverseStringFilter up-front and afterward");
}
if (side == null)
{
throw new System.ArgumentException("sideLabel must be either front or back");
}
if (minGram < 1)
{
throw new System.ArgumentException("minGram must be greater than zero");
}
if (minGram > maxGram)
{
throw new System.ArgumentException("minGram must not be greater than maxGram");
}
this.version = version;
this.charUtils = version.onOrAfter(LuceneVersion.LUCENE_44) ? CharacterUtils.getInstance(version) : CharacterUtils.Java4Instance;
this.minGram = minGram;
this.maxGram = maxGram;
this.side = side;
}
public static Side RotateSide(Side side, int steps)
{
int index = Array.IndexOf(allSides, side);
index += steps;
index = Mathf.CeilToInt(Mathf.Repeat(index, allSides.Length));
return allSides[index];
}
public Gear(String _Classname, int _UpgradeLevel, int _Price, Side _Side)
{
Classname = _Classname;
UpgradeLevel = _UpgradeLevel;
Price = _Price;
Side = _Side;
}
///<summary>Check arguments so that errors don't occur in native code</summary>
private static void ArgumentCheck( Side side, int m, int n, object A, int lda, object B, int ldb ) {
if ( A == null ) {
throw new ArgumentNullException("A", "A cannot be null.");
}
if ( B == null ) {
throw new ArgumentNullException("B", "B cannot be null.");
}
if ( m < 0) {
throw new ArgumentException("m must be zero or greater", "m");
}
if ( n < 0) {
throw new ArgumentException("n must be zero or greater", "n");
}
if (side == Side.Left) {
if(lda < System.Math.Max(1,m)){
throw new ArgumentException("lda must be at least max(1,m).", "lda");
}
}else{
if(lda < System.Math.Max(1,n)){
throw new ArgumentException("lda must be at least max(1,n).","lda");
}
}
if(ldb < System.Math.Max(1,m)){
throw new ArgumentException("lda must be at least max(1,m).","ldb");
}
}
public void AttackedFrom_WhteRookE1KnightC3C4BlackRookA4TargetE4_ReturnsBitboardC3E1()
{
// arrange
var white = new Side(
"G1",
new PieceSet<Queen>(),
new PieceSet<Bishop>(),
new PieceSet<Knight>(Bitboard.With.C3.C4),
new PieceSet<Rook>(Bitboard.With.E1),
new WhitePawns()
);
var black = new Side(
"G8",
new PieceSet<Queen>(),
new PieceSet<Bishop>(),
new PieceSet<Knight>(),
new PieceSet<Rook>(Bitboard.With.A4),
new BlackPawns()
);
var target = new Square("E4");
var expected = Bitboard.With.C3.E1.Build();
// act
var result = target.AttackedFrom(white, black);
// assert
result.Should().Be(expected);
}
public Person(int helthPoint, int x, int y, Side team)
{
this.HelthPoint = helthPoint;
this.x = x;
this.y = y;
this.Team = team;
}
/// <summary>
/// Gets the orientation for the context in the given position.
/// </summary>
/// <param name="loc"></param>
/// <returns></returns>
public static Orientation ContextOrientation(Side loc)
{
if (loc == Side.N || loc == Side.S)
return Orientation.Horizontal;
else
return Orientation.Vertical;
}
private IEnumerator WaitForPosition()
{
yield return new WaitForEndOfFrame();
int dir = 1;
lastSide = Side.Right;
Vector3 viewportPosition = Camera.main.WorldToViewportPoint (transform.position);
if((viewportPosition.x < 0 && viewportPosition.y > 0.5f) ||
(viewportPosition.x > 1 && viewportPosition.y < 0.5f) ||
(viewportPosition.y < 0 && viewportPosition.x < 0.5f) ||
(viewportPosition.y > 1 && viewportPosition.x > 0.5f))
{
dir = -1;
lastSide = Side.Left;
}
sideVelocity = (Vector2)transform.up * dir;
frontVelocity = (Vector2)transform.right;
finalVelocity = (frontVelocity + sideVelocity).normalized;
myAnimator.SetInteger ("State", (lastSide == Side.Right) ? 0 : 1);
yield return new WaitForEndOfFrame();
myAnimator.SetInteger("State", 2);
angle = Mathf.Atan2 (finalVelocity.y, finalVelocity.x) * Mathf.Rad2Deg;
StartCoroutine (ChangeDirection (timeToChangeDirection.Random ()));
}
/// <summary>
/// Create a NewOrderSingle message.
/// </summary>
/// <param name="customFields"></param>
/// <param name="orderType"></param>
/// <param name="side"></param>
/// <param name="symbol"></param>
/// <param name="orderQty"></param>
/// <param name="tif"></param>
/// <param name="price">ignored if orderType=Market</param>
/// <returns></returns>
static public QuickFix.FIX42.NewOrderSingle NewOrderSingle(
Dictionary<int,string> customFields,
OrderType orderType, Side side, string symbol,
int orderQty, TimeInForce tif, decimal price)
{
// hard-coded fields
QuickFix.Fields.HandlInst fHandlInst = new QuickFix.Fields.HandlInst(QuickFix.Fields.HandlInst.AUTOMATED_EXECUTION_ORDER_PRIVATE);
// from params
QuickFix.Fields.OrdType fOrdType = FixEnumTranslator.ToField(orderType);
QuickFix.Fields.Side fSide = FixEnumTranslator.ToField(side);
QuickFix.Fields.Symbol fSymbol = new QuickFix.Fields.Symbol(symbol);
QuickFix.Fields.TransactTime fTransactTime = new QuickFix.Fields.TransactTime(DateTime.Now);
QuickFix.Fields.ClOrdID fClOrdID = GenerateClOrdID();
QuickFix.FIX42.NewOrderSingle nos = new QuickFix.FIX42.NewOrderSingle(
fClOrdID, fHandlInst, fSymbol, fSide, fTransactTime, fOrdType);
nos.OrderQty = new QuickFix.Fields.OrderQty(orderQty);
nos.TimeInForce = FixEnumTranslator.ToField(tif);
if (orderType == OrderType.Limit)
nos.Price = new QuickFix.Fields.Price(price);
// add custom fields
foreach (KeyValuePair<int,string> p in customFields)
nos.SetField(new QuickFix.Fields.StringField(p.Key, p.Value));
return nos;
}
public Player(string name, Side side)
{
Name = name;
Side = side;
win = 0;
lose = 0;
}
public Bishop(Position pos, Side side, ChessField chessfield)
: base(pos, side, chessfield)
{
FigureType = FigureTypes.Bishop;
movepolitics = new MovePolitics[] {
chessfield.DiagMovePolitics};
}
private void AdvanceState(Side side)
{
if (StillPlaying())
{
if (HasEnteredDeuce())
{
this.state = GameState.Deuce;
if (GetPointState(side) == PointState.Advantage)
{
this.state = DetermineWinner(side);
return;
}
if((sideOnePoints == PointState.Deuce && sideTwoPoints == PointState.Deuce)
|| (sideOnePoints == PointState.Forty && sideTwoPoints == PointState.Forty))
{
SetPointState(side, PointState.Advantage);
return;
}
sideOnePoints = PointState.Deuce;
sideTwoPoints = PointState.Deuce;
return;
}
RollPoints(side);
if (((int)GetPointState(side)) > 4)
{
this.state = DetermineWinner(side);
}
}
}
public bool GetSensor(Axis axis, Side side)
{
if (axis == Axis.X)
{
if (side == Side.POSITIVE && GetSensorValue(axis) >= thresholdX)
return true;
else if (side == Side.NEGATIVE && GetSensorValue(axis) <= -thresholdX)
return true;
else
return false;
}
else if (axis == Axis.Y)
{
if (side == Side.POSITIVE && GetSensorValue(axis) >= thresholdY)
return true;
else if (side == Side.NEGATIVE && GetSensorValue(axis) <= -thresholdY)
return true;
else
return false;
}
else if (axis == Axis.Z)
{
if (side == Side.POSITIVE && GetSensorValue(axis) >= thresholdZ)
return true;
else if (side == Side.NEGATIVE && GetSensorValue(axis) <= thresholdZ)
return true;
else
return false;
}
else
return false;
}
public Slot this[Side index]
{
// access to neighby slots on the index
get {
return slot.nearSlot[index];
}
}
private int EvaluateOrientation(PositionInfo.LineInfo positive, PositionInfo.LineInfo negative, Side player)
{
if (positive.amount > 0 && negative.amount > 0)
{
if (positive.side == negative.side)
{
int n = 1 + positive.amount + negative.amount;
return LineCost(n, positive.open, negative.open);
}
else
{
int npos = positive.amount + 1;
int nneg = negative.amount + 1;
return Math.Max(LineCost(npos, positive.open, false), LineCost(nneg, negative.open, false));
}
}
if (positive.amount > 0)
{
return LineCost(positive.amount + 1, positive.open, true);
}
if (negative.amount > 0)
{
return LineCost(negative.amount + 1, negative.open, true);
}
return 0;
}
public void ChangeVisibility(Side side, Mode mode)
{
Transform sideObject = this.transform.FindChild(SidesNames [(int)side]);
Mesh leftMesh, rightMesh, midMesh;
switch (mode)
{
case Mode.Full:
leftMesh = fullMeshLeft;
rightMesh = fullMeshRight;
midMesh = fullMesh;
break;
case Mode.Half:
leftMesh = halfMeshLeft;
rightMesh = halfMeshRight;
midMesh = halfMesh;
break;
case Mode.Empty:
leftMesh = null;
rightMesh = null;
midMesh = emptyMesh;
break;
default:
throw new ArgumentException();
}
sideObject.FindChild("LeftSide").GetComponent<MeshFilter>().sharedMesh= leftMesh;
sideObject.FindChild("LeftSide").GetComponent<MeshCollider>().sharedMesh = leftMesh;
sideObject.FindChild("RightSide").GetComponent<MeshFilter>().sharedMesh = rightMesh;
sideObject.FindChild("RightSide").GetComponent<MeshCollider>().sharedMesh = rightMesh;
sideObject.FindChild("Middle").GetComponent<MeshFilter>().sharedMesh = midMesh;
sideObject.FindChild("Middle").GetComponent<MeshCollider>().sharedMesh = midMesh;
}
public ClickRes getClickResult(Side side, ClickRes res)
{
float diff = preTempo.rect.width - tempo.rect.width;
ClickRes clickRes;
if (side == Side.Atk)
{ // 攻擊判斷
if (diff < 5)
clickRes = ClickRes.Perfect;
else if (diff < 15)
clickRes = ClickRes.Great;
else
clickRes = ClickRes.Miss;
}
else
{ // 防禦判斷
if (diff < defList[res][0])
clickRes = ClickRes.Perfect;
else if (diff < defList[res][1])
clickRes = ClickRes.Great;
else
clickRes = ClickRes.Miss;
}
// 更新結果顯示文字
updateResult(clickRes);
return clickRes;
}
private void bt_right_Click(object sender, EventArgs e)
{
bt_left.Enabled = false;
bt_right.Enabled = false;
_Side = Side.Right;
lb_status.Text = "Press space to save right point";
}
public bool getAveragePrice(MarketData md, int qty, Side side, int leg)
{
long tempPrice = 0;
long tempQty = 0;
for (int i = 0; i < 5; ++i)
{
long p = md.getPrice(side, i + 1);
long q = md.getQty(side, i + 1);
tempPrice += p * q;
tempQty += q;
if (tempQty >= qty)
break;
}
if (tempQty < qty)
{
if (leg == 1)
_data.avgPriceFirstLeg = 0;
else
_data.avgPriceSecondLeg = 0;
return false;
}
if (leg == 1)
_data.avgPriceFirstLeg = (int)(tempPrice / tempQty);
else
_data.avgPriceSecondLeg = (int)(tempPrice / tempQty);
return true;
}
public Pawn(Position pos, Side side, ChessField chessfield)
: base(pos,side, chessfield)
{
FigureType = FigureTypes.Pawn;
movepolitics = new MovePolitics[] { chessfield.VerticalMovePolitics};
attackpolitics = new MovePolitics[] { chessfield.DiagMovePolitics};
}
public Side side; // The side that it would be played on
#endregion Fields
#region Constructors
public TurnOption(Dom inPlayed, Side inSide, List<Dom> inHand, List<int> inBoard)
{
played = inPlayed;
side = inSide;
hand = inHand;
board = inBoard;
}
public override MultiOrderLeg GetLeg(Side side,string instrument)
{
if (side == Side.Buy)
return Buy;
else
return Sell;
}
public Paddle(Side side, GameOfPaddles game) {
_side = side;
_game = game;
_world = game.World;
_ball = _world["ball"];
_pixels = new PlayerMissile[Size];
for(var i = 0; i < Size; i++) {
_pixels[i] = new PlayerMissile(
"paddle" +
(_side == Side.Right ? 'R' : 'L') +
i,
_side == Side.Right ? 7 : 0,
i,
_world);
}
_world.Coinc +=
(s, a) => {
if (_ball.X == 0 && _side == Side.Left) {
_game.BallGoingRight = true;
}
if (_ball.X == 7 && _side == Side.Right) {
_game.BallGoingRight = false;
}
};
}
public Position getPosition(Instrument instrument, Side orderMode)
{
IntPtr cPtr = ContextModulePINVOKE.NetPositions_getPosition(swigCPtr, Instrument.getCPtr(instrument), (int)orderMode);
Position ret = (cPtr == IntPtr.Zero) ? null : new Position(cPtr, false);
if (ContextModulePINVOKE.SWIGPendingException.Pending) throw ContextModulePINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private async void MoveWindowOutOfScreen(Side side)
{
BaseWindow.Topmost = true;
MoveOut?.Invoke(this, EventArgs.Empty);
if (side == Side.Left)
{
for (var i = 0; i > -32; i--)
{
await Task.Delay(1);
BaseWindow.Left = i * 10 + WpfScreen.MostLeftX;
}
}
else
{
for (int i = 0; i < 32; i++)
{
await Task.Delay(1);
BaseWindow.Left = WpfScreen.MostRightX - BaseWindow.Width + i * 10;
}
}
_movedOut = true;
BaseWindow.ShowInTaskbar = false;
_movedOutSide = side;
StartMagic();
}
static void ShowSidesInfo(Side[] sides)
{
foreach (var side in sides)
{
Console.WriteLine(side.Length);
}
}
public DbWords(int CardId, Side ListSide, WordType ListType, ParentClass parentClass)
{
id = CardId;
side = ListSide;
type = ListType;
parent = parentClass;
}
/// <summary>
/// Inicializa el Jugador a partir de su <see cref="Side"/>
/// </summary>
/// <param name="side"></param>
public Jugador(Side side)
{
//Inicializamos las variables
paddlePosition = new Point();
paddlePositionPast = new Point();
position = new Point();
this.side = side;
score = 0;
//Creamos el puntero para ver donde se encuentra la mano del jugador
mark = new Ellipse();
mark.Width = Utilities.PLAYER_ELLIPSE_RADIUS;
mark.Height = Utilities.PLAYER_ELLIPSE_RADIUS;
//Creamos la barra del jugador
shape = new Rectangle();
shape.Width = Utilities.PADDLE_WIDTH;
shape.Height = Utilities.PADDLE_HEIGHT; ;
shape.Stroke = new SolidColorBrush(Colors.White);
shape.StrokeThickness = 2;
//Coloreamos según el jugador que sea
switch (side) {
case Side.Player1:
mark.Fill = new SolidColorBrush(Utilities.PLAYER1_COLOR);
shape.Fill = new SolidColorBrush(Utilities.PLAYER1_COLOR);
break;
case Side.Player2:
mark.Fill = new SolidColorBrush(Utilities.PLAYER2_COLOR);
shape.Fill = new SolidColorBrush(Utilities.PLAYER2_COLOR);
break;
}
isConnected = false;
}
public Knight(Position pos, Side side, ChessField chessfield)
: base(pos, side, chessfield)
{
FigureType = FigureTypes.Knight;
movepolitics = new MovePolitics[] {
chessfield.KnightMovePolitics};
}
public async Task <OrderResponse> StopLossOrderAsync(string pair, decimal quantity, decimal price, decimal stopPrice, Side side)
{
Binance.NetCore.Entities.Side binanceSide = this.BinanceSideReConverter(side);
var response = await binance.StopLossLimitAsync(pair, binanceSide, quantity, price, stopPrice, Binance.NetCore.Entities.TimeInForce.GTC);
return(this.BinanceTradeResponseToOrderResponse(response));
}
public bool CanConnect(Side side)
{
return(IO[side]);
}
public void Initialize(Side side)
{
m_side = side;
}
private IEnumerable <PersonViewModel> GetPersons(Side side)
{
return(side == Side.Home ? homePersons : awayPersons);
}
public async Task <OrderResponse> LimitOrderAsync(string pair, decimal price, decimal quantity, Side side)
{
Binance.NetCore.Entities.Side binanceSide = this.BinanceSideReConverter(side);
var response = await binance.LimitOrderAsync(pair, binanceSide, quantity, price);
return(this.BinanceTradeResponseToOrderResponse(response));
}
static void Main(string[] args)
{
string excelFile = null;
string dataFile = null;
Side side = Side.All;
string headModel = null;
string dataFormatStr = null;
string dataType = "List<Dictionary<string, object>>";
optionSet = new OptionSet()
{
{ "excelFile=", "Excel folder path", s => excelFile = s },
{ "dataFile=", "The code out folder", s => dataFile = s },
{ "headModel=", "The last export info.", s => headModel = s },
{ "side=", "The last export info.", s => side = (Side)Enum.Parse(typeof(Side), s) },
{ "dataFormat=", "Data format", s => dataFormatStr = s },
{ "dataType=", "Data Type", s => dataType = s },
};
optionSet.Parse(args);
if (string.IsNullOrEmpty(excelFile))
{
Console.WriteLine("Excel file is null");
return;
}
if (string.IsNullOrEmpty(dataFile))
{
Console.WriteLine("Code out path is null");
return;
}
if (!Path.IsPathRooted(excelFile))
{
excelFile = Path.Combine(Directory.GetCurrentDirectory(), excelFile);
}
if (!Path.IsPathRooted(dataFile))
{
dataFile = Path.Combine(Directory.GetCurrentDirectory(), dataFile);
}
ImportSetting setting = new ImportSetting();
if (!string.IsNullOrEmpty(headModel))
{
switch (headModel)
{
case "Normal":
setting.headModel = HeadModel.CreateNormalModel();
break;
case "Simple":
setting.headModel = HeadModel.CreateSimpleModel();
break;
//use default have side
case "All":
default:
break;
}
}
ExcelImport import = new ExcelImport(setting);
import.side = side;
DataFormat dataFormat = (DataFormat)Enum.Parse(typeof(DataFormat), dataFormatStr);
import.dataFormat = dataFormat;
import.dataType = TypeInfo.Parse(dataType).ToSystemType();
import.Import(dataFile, excelFile);
}
protected override void ThreadFunction() // Function ported from Main.greedy() at https://github.com/roboleary/GreedyMesh/blob/master/src/mygame/Main.java
{
int i, j, k, l, w, h, u, v, n;
Side side = Side.TOP;
int[] x = new int[] { 0, 0, 0 };
int[] q = new int[] { 0, 0, 0 };
int[] du = new int[] { 0, 0, 0 };
int[] dv = new int[] { 0, 0, 0 };
VoxelFace[] mask = new VoxelFace[Chunk.chunkSize * Chunk.chunkSize];
VoxelFace comp1, comp2;
VoxelFace nullFace = new VoxelFace()
{
srcBlock = null
};
for (bool backFace = true, b = false; b != backFace; backFace = backFace && b, b = !b)
{
for (int d = 0; d < 3; d++)
{
u = (d + 1) % 3;
v = (d + 2) % 3;
x = new int[] { 0, 0, 0 };
q = new int[] { 0, 0, 0 };
q[d] = 1;
switch (d)
{
case 0:
side = backFace ? Side.WEST : Side.EAST;
break;
case 1:
side = backFace ? Side.BOTTOM : Side.TOP;
break;
case 2:
side = backFace ? Side.SOUTH : Side.NORTH;
break;
}
for (x[d] = -1; x[d] < Chunk.chunkSize;)
{
// Generate Mask
n = 0;
for (x[v] = 0; x[v] < Chunk.chunkSize; x[v]++)
{
for (x[u] = 0; x[u] < Chunk.chunkSize; x[u]++)
{
comp1 = (x[d] >= 0) ? GetVoxelFace(x[0], x[1], x[2], side) : nullFace;
comp2 = (x[d] < Chunk.chunkSize - 1) ? GetVoxelFace(x[0] + q[0], x[1] + q[1], x[2] + q[2], side) : nullFace;
mask[n++] = (comp1 != nullFace && comp2 != nullFace && comp1 == comp2) ? nullFace : (backFace ? comp2 : comp1);
}
}
x[d]++;
// Generate Mesh
n = 0;
for (j = 0; j < Chunk.chunkSize; j++)
{
for (i = 0; i < Chunk.chunkSize;)
{
if (mask[n] == nullFace)
{
// Compute width
for (w = 1; i + w < Chunk.chunkSize && mask[n + w] != nullFace && mask[n + w] == mask[n]; w++)
{
}
// Compute height
bool done = false;
for (h = 1; j + h < Chunk.chunkSize; h++)
{
for (k = 0; k < w; k++)
{
if (mask[n + k + h * Chunk.chunkSize] == nullFace || mask[n + k + h * Chunk.chunkSize] != mask[n])
{
done = true; break;
}
}
if (done)
{
break;
}
}
if (!mask[n].culled) // Ensure this face hasn't been culled
{
x[u] = i;
x[v] = j;
du = new int[] { 0, 0, 0 };
du[u] = w;
dv = new int[] { 0, 0, 0 };
dv[v] = h;
var vertexIndex = vertices.Count;
vertices.AddRange(new Vector3[] {
new Vector3(x[0], x[1], x[2]),
new Vector3(x[0] + du[0], x[1] + du[1], x[2] + du[2]),
new Vector3(x[0] + du[0] + dv[0], x[1] + du[1] + dv[1], x[2] + du[2] + dv[2]),
new Vector3(x[0] + dv[0], x[1] + dv[1], x[2] + dv[2]),
});
var uv = mask[n].srcBlock.getUv(side);
uvs.AddRange(new Vector2[] { uv, uv, uv, uv });
if (backFace)
{
tris.AddRange(new int[] { vertexIndex + 2, vertexIndex, vertexIndex + 1,
vertexIndex + 1, vertexIndex + 3, vertexIndex + 2 });
}
else
{
tris.AddRange(new int[] { vertexIndex + 2, vertexIndex + 3, vertexIndex + 1,
vertexIndex + 1, vertexIndex, vertexIndex + 2 });
}
}
// Empty the mask
for (l = 0; l < h; l++)
{
for (k = 0; k < w; k++)
{
mask[n + k + l * Chunk.chunkSize] = nullFace;
}
}
}
}
}
}
}
}
}
/// <summary>
/// Gets the characters.
/// </summary>
/// <param name="side">The side.</param>
/// <returns></returns>
public ICollection <Character> GetCharacters(Side side)
{
return(side == Side.LEFT ? Left : Right);
}
/// <summary>
/// Stitchs the terrains.
/// </summary>
/// <param name="terrain">Terrain.</param>
/// <param name="second">Second.</param>
/// <param name="side">Side.</param>
/// <param name="xBase">X base.</param>
/// <param name="yBase">Y base.</param>
/// <param name="width">Width.</param>
/// <param name="height">Height.</param>
/// <param name="range">Range.</param>
/// <param name="smooth">If set to <c>true</c> smooth.</param>
public static void StitchTerrains(Terrain terrain, Terrain second, Side side, int xBase, int yBase, int width, int height, int range, bool smooth = false)
{
TerrainData terrainData = terrain.terrainData;
TerrainData secondData = second.terrainData;
//Debug.Log (xBase + " " + (terrainData.heightmapHeight - 1) + " " + (xBase + width) + " " + 1);
if (side == Side.Right)
{
float[,] heights = terrainData.GetHeights(terrainData.heightmapWidth - width, yBase, width, height);
float[,] secondHeights = secondData.GetHeights(0, yBase, range > 0 ? range : 1, height);
//Debug.Log ("Right " + heights.GetLength (0) + " " + heights.GetLength (1));
checkLength = width;
int y = width - 1;
int x = 0;
int y2 = 0;
for (x = 0; x < heights.GetLength(0); x++)
{
if (heights [x, y] == secondHeights [x, y2])
{
continue;
}
heights [x, y] = average(heights [x, y], secondHeights [x, y2]);
if (smooth)
{
heights [x, y] += Mathf.Abs(heights [x, y - 1] - secondHeights [x, y2 + 1]) / levelSmooth;
}
secondHeights [x, y2] = heights [x, y];
for (int i = 1; i < checkLength; i++)
{
heights [x, y - i] = (average(heights [x, y - i], heights [x, y - i + 1]) + Mathf.Abs(heights [x, y - i] - heights [x, y - i + 1]) / levelSmooth) * (checkLength - i) / checkLength + heights [x, y - i] * i / checkLength;
}
for (int i = 1; i < range; i++)
{
secondHeights [x, y2 + i] = (average(secondHeights [x, y2 + i], secondHeights [x, y2 + i - 1]) + Mathf.Abs(secondHeights [x, y2 + i] - secondHeights [x, y2 + i - 1]) / levelSmooth) * (range - i) / range + secondHeights [x, y2 + i] * i / range;
}
}
terrainData.SetHeightsDelayLOD(terrainData.heightmapWidth - width, yBase, heights);
terrain.terrainData = terrainData;
secondData.SetHeightsDelayLOD(0, yBase, secondHeights);
second.terrainData = secondData;
}
else
{
if (side == Side.Top)
{
float[,] heights = terrainData.GetHeights(xBase, terrainData.heightmapHeight - height, width, height);
float[,] secondHeights = secondData.GetHeights(xBase, 0, width, range > 0 ? range : 1);
checkLength = height;
int y = 0;
int x = height - 1;
//Debug.Log (x + " " + height + " " + range + " " + heights.GetLength (0) + " " + heights.GetLength (1) + " " + secondHeights.GetLength (0) + " " + secondHeights.GetLength (1));
int x2 = 0;
for (y = 0; y < heights.GetLength(1); y++)
{
if (heights [x, y] == secondHeights [x2, y])
{
continue;
}
heights [x, y] = average(heights [x, y], secondHeights [x2, y]);
if (smooth)
{
heights [x, y] += Mathf.Abs(heights [x - 1, y] - secondHeights [x2 + 1, y]) / levelSmooth;
}
secondHeights [x2, y] = heights [x, y];
for (int i = 1; i < checkLength; i++)
{
heights [x - i, y] = (average(heights [x - i, y], heights [x - i + 1, y]) + Mathf.Abs(heights [x - i, y] - heights [x - i + 1, y]) / levelSmooth) * (checkLength - i) / checkLength + heights [x - i, y] * i / checkLength;
}
for (int i = 1; i < range; i++)
{
secondHeights [x2 + i, y] = (average(secondHeights [x2 + i, y], secondHeights [x2 + i - 1, y]) + Mathf.Abs(secondHeights [x2 + i, y] - secondHeights [x2 + i - 1, y]) / levelSmooth) * (range - i) / range + secondHeights [x2 + i, y] * i / range;
}
}
terrainData.SetHeightsDelayLOD(xBase, terrainData.heightmapHeight - height, heights);
terrain.terrainData = terrainData;
secondData.SetHeightsDelayLOD(xBase, 0, secondHeights);
second.terrainData = secondData;
}
}
terrain.Flush();
second.Flush();
}
/// <summary>
/// Stitchs the terrains and repairs errors.
/// </summary>
/// <param name="terrain">Terrain.</param>
/// <param name="second">Second.</param>
/// <param name="side">Side.</param>
/// <param name="xBase">X base.</param>
/// <param name="yBase">Y base.</param>
/// <param name="width">Width.</param>
/// <param name="height">Height.</param>
public static void StitchTerrainsRepair(Terrain terrain, Terrain second, Side side, int xBase, int yBase, int width, int height)
{
TerrainData terrainData = terrain.terrainData;
TerrainData secondData = second.terrainData;
if (side == Side.Right)
{
float[,] heights = terrainData.GetHeights(terrainData.heightmapWidth - 1, yBase, 1, height);
float[,] secondHeights = secondData.GetHeights(0, yBase, 1, height);
int y = 0;
int x = 0;
int y2 = 0;
for (x = 0; x < heights.GetLength(0); x++)
{
if (heights [x, y] == secondHeights [x, y2])
{
continue;
}
heights [x, y] = average(heights [x, y], secondHeights [x, y2]);
secondHeights [x, y2] = heights [x, y];
}
terrainData.SetHeightsDelayLOD(terrainData.heightmapWidth - 1, yBase, heights);
terrain.terrainData = terrainData;
secondData.SetHeightsDelayLOD(0, yBase, secondHeights);
second.terrainData = secondData;
}
else
{
if (side == Side.Top)
{
//Debug.Log ("top");
float[,] heights = terrainData.GetHeights(xBase, terrainData.heightmapHeight - 1, width, 1);
float[,] secondHeights = secondData.GetHeights(xBase, 0, width, 1);
int y = 0;
int x = 0;
int x2 = 0;
for (y = 0; y < heights.GetLength(1); y++)
{
if (heights [x, y] == secondHeights [x2, y])
{
continue;
}
heights [x, y] = average(heights [x, y], secondHeights [x2, y]);
secondHeights [x2, y] = heights [x, y];
}
terrainData.SetHeightsDelayLOD(xBase, terrainData.heightmapHeight - 1, heights);
terrain.terrainData = terrainData;
secondData.SetHeightsDelayLOD(xBase, 0, secondHeights);
second.terrainData = secondData;
}
}
terrain.Flush();
second.Flush();
}
public Piece(Side owner, int stackLimit, params ShapeOrientation[] shapes)
{
Owner = owner;
StackLimit = stackLimit;
Shapes = new ShapeOrientationCollection(shapes, true);
}
public void Interrupt(Side side)
{
source.Interrupt(side);
}
public Piece(Side owner, int stackLimit, ShapeOrientationCollection shapes)
{
Owner = owner;
StackLimit = stackLimit;
Shapes = shapes;
}
private int GetTeamId(Side side)
{
return(side == Side.Home ? protocolManager.Game.homeId : protocolManager.Game.awayId);
}
public bool TryGetLength(int start, Side side, out int length)
{
return(inner.TryGetLength(start, side, out length));
}
public bool TrySetLength(int start, Side side, int length)
{
return(inner.TrySetLength(start, side, length));
}
public bool TryInsert(int start, Side side, int xLength, int yLength)
{
return(inner.TryInsert(start, side, xLength, yLength, null));
}
public bool TryDelete(int start, Side side)
{
return(inner.TryDelete(start, side));
}
public IEnumerable <EntryRange2List> GetRobustEnumerable(int startAt, Side side, bool forward)
{
return(new AdaptEnumerable <EntryRange2List, EntryRange2Map <object> >(
inner.GetRobustEnumerable(startAt, side, forward),
Convert));
}
public bool Contains(int start, Side side)
{
return(inner.Contains(start, side));
}
public bool NearestGreater(int position, Side side, out int nearestStart, out int otherStart, out int xLength, out int yLength)
{
object value;
return(inner.NearestGreater(position, side, out nearestStart, out otherStart, out xLength, out yLength, out value));
}
public IEnumerable <EntryRange2List> GetFastEnumerable(int startAt, Side side)
{
return(new AdaptEnumerable <EntryRange2List, EntryRange2Map <object> >(
inner.GetFastEnumerable(startAt, side),
Convert));
}
public bool NearestLessOrEqual(int position, Side side, out int nearestStart)
{
return(inner.NearestLessOrEqual(position, side, out nearestStart));
}
public bool NearestGreater(int position, Side side, out int nearestStart)
{
return(inner.NearestGreater(position, side, out nearestStart));
}
public int AdjustLength(int start, Side side, int xAdjust, int yAdjust)
{
return(inner.AdjustLength(start, side, xAdjust, yAdjust));
}
public int GetExtent(Side side)
{
return(inner.GetExtent(side));
}
public void Get(int start, Side side, out int otherStart, out int xLength, out int yLength)
{
object value;
inner.Get(start, side, out otherStart, out xLength, out yLength, out value);
}
public void Set(int start, Side side, int xLength, int yLength)
{
inner.Set(start, side, xLength, yLength, null);
}
protected override MapArrayTile[,] GeneratePathInto(int seed, Side side,
MapArrayGenerator otherMapArrayGenerator, out Vector2 connectorCoords, out Vector2 plugCoords)
{
System.Random random = new System.Random(seed);
int hallThickness = random.Next((int)hallThicknessRange.x, (int)hallThicknessRange.y);
int hallYCoord = random.Next((int)otherMapArrayGenerator.roomBoundingRect.min.y + hallThickness / 2,
(int)otherMapArrayGenerator.roomBoundingRect.max.y - (hallThickness + 1) / 2);
int hallXCoord = random.Next((int)otherMapArrayGenerator.roomBoundingRect.min.x + hallThickness / 2,
(int)otherMapArrayGenerator.roomBoundingRect.max.x - (hallThickness + 1) / 2);
MapArrayTile[,] otherMapArray = otherMapArrayGenerator.mapArray;
Rect otherRoomBoundingRect = otherMapArrayGenerator.roomBoundingRect;
plugCoords = Vector2.zero;
connectorCoords = Vector2.zero;
switch (side)
{
case Side.Left:
connectorCoords = new Vector2(-0.5f, hallYCoord);
plugCoords = new Vector2((int)otherRoomBoundingRect.min.x - 0.5f, hallYCoord);
break;
case Side.Right:
connectorCoords = new Vector2(otherMapArray.GetLength(0) - 0.5f, hallYCoord);
plugCoords = new Vector2((int)otherRoomBoundingRect.max.x - 0.5f, hallYCoord);
break;
case Side.Top:
connectorCoords = new Vector2(hallXCoord, otherMapArray.GetLength(1) - 0.5f);
plugCoords = new Vector2(hallXCoord, (int)otherRoomBoundingRect.max.y - 0.5f);
break;
case Side.Bottom:
connectorCoords = new Vector2(hallXCoord, -0.5f);
plugCoords = new Vector2(hallXCoord, (int)otherRoomBoundingRect.min.y - 0.5f);
break;
default:
Debug.Log("Side does not exist");
break;
}
MapArrayTile[,] pathArray = new MapArrayTile[otherMapArray.GetLength(0), otherMapArray.GetLength(1)];
FillWith(pathArray, MapArrayTile.None);
//Returns the position of the connector in map coords
switch (side)
{
case Side.Left:
FillBoxWith(pathArray, 0, (int)otherRoomBoundingRect.min.x,
hallYCoord - hallThickness / 2, hallYCoord + (hallThickness + 1) / 2, MapArrayTile.Ground);
break;
case Side.Right:
FillBoxWith(pathArray, (int)otherRoomBoundingRect.max.x, pathArray.GetLength(0),
hallYCoord - hallThickness / 2, hallYCoord + (hallThickness + 1) / 2, MapArrayTile.Ground);
break;
case Side.Top:
FillBoxWith(pathArray, hallXCoord - hallThickness / 2, hallXCoord + (hallThickness + 1) / 2,
(int)otherRoomBoundingRect.max.y, pathArray.GetLength(1), MapArrayTile.Ground);
break;
case Side.Bottom:
FillBoxWith(pathArray, hallXCoord - hallThickness / 2, hallXCoord + (hallThickness + 1) / 2,
0, (int)otherRoomBoundingRect.min.y, MapArrayTile.Ground);
break;
default:
Debug.Log("Side does not exist");
break;
}
return(pathArray);
}
public void SetLength(int start, Side side, int length)
{
inner.SetLength(start, side, length);
}
