public void HandleEvent(IFallable sender, FallEventArgs e)
{
if (sender == null || e == null)
{
return;
}
if (sender is Mino)
{
Mino mino = sender as Mino;
Counter += mino.Game.TargetElapsedTime;
if (Counter >= FallTimeSpan)
{
mino.Position += new Vector2(0, FallVelocity);
Counter -= FallTimeSpan;
}
}
if (sender is Polyomino)
{
Polyomino polyomino = sender as Polyomino;
Counter += polyomino.Game.TargetElapsedTime;
if (Counter >= FallTimeSpan)
{
foreach (Mino mino in polyomino.Minoes)
{
mino.Position += new Vector2(0, FallVelocity);
}
Counter -= FallTimeSpan;
}
}
}
private static void polyomino_lp_write_test()
//****************************************************************************80
//
// Purpose:
//
// POLYOMINO_LP_WRITE_TEST tests POLYOMINO_LP_WRITE.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 17 May 2018
//
// Author:
//
// John Burkardt
//
{
const string filename = "reid.lp";
const string label = "\\ LP file for the Reid example, created by POLYOMINO_LP_WRITE.";
int m = 0;
int n = 0;
Console.WriteLine("");
Console.WriteLine("POLYOMINO_LP_WRITE_TEST:");
Console.WriteLine(" POLYOMINO_LP_WRITE writes an LP file associated");
Console.WriteLine(" with a binary programming problem for tiling a region");
Console.WriteLine(" with copies of a single polyomino.");
//
// Get the coefficients and right hand side for the Reid system.
//
polyomino_monohedral_example_reid_size(ref m, ref n);
int[] a = new int[m * n];
int[] b = new int[m];
polyomino_monohedral_example_reid_system(m, n, a, b);
//
// Create the LP file.
//
Polyomino.polyomino_lp_write(filename, label, m, n, a, b);
Console.WriteLine("");
Console.WriteLine(" Created the LP file '" + filename + "'");
Console.WriteLine("");
Console.WriteLine("POLYOMINO_LP_WRITE_TEST:");
Console.WriteLine(" Normal end of execution.");
}
private static void polyomino_embed_number_test()
//****************************************************************************80
//
// Purpose:
//
// POLYOMINO_EMBED_NUMBER_TEST tests POLYOMINO_EMBED_NUMBER.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 02 May 2018
//
// Author:
//
// John Burkardt
//
{
const int mp = 3;
const int mr = 4;
const int np = 2;
const int nr = 4;
int[] p =
{
0, 0, 1,
1, 1, 1
};
int[] r =
{
0, 1, 1, 1,
1, 1, 1, 0,
1, 0, 1, 1,
1, 1, 1, 1
};
Console.WriteLine("");
Console.WriteLine("POLYOMINO_EMBED_NUMBER_TEST:");
Console.WriteLine(" POLYOMINO_EMBED_NUMBER reports the number of ways a");
Console.WriteLine(" fixed polyomino can be embedded in a region.");
Polyomino.polyomino_print(mr, nr, r, " The given region R:");
Polyomino.polyomino_print(mp, np, p, " The given polyomino P:");
int number = Polyomino.polyomino_embed_number(mr, nr, r, mp, np, p);
Console.WriteLine("");
Console.WriteLine(" As a fixed polyomino, P can be embedded in R in " + number + " ways");
}
public void HandleEvent(IRotatable sender, RotateEventArgs e)
{
if (sender == null || e == null)
{
return;
}
if (e.Direction != LastDirection)
{
DirectionChanged = true;
LastDirection = e.Direction;
}
else
{
DirectionChanged = false;
}
if (e.Direction == RotatingDirections.None)
{
return;
}
if (sender is Polyomino)
{
Polyomino polyomino = sender as Polyomino;
if (DirectionChanged)
{
foreach (Mino mino in polyomino.Minoes)
{
Vector2 vector = mino.Position - polyomino.OriginMino.Position;
float r = 0;
switch (e.Direction)
{
case RotatingDirections.Clockwise:
r = +MathHelper.PiOver2;
break;
case RotatingDirections.Counterclockwise:
r = -MathHelper.PiOver2;
break;
default:
break;
}
var x = MathHelper.Clamp(Convert.ToSingle(vector.X * Math.Cos(r) - vector.Y * Math.Sin(r)), float.MinValue, float.MaxValue);
var y = MathHelper.Clamp(Convert.ToSingle(vector.X * Math.Sin(r) + vector.Y * Math.Cos(r)), float.MinValue, float.MaxValue);
mino.Position = polyomino.OriginMino.Position + new Vector2(x, y);
}
}
}
}
public static Block generate(int depth, Polyomino frame = null)
{
frame = frame ?? candidates.Sample().Single();
var offset = new Point2(Random.Range(0, TileContainer.Instance.size - frame.constraints.x),
Random.Range(0, TileContainer.Instance.size - frame.constraints.y));
List <Tile> tiles = new List <Tile> ();
foreach (var point in frame.points)
{
tiles.Add(TileContainer.Instance.getTile(point + offset, depth));
}
return(new Block(tiles, frame));
}
private static void polyomino_enumerate_free_test()
//****************************************************************************80
//
// Purpose:
//
// POLYOMINO_ENUMERATE_FREE_TEST tests POLYOMINO_ENUMERATE_FREE.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 13 April 2018
//
// Author:
//
// John Burkardt
//
{
int n_data = 0;
long number = 0;
int order = 0;
Console.WriteLine("");
Console.WriteLine("POLYOMINO_ENUMERATE_FREE_TEST:");
Console.WriteLine(" POLYOMINO_ENUMERATE_FREE returns the number of free");
Console.WriteLine(" polyominoes of a given order;");
n_data = 0;
Console.WriteLine("");
Console.WriteLine(" Order Number");
Console.WriteLine("");
for (;;)
{
Polyomino.polyomino_enumerate_free(ref n_data, ref order, ref number);
if (n_data == 0)
{
break;
}
Console.WriteLine(" " + order.ToString().PadLeft(4)
+ " " + number.ToString().PadLeft(24) + "");
}
}
public void HandleEvent(IShiftable sender, ShiftEventArgs e)
{
if (sender == null || e == null)
{
return;
}
if (e.Direction != LastDirection)
{
Counter = TimeSpan.Zero;
LastDirection = e.Direction;
DirectionChanged = true;
}
else
{
DirectionChanged = false;
}
if (sender is Mino)
{
Mino mino = sender as Mino;
Counter += mino.Game.TargetElapsedTime;
bool isHolding = !(Counter < HoldThreshold);
if (DirectionChanged || !DirectionChanged && isHolding)
{
mino.Position = Adjust(mino.Position, e.Direction);
}
}
if (sender is Polyomino)
{
Polyomino polyomino = sender as Polyomino;
Counter += polyomino.Game.TargetElapsedTime;
bool isHolding = !(Counter < HoldThreshold);
if (DirectionChanged || !DirectionChanged && isHolding)
{
foreach (Mino mino in polyomino.Minoes)
{
mino.Position = Adjust(mino.Position, e.Direction);
}
}
}
}
private static void polyomino_condense_demo(int mp, int np, int[] p)
//****************************************************************************80
//
// Purpose:
//
// polyomino_condense_demo demonstrates POLYOMINO_CONDENSE.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 29 April 2018
//
// Author:
//
// John Burkardt
//
// Parameters:
//
// Input, int MP, NP, the number of rows and columns in the representation
// of the polyomino P.
//
// Input, int P[MP*NP], a matrix representing the polyomino.
//
// Local, int MQ, NQ, the number of rows and columns in the representation
// of the condensed polyomino Q.
//
// Local, int Q[MQ*NQ], a matrix representing the condensed polyomino.
//
{
int mq = 0;
int nq = 0;
int[] q = null;
string label = " The initial (" + mp + "," + np + ") polynomino P:";
Polyomino.polyomino_print(mp, np, p, label);
Polyomino.polyomino_condense(mp, np, p, ref mq, ref nq, ref q);
label = " The condensed (" + mq + "," + nq + ") polynomino Q:";
Polyomino.polyomino_print(mq, nq, q, label);
}
public static void polyomino_chiral_count_values_test()
//****************************************************************************80
//
// Purpose:
//
// POLYOMINO_CHIRAL_COUNT_VALUES_TEST tests POLYOMINO_CHIRAL_COUNT_VALUES.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 18 May 2018
//
// Author:
//
// John Burkardt
//
{
long number = 0;
int order = 0;
Console.WriteLine("");
Console.WriteLine("POLYOMINO_CHIRAL_COUNT_VALUES_TEST:");
Console.WriteLine(" POLYOMINO_CHIRAL_COUNT_VALUES returns the number of chiral");
Console.WriteLine(" polyominoes of a given order;");
int n_data = 0;
Console.WriteLine("");
Console.WriteLine(" Order Number");
Console.WriteLine("");
for (;;)
{
Polyomino.polyomino_chiral_count_values(ref n_data, ref order, ref number);
if (n_data == 0)
{
break;
}
Console.WriteLine(" " + order.ToString().PadLeft(4) + order
+ " " + number.ToString().PadLeft(24) + number + "");
}
}
public Block(IEnumerable <Tile> tiles, Polyomino polymino)
{
this.tiles = tiles.ToList();
this.polymino = polymino;
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
// TODO: use this.Content to load your game content here
/*
* SimpleTetris.Core.Shape.Polyomino.Tetromino.TetrominoBuilder builder = new Core.Shape.Polyomino.Tetromino.TetrominoBuilder();
* SimpleTetris.Core.Shape.Polyomino.Tetromino.BuildDirectors.MinoSimpleDirector director = new Core.Shape.Polyomino.Tetromino.BuildDirectors.MinoSimpleDirector(builder);
*
* director.Texture = SimpleTetris.Core.Graphics.Helpers.CreateTexture(graphics.GraphicsDevice, System.Convert.ToInt32(SimpleTetris.Core.Settings.GraphicalSettings.UnitWidth), System.Convert.ToInt32(SimpleTetris.Core.Settings.GraphicalSettings.UnitHeight), x => Color.Blue);
* director.Direct(Core.Shape.Polyomino.Tetromino.Tetrominoes.S);
*
* testingMino = builder.Build();
*
* textureTile = Content.Load<Texture2D>("tile");
*/
/*
* this.Components.Add(new Core2.Piece.Mino(this, new System.Func<Texture2D>(() => {
* int w = 32;
* int h = 32;
* int sz = w * h;
*
* Texture2D texture = new Texture2D(GraphicsDevice, w, h);
*
* Color[] colors = new Color[sz];
*
* for (int i = 0; i < sz; ++i) colors[i] = Color.ForestGreen;
*
* texture.SetData(colors);
*
* return texture;
* })()));
*/
/*
* int unitWidth = 32;
* int unitHeight = 32;
*
* Texture2D texture = new System.Func<Texture2D>(() => {
* int w = 32;
* int h = 32;
* int sz = w * h;
*
* Texture2D tex = new Texture2D(GraphicsDevice, w, h);
*
* Color[] colors = new Color[sz];
*
* for (int i = 0; i < sz; ++i) colors[i] = Color.ForestGreen;
*
* tex.SetData(colors);
*
* return tex;
* })();
*
* Polyomino piece = new Polyomino(this);
*
* piece.Minoes.AddRange(new [] {
* new Mino(this, texture) {
* Position = new Vector2(1 * unitWidth, 0 * unitHeight)
* },
* new Mino(this, texture) {
* Position = new Vector2(0 * unitWidth, 1 * unitHeight)
* },
* new Mino(this, texture) {
* Position = new Vector2(1 * unitWidth, 1 * unitHeight)
* },
* new Mino(this, texture) {
* Position = new Vector2(2 * unitWidth, 1 * unitHeight)
* }
* });
*
* this.Components.Add(piece);
*/
int unitWidth = Properties.Settings.Default.UnitWidth;
int unitHeight = Properties.Settings.Default.UnitHeight;
Texture2D texture = new Func <Texture2D>(() => {
int w = unitWidth;
int h = unitHeight;
int sz = w * h;
Texture2D tex = new Texture2D(GraphicsDevice, w, h);
Color[] colors = new Color[sz];
for (int i = 0; i < sz; ++i)
{
colors[i] = Color.ForestGreen;
}
tex.SetData(colors);
return(tex);
})();
Action <object[]> painter = new Action <object[]>((args) => {
if (args.Length == 0)
{
return;
}
if (args[0] is Sprite)
{
Sprite sprite = args[0] as Sprite;
spriteBatch.Begin();
if (sprite.SpriteMode == SpriteModes.Single)
{
spriteBatch.Draw(
sprite.SamplingTexture,
sprite.Position * new Vector2(unitWidth, unitHeight),
null,
Color.White,
sprite.RotationAngle,
Vector2.Zero,
sprite.Scale,
SpriteEffects.None,
0
);
}
spriteBatch.End();
}
});
List <Mino> minoList = new List <Mino> {
new Mino(this)
{
Position = new Vector2(1, 0),
},
new Mino(this)
{
Position = new Vector2(0, 1)
},
new Mino(this)
{
Position = new Vector2(1, 1)
},
new Mino(this)
{
Position = new Vector2(2, 1)
}
};
foreach (Mino mino in minoList)
{
mino.SamplingTexture = texture;
mino.Painter = painter;
}
Polyomino polyomino = new Polyomino(this)
{
FallMechanics = new MinoFall(),
ShiftMechanics = new MinoShift(),
RotateMechanics = new MinoRotate()
};
foreach (Mino mino in minoList)
{
polyomino.Minoes.Add(mino);
}
polyomino.OriginMino = polyomino.Minoes[2];
Components.Add(polyomino);
}
private static void polyomino_transform_test()
//****************************************************************************80
//
// Purpose:
//
// POLYOMINO_TRANSFORM_TEST tests POLYOMINO_TRANSFORM.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 28 April 2018
//
// Author:
//
// John Burkardt
//
// Local parameters:
//
// Local, int M, N, the number of rows and columns in the representation
// of the polyomino P.
//
// Local, int P[M*N], a matrix of 0"s and 1"s representing the
// polyomino. The matrix should be "tight", that is, there should be a
// 1 in row 1, and in column 1, and in row M, and in column N.
//
{
const int m = 3;
int mq = 0;
const int n = 3;
int nq = 0;
//
// P is given by columns, not rows.
//
int[] p =
{
0, 1, 0,
1, 1, 1,
1, 0, 0
};
int[] q = null;
int reflect;
Console.WriteLine("");
Console.WriteLine("POLYOMINO_TRANSFORM_TEST:");
Console.WriteLine(" POLYOMINO_TRANSFORM can transform a polyomino.");
Console.WriteLine(" Generate all 8 combinations of rotation and reflection");
Console.WriteLine(" applied to a polyomino represented by a binary matrix.");
Polyomino.polyomino_print(m, n, p, " The given polyomino P:");
for (reflect = 0; reflect <= 1; reflect++)
{
int rotate;
for (rotate = 0; rotate <= 3; rotate++)
{
Polyomino.polyomino_transform(m, n, p, rotate, reflect, ref mq, ref nq, ref q);
string label = " P after " + reflect + " reflections and " + rotate + " rotations:";
Polyomino.polyomino_print(mq, nq, q, label);
}
}
Console.WriteLine("");
Console.WriteLine("POLYOMINO_TRANSFORM_TEST:");
Console.WriteLine(" Normal end of execution.");
}
private static void polyomino_index_test()
//****************************************************************************80
//
// Purpose:
//
// POLYOMINO_INDEX_TEST tests POLYOMINO_INDEX.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 30 April 2018
//
// Author:
//
// John Burkardt
//
{
int i;
const int m = 3;
const int n = 4;
//
// P is listed in column-major order;
//
int[] p =
{
1, 1, 0,
0, 1, 1,
1, 1, 1,
1, 0, 0
};
Console.WriteLine("");
Console.WriteLine("POLYOMINO_INDEX_TEST");
Console.WriteLine(" POLYOMINO_INDEX assigns an index to each nonzero entry");
Console.WriteLine(" of a polyomino.");
Polyomino.polyomino_print(m, n, p, " The polyomino P:");
int[] pin = Polyomino.polyomino_index(m, n, p);
Console.WriteLine("");
Console.WriteLine(" PIN: Index vector for P:");
Console.WriteLine("");
for (i = 0; i < m; i++)
{
string cout = "";
int j;
for (j = 0; j < n; j++)
{
cout += " " + pin[i + j * m];
}
Console.WriteLine(cout);
}
Console.WriteLine("");
Console.WriteLine("POLYOMINO_INDEX_TEST");
Console.WriteLine(" Normal end of execution.");
}
private static void polyomino_embed_list_test()
//****************************************************************************80
//
// Purpose:
//
// POLYOMINO_EMBED_LIST_TEST tests POLYOMINO_EMBED_LIST.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 02 May 2018
//
// Author:
//
// John Burkardt
//
{
int k;
const int mp = 3;
const int mr = 4;
const int np = 2;
const int nr = 4;
int[] p =
{
0, 0, 1,
1, 1, 1
};
int[] q = new int[4 * 4];
int[] r =
{
0, 1, 1, 1,
1, 1, 1, 0,
1, 0, 1, 1,
1, 1, 1, 1
};
Console.WriteLine("");
Console.WriteLine("POLYOMINO_EMBED_LIST_TEST:");
Console.WriteLine(" POLYOMINO_EMBED_LIST lists the offsets used");
Console.WriteLine(" to embed a fixed polyomino in a region.");
Polyomino.polyomino_print(mr, nr, r, " The given region R:");
Polyomino.polyomino_print(mp, np, p, " The given polyomino P:");
//
// Get the number of embeddings.
//
int number = Polyomino.polyomino_embed_number(mr, nr, r, mp, np, p);
Console.WriteLine("");
Console.WriteLine(" As a fixed polyomino, P can be embedded in R in " + number + " ways");
/*
* Get the list of embeddings.
*/
int[] list = Polyomino.polyomino_embed_list(mr, nr, r, mp, np, p, number);
for (k = 0; k < number; k++)
{
int mk = list[k + 0 * number];
int nk = list[k + 1 * number];
int i;
int j;
for (j = 0; j < nr; j++)
{
for (i = 0; i < mr; i++)
{
q[i + j * mr] = r[i + j * mr];
}
}
for (j = 0; j < np; j++)
{
for (i = 0; i < mp; i++)
{
q[i + mk + (j + nk) * mr] += p[i + j * mp];
}
}
Console.WriteLine("");
Console.WriteLine(" Embedding number " + k + ":");
Console.WriteLine("");
for (i = 0; i < mr; i++)
{
string cout = "";
for (j = 0; j < nr; j++)
{
cout += " " + q[i + j * mr];
}
Console.WriteLine(cout);
}
}
}
