/// <summary>
/// Metoda rozstrzygająca czy puzzle pasują do siebie oraz czy są na tyle blisko by je scalić/złączyć
/// </summary>
/// <param name="currentPiece">Aktualny puzzel</param>
/// <param name="adjacentPiece">Sąsiedni puzzel</param>
/// <returns>True - jeśli puzzle pasują do siebie, False - jeśli nie pasują, bądź są za daleko od siebie</returns>
public bool DetermineIfMergePieces(IPuzzlePiece currentPiece, IPuzzlePiece adjacentPiece)
{
// jeżeli obrót jest różny od 0 to nie można scalić dwóch kawałków
if (currentPiece.Rotation != 0 || adjacentPiece.Rotation != 0)
{
return(false);
}
if (adjacentPiece.ClusterId != currentPiece.ClusterId)
{
double topPositionDifference = Canvas.GetTop(currentPiece.PieceImage) - Canvas.GetTop(adjacentPiece.PieceImage);
double leftPositionDifference = Canvas.GetLeft(currentPiece.PieceImage) - Canvas.GetLeft(adjacentPiece.PieceImage);
// Sklejanie kawałków które przykładane są z lewej bądź prawej strony
if (currentPiece.Location.Y == adjacentPiece.Location.Y && Math.Abs(topPositionDifference) <= PuzzleSettings.SNAP_TOLERANCE)
{
if ((currentPiece.Location.X + 1 == adjacentPiece.Location.X && Math.Abs(leftPositionDifference + currentPiece.Width) <= PuzzleSettings.SNAP_TOLERANCE) ||
(currentPiece.Location.X - 1 == adjacentPiece.Location.X && Math.Abs(leftPositionDifference - currentPiece.Width) <= PuzzleSettings.SNAP_TOLERANCE))
{
return(true);
}
}
// Sklejanie kawałków które przykładane są z góry bądź z dołu
else if (currentPiece.Location.X == adjacentPiece.Location.X && Math.Abs(leftPositionDifference) <= PuzzleSettings.SNAP_TOLERANCE)
{
if ((currentPiece.Location.Y - 1 == adjacentPiece.Location.Y && Math.Abs(topPositionDifference - currentPiece.Height) <= PuzzleSettings.SNAP_TOLERANCE) ||
(currentPiece.Location.Y + 1 == adjacentPiece.Location.Y && Math.Abs(topPositionDifference + currentPiece.Height) <= PuzzleSettings.SNAP_TOLERANCE))
{
return(true);
}
}
}
return(false);
}
/// <summary>
/// Metoda dokonująca inicjalizacji pojedynczego kawałka puzzli
/// </summary>
/// <param name="piece">Kawałek puzzli</param>
private void InitPiece(IPuzzlePiece piece)
{
Image pieceImage = new Image
{
Source = piece.Picture,
Width = piece.Width,
Height = piece.Height,
Name = "p" + piece.ID
};
pieceImage.FocusVisualStyle = null;
pieceImage.AddHandler(MouseLeftButtonDownEvent, new MouseButtonEventHandler(PieceCluster_MouseLeftButtonDown));
pieceImage.AddHandler(MouseRightButtonDownEvent, new MouseButtonEventHandler(PieceCluster_MouseRightButtonDown));
pieceImage.AddHandler(MouseRightButtonUpEvent, new MouseButtonEventHandler(PieceCluster_MouseRightButtonUp));
pieceImage.AddHandler(MouseMoveEvent, new MouseEventHandler(PieceCluster_MouseMove));
pieceImage.AddHandler(MouseUpEvent, new MouseButtonEventHandler(PieceCluster_MouseUp));
pieceImage.AddHandler(MouseWheelEvent, new MouseWheelEventHandler(PieceCluster_MouseWheel));
pieceImage.AddHandler(KeyDownEvent, new KeyEventHandler(PieceCluster_KeyDown));
canvasRoot.Children.Add(pieceImage);
piece.PieceImage = pieceImage;
Canvas.SetLeft(pieceImage, _random.Next(0, (int)(mainGrid.ActualWidth - pieceImage.Width - 50)));
Canvas.SetTop(pieceImage, _random.Next(0, (int)(mainGrid.ActualHeight - pieceImage.Height - 50)));
}
protected override IRequest InternalToTransferCodeBase(IPuzzlePiece root, ITree<IPuzzlePiece> matchtree, Dictionary<string, object> bindings)
{
ILocation loca = TilingUtils.MatchLocation (matchtree.ChildAt(0x00).ChildAt(0x00).Data);
ILocation locb = TilingUtils.MatchLocation (matchtree.ChildAt(0x00).ChildAt(0x01).Data);
DateTime dt = bindings.ValueOrDefault<string,object,DateTime>("time");
string als = bindings.ValueOrDefault<string,object,string>("airlinecode");
string scs = bindings.ValueOrDefault<string,object,string>("classname");
Airline al = null;
SeatClass sc = null;
if(als != null) {
al = new Airline (als);
}
if(scs != null) {
sc = new SeatClass (scs);
}
if (loca is Country && locb is Country) {
return new RequestGetFlights ((Country)loca, (Country)locb, dt, al, sc);
} else if (loca is City && locb is City) {
return new RequestGetFlights ((City)loca, (City)locb, dt, al, sc);
} else if (loca is Airport && locb is Airport) {
return new RequestGetFlights ((Airport)loca, (Airport)locb, dt, al, sc);
} else {
return null;
}
}
public IXmlRequest ToTransferCode(IPuzzlePiece root)
{
ITree<IPuzzlePiece> tmp;
Tree<TypeBind>.ConjunctiveTreeSwapMatchPredicate(this.pattern,0x00,root,TypeBind.Match,out tmp);
Dictionary<string,object> bindings = new Dictionary<string, object>();
Tree<TypeBind>.ConjunctiveTreeNonSwapMatchPredicate(this.pattern,0x00,root,(x,y,z) => TypeBind.MatchAndBind(x,y,z,bindings));
return InternalToTransferCode(root, bindings);
}
public IRequest Tile(IPuzzlePiece ipp)
{
foreach(ITilePattern tp in patterns) {
if(tp.Match(ipp)) {
return tp.ToTransferCode(ipp);
}
}
return null;
}
protected override IRequest InternalToTransferCode(IPuzzlePiece root, Dictionary<string, object> bindings)
{
string ftc = (string) bindings["flighttemplatecode"];
string sac = (string) bindings["startcode"];
string soc = (string) bindings["stopcode"];
string apc = (string) bindings["airplanecode"];
int distance = (int) bindings["distance"];
DateTime sat = (DateTime) bindings["starttime"];
DateTime sot = (DateTime) bindings["stoptime"];
return new RequestAddFlight(new Flight(new FlightTemplate(ftc),sat,sot,new Airport(sac),new Airport(soc),new Airplane(apc),distance));
}
public IPuzzlePiece[] Resolve(IPuzzlePiece query)
{
IRequest ixq = Tile((RunPiece) query);
if(ixq == null) {
return new IPuzzlePiece[] {new SucceedFailPiece("No template")};
}
try {
return ixq.execute().ToPuzzlePieces().ToArray();
}
catch(Exception e) {
return new IPuzzlePiece[] {new SucceedFailPiece(e)};
}
}
/// <summary>
/// Metoda obracająca pojedynczy puzzel o losowy kąt (0, 90, 180, 270)
/// </summary>
/// <param name="pieceToRotate">Kawałek puzzli do obracania</param>
public void RotatePieceRandom(IPuzzlePiece pieceToRotate)
{
Matrix matrix = pieceToRotate.PieceImage.RenderTransform.Value;
int[] degrees = { 0, 90, 180, 270 };
int rotation = degrees[_random.Next(0, degrees.Length)];
double centerX = pieceToRotate.Width / 2;
double centerY = pieceToRotate.Height / 2;
pieceToRotate.Rotation = rotation;
matrix.RotateAtPrepend(rotation, centerX, centerY);
MatrixTransform matrixTransform = new MatrixTransform(matrix);
pieceToRotate.PieceImage.RenderTransform = matrixTransform;
}
protected override IRequest InternalToTransferCode(IPuzzlePiece root, Dictionary<string, object> bindings)
{
List<Seat> seats = new List<Seat>();
int n = root.NumberOfChildren;
Dictionary<string,object> bind = new Dictionary<string,object>();
for(int i = 0x01; i < n; i++) {
if(Tree<TypeBind>.ConjunctiveTreeNonSwapMatchPredicate(bindseattree,0x00,root[i],(x,y,z) => TypeBind.MatchBind(x,y,z,bind),TypeBind.GetOptional)) {
//(bindseat.MatchBind(i,root[i],bind))) {
//if(bind["number"] != null) {
int m = (int) bind["number"];
SeatClass sc = new SeatClass((string) bind["name"]);
seats.Add(new Seat(sc,m));
//}
bind.Clear();
}
}
return new RequestAddAirplane(new Airplane((string) bindings["airplanetype"],seats,(string) bindings["airplanecode"]));
}
public virtual void MatchesConstraintsParent(IPuzzlePiece piece)
{
}
protected override IRequest InternalToTransferCode(IPuzzlePiece root, Dictionary<string, object> bindings)
{
return new RequestAddCity(new City((string) bindings["cityname"],new Country((string) bindings["countryname"])));
}
public virtual void MatchesConstraintsChildren(int index, IPuzzlePiece piece)
{
if (!ExtensionMethods.IsTypeColorMatch (this.TypeColorArguments [index], piece.TypeColors)) {
throw new ArgumentException(string.Format("The given piece doesn't match with it's parent: {0} versus {1}",piece.TypeColors,this.TypeColorArguments[index]));
}
}
public static bool MatchAndBind(TypeBind tb, int index, IPuzzlePiece ipp, Dictionary<string,object> tobind)
{
if(Match(tb,index,ipp)) {
if(tb.bindingtable != null && tb.bindingtable.Count > 0x00) {
if(!(ipp is IKeyValueTablePuzzlePiece<string,object>)) {
return false;
}
KeyValueTable<string,object> conv = ((IKeyValueTablePuzzlePiece<string,object>) ipp).Table;
foreach(KeyValuePair<string,string> entry in tb.bindingtable) {
Console.WriteLine("Bind key {0} of {1}",entry.Key,ipp);
try {
tobind.Add(entry.Value,conv[entry.Key]);
}
catch {
return false;
}
}
}
return true;
}
return false;
}
public void MatchesConstraintsChildren(int index, IPuzzlePiece piece)
{
}
public static bool Match(TypeBind tb, int index, IPuzzlePiece ipp)
{
return (ipp != null && (tb.index == -0x01 || tb.index == index) && ipp.Match(tb));
}
public bool Match(IPuzzlePiece ipp, int index)
{
return Match(this,index,ipp);
}
private void AddGap(Gdk.EventButton evnt, IPuzzlePiece source)
{
int index;
IPuzzlePiece ipp = this.rootpiece.GetPuzzleGap (this.subcontext, new PointD (evnt.X - Margin, evnt.Y - Margin), out index);
if (ipp != null) {
try {
ipp [index] = source;
} catch (Exception e) {
ExtensionMethods.ShowException (e);
}
}
}
protected override bool OnButtonPressEvent(Gdk.EventButton evnt)
{
PointD p = new PointD(evnt.X,evnt.Y);
IPuzzlePiece ipp;
switch (this.Tool) {
case SketchPadTool.CreateNew:
if (this.injectionPiece != null && this.rootpiece != null) {
this.AddGap(evnt,(IPuzzlePiece)this.injectionPiece.Invoke (emptyArgs));
}
break;
case SketchPadTool.Link :
if(this.linkpiece == null) {
this.linkpiece = this.GetPuzzlePiece(p);
}
else {
this.AddGap(evnt,new LinkPiece(this.linkpiece));
this.linkpiece = null;
}
break;
case SketchPadTool.Remove :
ipp = this.GetPuzzlePiece(p);
if(ipp != null) {
if(ipp.PieceParent != null) {
ipp.Kill();
ipp.PieceParent[ipp.Index] = null;
}
}
break;
case SketchPadTool.Modify :
ipp = this.GetPuzzlePiece(p);
if(ipp != null) {
if(ipp is IKeyValueTablePuzzlePiece<string,object>) {
KeyValueTableEditor<string,object>.RunDialog((ipp as IKeyValueTablePuzzlePiece<string,object>).Table);
}
else {
ExtensionMethods.ShowException("Cannot modify: the selected piece doesn't contain any information!");
}
ipp.InvalidateSizeCache();
}
break;
}
this.QueueDraw ();
return base.OnButtonPressEvent (evnt);
}
protected virtual IRequest InternalToTransferCode(IPuzzlePiece root)
{
return null;
}
protected virtual IRequest InternalToTransferCodeBase(IPuzzlePiece root, ITree<IPuzzlePiece> sortedtree, Dictionary<string, object> bindings)
{
return InternalToTransferCode(root,bindings);
}
protected virtual IRequest InternalToTransferCode(IPuzzlePiece root, Dictionary<string, object> bindings)
{
return InternalToTransferCode(root);
}
public IRequest ToTransferCode(IPuzzlePiece root)
{
return TilingUtils.MatchBindExecute (this.pattern, root, this.InternalToTransferCodeBase);
}
public bool Match(IPuzzlePiece root)
{
ITree<IPuzzlePiece> tmp;
bool res = Tree<TypeBind>.ConjunctiveTreeSwapMatchPredicate(this.pattern,0x00,root,TypeBind.Match,TypeBind.GetOptional,out tmp);
return res;
}
protected void SetArgumentSize()
{
int nmin = Math.Min(this.arguments.Length,this.NumberOfArguments);
IPuzzlePiece[] newarguments = new IPuzzlePiece[this.NumberOfArguments];
Rectangle[] newsubpieces = new Rectangle[this.NumberOfArguments];
for(int i = 0x00; i < nmin; i++) {
newarguments[i] = this.arguments[i];
}
for(int i = nmin; i < this.arguments.Length; i++) {
this[i] = null;
}
this.arguments = newarguments;
this.subpieces = newsubpieces;
this.PerformBoundsChanged(this,EventArgs.Empty);
}
protected override IRequest InternalToTransferCode(IPuzzlePiece root, Dictionary<string, object> bindings)
{
return new RequestAddAirline(new Airline((string) bindings["airlinename"],(string) bindings["airlinecode"]));
}
public static bool MatchBind(TypeBind tb, int index, IPuzzlePiece ipp, Dictionary<string,object> tobind)
{
if(Match(tb,index,ipp)) {
return ipp.MatchBind(tb,tobind);
}
return false;
}
public bool Match(IPuzzlePiece root)
{
ITree<IPuzzlePiece> tmp;
return Tree<TypeBind>.ConjunctiveTreeSwapMatchPredicate(this.pattern,0x00,root,TypeBind.Match,out tmp);
}
public UnableToBindException(string key, IPuzzlePiece piece)
{
this.key = key;
this.piece = piece;
}
public bool MatchBind(int index, IPuzzlePiece ipp, Dictionary<string,object> tobind)
{
return TypeBind.MatchBind(this,index,ipp,tobind);
}
public static bool Match(TypeBind tb, int index, IPuzzlePiece ipp)
{
return (ipp != null && tb.type.IsAssignableFrom(ipp.GetType()) && (tb.index == -0x01 || tb.index == index));
}
protected abstract IXmlRequest InternalToTransferCode(IPuzzlePiece root, Dictionary<string, object> bindings);
protected override IRequest InternalToTransferCode(IPuzzlePiece root, Dictionary<string, object> bindings)
{
return new RequestAddBooking(new Booking(new Passenger((string) bindings["passengername"]),
new Flight(new FlightTemplate((string) bindings["flighttemplatecode"]),
(DateTime) bindings["time"]),new Seat(new SeatClass((string) bindings["classname"]),(int) bindings["seatnumber"])));
}
private QueryAnswerLocations(RunPiece query, PointD offset, IPuzzlePiece[] answer, PointD[] locations)
{
this.query = query;
this.offset = offset;
this.answers = answer;
this.locations = locations;
this.registerChildren();
}