void BuildCorner3(SubMesh data, CardShape shape, Vector3 v0, Vector3 v1, Vector3 v2)
{
CardStock Stock = Definition.Stock;
int smooth = Stock.Smooth;
int vbase = data.VertexList.Count;
this.VertexUV(data, shape, v0, UV(shape, 0, 1));
this.VertexUV(data, shape, v1, UV(shape, 0, 1));
this.VertexUV(data, shape, v2, UV(shape, 1, 0));
float deltaAngle = 0.5f * Mathf.PI / (smooth + 1);
int prev = vbase + 1;
Vector3 vy = v1 - v0;
Vector3 vx = v2 - v0;
for (int i = 0; i <= smooth; ++i)
{
if (i < smooth)
{
float angle = (i + 1) * deltaAngle;
float tu = Mathf.Sin(angle);
float tv = Mathf.Cos(angle);
Vector3 xyz = v0 + tu * vx + tv * vy;
Vector2 uv = UV(shape, tu, tv);
data.AddVertex(xyz, uv, Color.white);
}
int vn = vbase + 3 + i;
int vprev = (i == 0) ? vbase + 1 : vn - 1;
int vnext = (i < smooth) ? vn : vbase + 2;
data.AddTriangle(vbase, vprev, vnext);
prev = vn;
}
}
void BuildBack(CardMesh card, Dictionary <Texture2D, SubMesh> table, CardShape paper)
{
CardShape back = Atlas.FindById(Stock.Back);
if (back != null)
{
Vector3[] v = RectPoints(Stock.Size * Stock.Scale, Stock.BackBorder * Stock.Scale);
SubMesh core = GetMesh(card, table, back);
// middle
if (Stock.HalfBack)
{
Square4(core, back, v[1], v[0], v[12], v[13], Color.white, false, false);
Square4(core, back, v[13], v[12], v[3], v[2], Color.white, true, true);
}
else
{
Square4(core, back, v[1], v[0], v[3], v[2], Color.white, false, false);
}
// top
Square4(core, paper, v[5], v[4], v[0], v[1], Color.white, false, false);
// back-left
Square5(core, paper, v[2], v[7], v[6], v[1], v[13], Color.white, false);
// bottom
Square4(core, paper, v[2], v[3], v[9], v[8], Color.white, false, false);
// back-right
Square5(core, paper, v[0], v[11], v[10], v[3], v[12], Color.white, false);
BuildCorner3(core, paper, v[1], v[6], v[5]);
BuildCorner3(core, paper, v[2], v[8], v[7]);
BuildCorner3(core, paper, v[3], v[10], v[9]);
BuildCorner3(core, paper, v[0], v[4], v[11]);
}
}
Vector2 UV(CardShape shape, float tu, float tv)
{
float u = Mathf.Lerp(shape.Min.x, shape.Max.x, tu);
float v = Mathf.Lerp(shape.Min.y, shape.Max.y, tv);
return(new Vector2(u, v));
}
void Square5(SubMesh data, CardShape shape, Vector3 v0, Vector3 v1, Vector3 v2, Vector3 v3, Vector3 v4, Color color, bool flip)
{
int vi = data.VertexList.Count;
Vector2 t0 = shape.UV0;
Vector2 t1 = shape.UV1;
Vector2 t2 = shape.UV2;
Vector2 t3 = shape.UV3;
Vector2 t4 = (t0 + t3) / 2;
if (!flip)
{
data.AddVertex(v0, t3, color);
data.AddVertex(v1, t2, color);
data.AddVertex(v2, t1, color);
data.AddVertex(v3, t0, color);
data.AddVertex(v4, t4, color);
}
else
{
data.AddVertex(v0, t0, color);
data.AddVertex(v1, t1, color);
data.AddVertex(v2, t2, color);
data.AddVertex(v3, t3, color);
data.AddVertex(v4, t4, color);
}
data.AddTriangle(vi + 4, vi + 0, vi + 1);
data.AddTriangle(vi + 4, vi + 1, vi + 2);
data.AddTriangle(vi + 4, vi + 2, vi + 3);
}
private void GameShape_CardMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
//zablokuj eventy
//GameShape.CardDrag -= new CardDragEventHandler(GameShape_CardDrag);
GameShape.CardMouseLeftButtonDown -= new MouseButtonEventHandler(GameShape_CardMouseLeftButtonDown);
bool renons;
//klikniecie na karte sprobuje zagrac karte
var cardShapeClicked = (CardShape)sender;
CardShape card = (CardShape)sender;
var gameShape = GameShape.GetGameShape(card.Card.Deck.Game);
var oldDeckShape = gameShape.GetDeckShape(card.Card.Deck);
if (oldDeckShape.Name == "Player4Hand")
{
//karta ktora chce zagrac gracz
Card userPlayedCard = new Card(card.Card);
//wygeneruj mozliwe ruchy gracza
Deck player4Moves = new Deck(Player4Hand.Deck);
player4Moves = GameRules.PossibleMoves(Player4Hand.Deck, WistCard, HeartsOpen, out renons);
Player4Hand.Deck.Sort();
//sprawdz czy karta ktora chce zagrac gracz jest w jego mozliwych ruchac
if (player4Moves.Has(userPlayedCard.Rank, userPlayedCard.Suit))
{
Player4UsedCards.AddPlayed(userPlayedCard);
Player4UsedCards.SortHigh();
//jezeli graz jest wistujacym to jego ruch staje sie karta wistujaca
if (WistPlayerNumber == 4)
{
WistCard = userPlayedCard;
}
//jezeli nie jest to sprawdz czy nie ma krotkosci
else if (renons)
{
Player4UsedCards.CardRenons[WistCard.Suit] = true;
}
card.Card.Deck = Player4Trick.Deck;
currentTrick.Add(userPlayedCard);
//jezeli zagral kiera to otworz kiery
if (userPlayedCard.Suit == CardSuit.Hearts)
{
HeartsOpen = true;
}
EndTrick();
return;
}
}
//Nie zagral prawidlowej karty - odblokuj klikanie
GameShape.CardMouseLeftButtonDown += GameShape_CardMouseLeftButtonDown;
//GameShape.CardMouseLeftButtonDown += new MouseButtonEventHandler(GameShape_CardMouseLeftButtonDown);
//gameShape.GetDeckShape(card.Card.Deck).UpdateCardShapes();
UpdateAllCardShapes();
//Canvas.SetZIndex(oldDeckShape, 0);
}
public Card(CardShape _shape, ShapeCount _shapeCount, ShapeColor _shapeColor, ShapeFill _shapeFill)
{
Shape = _shape;
ShapeCount = _shapeCount;
ShapeColor = _shapeColor;
ShapeFill = _shapeFill;
IsClicked = false;
}
void SquareFlip(SubMesh data, CardShape shape, Vector3 pos, Vector2 size, Color color, bool vflip, bool hflip)
{
Vector3 v0 = pos + new Vector3(-size.x, +size.y, 0);
Vector3 v1 = pos + new Vector3(+size.x, +size.y, 0);
Vector3 v2 = pos + new Vector3(+size.x, -size.y, 0);
Vector3 v3 = pos + new Vector3(-size.x, -size.y, 0);
Square4(data, shape, v0, v1, v2, v3, color, vflip, hflip);
}
private DeckMatch ValidateCard(DeckName targetDeck, CardShape moveableItemCardShape, int moveableItemCardValue, CardName?cardName, CardShape?cardShape, int cardValue)
{
DeckMatch matchState = DeckMatch.NotFound;
if (cardName == null && cardShape == null)
{
return(matchState = DeckMatch.Found);
}
var targetCard = _openDecks[targetDeck].Find(c => (c.CardName == cardName && c.CardShape == cardShape));
if (targetCard == null && moveableItemCardValue == 13)
{
return(matchState = DeckMatch.Found);
}
if (targetCard == null)
{
return(matchState = DeckMatch.NotFound);
}
if (targetCard.CardPath == Properties.Resources.BackCardPath)
{
return(matchState = DeckMatch.Found);
}
//if (targetCard.CardPath == Properties.Resources.EmptyCardPath && moveableItemCardValue == 14) return matchState = DeckMatch.Found;
if ((moveableItemCardShape == CardShape.Hearts || moveableItemCardShape == CardShape.Diamonds) &&
(targetCard.CardShape == CardShape.Clubs || targetCard.CardShape == CardShape.Spades))
{
matchState = DeckMatch.Found;
}
else if ((moveableItemCardShape == CardShape.Clubs || moveableItemCardShape == CardShape.Spades) &&
(targetCard.CardShape == CardShape.Hearts || targetCard.CardShape == CardShape.Diamonds))
{
matchState = DeckMatch.Found;
}
else
{
return(DeckMatch.NotFound);
}
if (targetCard.CardValue - moveableItemCardValue == 1)
{
matchState = DeckMatch.Found;
}
else
{
matchState = DeckMatch.NotFound;
}
return(matchState);
}
void Square(SubMesh data, CardShape shape, Vector3 pos, Vector2 size, Color color)
{
int vi = data.VertexList.Count;
Vector2 t0 = shape.UV0;
Vector2 t1 = shape.UV1;
Vector2 t2 = shape.UV2;
Vector2 t3 = shape.UV3;
data.AddVertex(pos + new Vector3(-size.x, +size.y, 0), t0, color);
data.AddVertex(pos + new Vector3(+size.x, +size.y, 0), t1, color);
data.AddVertex(pos + new Vector3(+size.x, -size.y, 0), t2, color);
data.AddVertex(pos + new Vector3(-size.x, -size.y, 0), t3, color);
data.AddTriangle(vi, vi + 1, vi + 2);
data.AddTriangle(vi, vi + 2, vi + 3);
}
void Square4(SubMesh data, CardShape shape, Vector3 v0, Vector3 v1, Vector3 v2, Vector3 v3, Color color, bool vflip, bool hflip)
{
int vi = data.VertexList.Count;
Vector2 t0 = shape.UV3;
Vector2 t1 = shape.UV2;
Vector2 t2 = shape.UV1;
Vector2 t3 = shape.UV0;
if (!vflip)
{
if (hflip)
{
data.AddVertex(v0, t2, color);
data.AddVertex(v1, t3, color);
data.AddVertex(v2, t0, color);
data.AddVertex(v3, t1, color);
}
else
{
data.AddVertex(v0, t3, color);
data.AddVertex(v1, t2, color);
data.AddVertex(v2, t1, color);
data.AddVertex(v3, t0, color);
}
}
else
{
if (hflip)
{
data.AddVertex(v0, t1, color);
data.AddVertex(v1, t0, color);
data.AddVertex(v2, t3, color);
data.AddVertex(v3, t2, color);
}
else
{
data.AddVertex(v0, t0, color);
data.AddVertex(v1, t1, color);
data.AddVertex(v2, t2, color);
data.AddVertex(v3, t3, color);
}
}
data.AddTriangle(vi, vi + 1, vi + 2);
data.AddTriangle(vi, vi + 2, vi + 3);
}
public void SetFllipedCardBinding(DeckName sourceDeck, CardName cardName, CardShape cardShape)
{
var containerToFlip = _openDecks[sourceDeck].Find(c => c.CardName == cardName && c.CardShape == cardShape);
if (containerToFlip.SubContainer != null)
{
return;
}
var frontPath = containerToFlip.FrontCardPath;
containerToFlip.CardPath = frontPath;
switch (sourceDeck)
{
case DeckName.FirstDeck:
FirstDeckCards = _openDecks[sourceDeck];
break;
case DeckName.SecondDeck:
SecondDeckCards = _openDecks[sourceDeck];
break;
case DeckName.ThirdDeck:
ThirdDeckCards = _openDecks[sourceDeck];
break;
case DeckName.FourthDeck:
FourthDeckCards = _openDecks[sourceDeck];
break;
case DeckName.FifthDeck:
FifthDeckCards = _openDecks[sourceDeck];
break;
case DeckName.SixthDeck:
SixthDeckCards = _openDecks[sourceDeck];
break;
case DeckName.SeventhDeck:
SeventhDeckCards = _openDecks[sourceDeck];
break;
}
}
private void GameShape_CardDrag(CardShape cardShape, DeckShape oldDeckShape, DeckShape newDeckShape)
{
// check for lead suit renege
if (((newDeckShape.Deck.TopCard == null) && (cardShape.Card.Number == 1)) ||
((newDeckShape.Deck.TopCard != null) && (cardShape.Card.Suit == newDeckShape.Deck.TopCard.Suit) && (cardShape.Card.Number - 1 == newDeckShape.Deck.TopCard.Number)))
{
//Move card to stack
cardShape.Card.Deck = newDeckShape.Deck;
//Flip the first remaining card in the old deck
if (oldDeckShape.Deck.TopCard != null)
{
oldDeckShape.Deck.TopCard.Visible = true;
oldDeckShape.Deck.TopCard.Enabled = true;
oldDeckShape.Deck.TopCard.IsDragable = true;
}
}
}
// Optional support for multiple atlases or textures
SubMesh GetMesh(CardMesh card, Dictionary <Texture2D, SubMesh> table, CardShape shape)
{
if (shape != null)
{
if (table.ContainsKey(shape.Image))
{
return(table[shape.Image]);
}
Material mat = LastMat;
if (LastMat == null || LastMat.mainTexture != shape.Image || LastMat.shader != Stock.DefaultMaterial.shader)
{
mat = new Material(Stock.DefaultMaterial); //new Material(Shader.Find("Diffuse"));
mat.mainTexture = shape.Image;
LastMat = mat;
}
SubMesh newMesh = card.NewSubMesh(mat);
table[shape.Image] = newMesh;
return(newMesh);
}
return(null);
}
protected void gameShape_CardDrag(CardShape cardShape, DeckShape oldDeckShape, DeckShape newDeckShape)
{
if (oldDeckShape.Deck != newDeckShape.Deck)
{
//To Row Decks
if (rowDecks.Contains(newDeckShape.Deck))
{
//Color/Rank Rules
if (((newDeckShape.Deck.TopCard != null) && (cardShape.Card.Color != newDeckShape.Deck.TopCard.Color) && (cardShape.Card.Number + 1 == newDeckShape.Deck.TopCard.Number)) ||
((newDeckShape.Deck.TopCard == null) && (cardShape.Card.Rank == CardRank.King)))
{
//Move the current card with all cards after it to the new deck
for (int i = oldDeckShape.Deck.Cards.IndexOf(cardShape.Card); i < oldDeckShape.Deck.Cards.Count; i++)
{
oldDeckShape.Deck.Cards[i].Deck = newDeckShape.Deck;
i--;
}
//Flip the first remaining card in the old deck
if (oldDeckShape.Deck.TopCard != null)
{
oldDeckShape.Deck.TopCard.Visible = true;
oldDeckShape.Deck.TopCard.Enabled = true;
oldDeckShape.Deck.TopCard.IsDragable = true;
}
}
}
//To Stack Decks
if (stackDecks.Contains(newDeckShape.Deck))
{
//Must be dragging one card only
if (oldDeckShape.Deck.Cards.IndexOf(cardShape.Card) == oldDeckShape.Deck.Cards.Count - 1)
{
if (((newDeckShape.Deck.TopCard == null) && (cardShape.Card.Number == 1)) ||
((newDeckShape.Deck.TopCard != null) && (cardShape.Card.Suit == newDeckShape.Deck.TopCard.Suit) && (cardShape.Card.Number - 1 == newDeckShape.Deck.TopCard.Number)))
{
//Move card to stack
cardShape.Card.Deck = newDeckShape.Deck;
//Flip the first remaining card in the old deck
if (oldDeckShape.Deck.TopCard != null)
{
oldDeckShape.Deck.TopCard.Visible = true;
oldDeckShape.Deck.TopCard.Enabled = true;
oldDeckShape.Deck.TopCard.IsDragable = true;
}
//Check for winning condition
bool win = true;
for (int i = 0; i < 4; i++)
{
if ((stackDecks[i].TopCard == null) || (stackDecks[i].TopCard.Rank != CardRank.King))
win = false;
}
if (win)
{
DoWinAnimation();
}
}
}
}
}
}
public void Rebuild()
{
if (!IsValid())
{
Debug.LogError("The card definition is not valid. " + this.name);
return;
}
Stock.Validate();
Dictionary <Texture2D, SubMesh> table = new Dictionary <Texture2D, SubMesh>();
CardMesh card = new CardMesh();
CardShape paper = Definition.Atlas.FindById(Definition.Stock.Paper);
if (paper == null)
{
Debug.LogError("Paper does not exist in atlas = " + Definition.Atlas.name + "::" + Definition.Stock.Paper);
return;
}
SubMesh data = GetMesh(card, table, paper);
float x = Stock.Size.x * Stock.Scale / 2;
float y = Stock.Size.y * Stock.Scale / 2;
float bx = Mathf.Max(Stock.CornerSize, Stock.Border.x) * Stock.Scale;
float by = Mathf.Max(Stock.CornerSize, Stock.Border.y) * Stock.Scale;
//float cx = x-bx;
//float cy = y-by;
// 4 5
// B 0 1 6
// C D
// A 3 2 7
// 9 8
float crad = Stock.CornerSize;
Vector2 cxy = new Vector2(crad, crad);
Vector3[] v = RectPoints(Stock.Size * Stock.Scale, Stock.Scale * cxy);
Vector3 c0 = new Vector3(-x + bx, +y - by, 0);
Vector3 c1 = new Vector3(+x - bx, +y - by, 0);
Vector3 c2 = new Vector3(+x - bx, -y + by, 0);
Vector3 c3 = new Vector3(-x + bx, -y + by, 0);
if (Stock.Smooth > 0)
{
// middle
Square4(data, paper, v[0], v[1], v[2], v[3], Color.white, false, false);
// top
Square4(data, paper, v[4], v[5], v[1], v[0], Color.white, false, false);
// right
Square4(data, paper, v[1], v[6], v[7], v[2], Color.white, false, false);
// bottom
Square4(data, paper, v[3], v[2], v[8], v[9], Color.white, false, false);
// left
Square4(data, paper, v[11], v[0], v[3], v[10], Color.white, false, false);
BuildCorner3(data, paper, v[0], v[11], v[4]);
BuildCorner3(data, paper, v[1], v[5], v[6]);
BuildCorner3(data, paper, v[2], v[7], v[8]);
BuildCorner3(data, paper, v[3], v[9], v[10]);
}
else // simple rectangle
{
Vector3 p1 = new Vector3(-x, +y, 0);
Vector3 p2 = new Vector3(+x, +y, 0);
Vector3 p3 = new Vector3(+x, -y, 0);
Vector3 p4 = new Vector3(-x, -y, 0);
Square4(data, paper, p1, p2, p3, p4, Color.white, false, false);
}
Vector2 textSize = Stock.TextSize * Stock.Scale;
float s1 = Stock.BigSymbolSize * Stock.Scale;
float s2 = Stock.SymbolSize * Stock.Scale;
float s3 = Stock.CornerSymbolSize * Stock.Scale;
//float symW = s2;
//float symH = s2;
//float rimX = Mathf.Max(textSize.x,symW);
//float rimY = Mathf.Max(textSize.y,symH);
CardShape symbol = Atlas.FindById(Definition.Symbol);
if (symbol == null && !string.IsNullOrEmpty(Definition.Symbol))
{
Debug.LogError(string.Format("Symbol shape '{0}' is not defined in atlas.", Definition.Symbol));
}
// Full Image is used by cards like ACE/JOKER that might want a fully unique face image
// Half Image is used by cards like JQK where half image is flipped and reflected for the top/bottom of the face image
// Pattern is used to form standard layout of suit symbols for 2-10 cards
CardShape fullImage = Definition.FullImage ? Atlas.FindById(Definition.Image) : null;
CardShape halfImage = !Definition.FullImage ? Atlas.FindById(Definition.Image) : null;
if (fullImage != null)
{
SubMesh core = GetMesh(card, table, fullImage);
//Square4 (core,fullImage,v[0],v[1],v[2],v[3],Color.white,false,false);
Square4(core, fullImage, c0, c1, c2, c3, Color.white, false, false);
}
else if (halfImage != null)
{
SubMesh core = GetMesh(card, table, halfImage);
Vector3 lift = new Vector3(0, 0, -0.01f);
Square4(core, halfImage, v[0] + lift, v[1] + lift, v[13] + lift, v[12] + lift, Color.white, false, false);
Square4(core, halfImage, v[12] + lift, v[13] + lift, v[2] + lift, v[3] + lift, Color.white, true, true);
}
else if (Definition.Pattern != 0 && symbol != null)
{
if (Definition.Pattern >= 1 && Definition.Pattern < patternBits.Length)
{
SubMesh core = GetMesh(card, table, symbol);
int bits = patternBits[Definition.Pattern];
float x0 = -x + bx;
float x1 = +x - bx;
float y0 = +y - by;
float y1 = -y + by;
for (int b = 0; b < 17; b++)
{
if ((bits & (1 << b)) != 0)
{
float px = Mathf.Lerp(x0, x1, patternPos[b].x);
float py = Mathf.Lerp(y0, y1, patternPos[b].y);
Vector2 symSize = (Definition.Pattern == 1) ? new Vector2(s1, s1) : new Vector2(s2, s2);
if (Stock.AlwaysUpright || patternUpper[b])
{
Square(core, symbol, new Vector3(px, py, -0.01f), symSize, Color.white);
}
else
{
SquareFlip(core, symbol, new Vector3(px, py, -0.01f), symSize, Color.white, true, true);
}
}
}
}
else
{
Debug.LogError(string.Format("Pattern value '{0}' is not valid.", Definition.Pattern));
}
}
// Text is used for number/letter in corner of card (ex. A for Ace)
CardShape text = Atlas.FindById(Definition.Text);
if (text == null && !string.IsNullOrEmpty(Definition.Text))
{
Debug.LogError(string.Format("Text shape '{0}' is not defined in atlas.", Definition.Text));
}
if (text != null)
{
float tx = Stock.TextOffset.x * Stock.Scale;
float ty = Stock.TextOffset.y * Stock.Scale;
SubMesh sub = GetMesh(card, table, text);
float x0 = -x + tx; // + (bx+rimX)*0.5f;
float x1 = +x - tx; // - (bx+rimX)*0.5f;
float y0 = +y - ty; //by;
float y1 = -y + ty; //by;
Color color = GetSymbolColor(Definition.Symbol);
Square(sub, text, new Vector3(x0, y0, -0.01f), textSize, color);
if (Stock.AlwaysUpright)
{
Square(sub, text, new Vector3(x1, y1, -0.01f), textSize, color);
}
else
{
SquareFlip(sub, text, new Vector3(x1, y1, -0.01f), textSize, color, true, true);
}
}
// Symbol is used for corner suit icons (heart,diamond,spade,club)
if (symbol != null)
{
float sx = Stock.SymbolOffset.x * Stock.Scale;
float sy = Stock.SymbolOffset.y * Stock.Scale;
SubMesh sub = GetMesh(card, table, symbol);
//float gapY = s3/3;
float x0 = -x + sx; //(bx+rimX)*0.5f;
float x1 = +x - sx; //(bx+rimX)*0.5f;
float y0 = +y - sy; //by - textSize.y - gapY - rad;
float y1 = -y + sy; //by + textSize.y + gapY + rad;
Color color = GetSymbolColor(Definition.Symbol);
Vector2 halfSym = new Vector2(s3, s3);
// Top-left corner symbol
Square(sub, symbol, new Vector3(x0, y0, -0.01f), halfSym, color);
// Bottom-right symbol can be up-right or upside-down depending on preferences
if (Stock.AlwaysUpright)
{
Square(sub, symbol, new Vector3(x1, y1, -0.01f), halfSym, color);
}
else
{
SquareFlip(sub, symbol, new Vector3(x1, y1, -0.01f), halfSym, color, true, true);
}
}
if (Stock.TwoSided)
{
BuildBack(card, table, paper);
/*
* CardShape back = Atlas.FindById(Stock.Back);
* if (back != null)
* {
* Vector3 [] v = RectPoints(Stock.Size*Stock.Scale,Stock.BackBorder*Stock.Scale);
*
* SubMesh core = GetMesh(card,table,back);
* // middle
* if (Stock.HalfBack)
* {
* Square4(core,back,v[1],v[0],v[12],v[13],Color.white,false,false);
* Square4(core,back,v[13],v[12],v[3],v[2],Color.white,true,true);
* }
* else
* {
* Square4(core,back,v[1],v[0],v[3],v[2],Color.white,false,false);
* }
* // top
* Square4(core,paper,v[5],v[4],v[0],v[1],Color.white,false,false);
* // back-left
* Square5(core,paper,v[2],v[7],v[6],v[1],v[13],Color.white,false);
* // bottom
* Square4(core,paper,v[2],v[3],v[9],v[8],Color.white,false,false);
* // back-right
* Square5(core,paper,v[0],v[11],v[10],v[3],v[12],Color.white,false);
*
* BuildCorner3(core, paper, v[1],v[6],v[5]);
* BuildCorner3(core, paper, v[2],v[8],v[7]);
* BuildCorner3(core, paper, v[3],v[10],v[9]);
* BuildCorner3(core, paper, v[0],v[4],v[11]);
* }
*/
}
Mesh mesh = SetupMesh();
mesh.vertices = card.GetCombinedVertices().ToArray();
mesh.triangles = data.IndexList.ToArray();
mesh.uv = card.GetCombinedTexCoords().ToArray();
mesh.colors = card.GetCombinedColors().ToArray();
if (card.MeshList.Count > 1)
{
mesh.subMeshCount = card.MeshList.Count;
int vbase = 0;
for (int i = 1; i < card.MeshList.Count; ++i)
{
SubMesh sub = card.MeshList[i];
int[] tris = sub.IndexList.ToArray();
vbase += card.MeshList[i - 1].VertexList.Count;
for (int t = 0; t < tris.Length; ++t)
{
tris[t] += vbase;
}
mesh.SetTriangles(tris, i);
}
}
mesh.RecalculateBounds();
mesh.Optimize();
mesh.RecalculateNormals();
this.GetComponent <Renderer>().sharedMaterials = card.Materials.ToArray();
// Setup Collider
this.gameObject.AddComponent <BoxCollider2D>();
// Mark as not clicked
this.Clicked = false;
}
static public void Generate(AtlasDesc desc)
{
Debug.Log("Generate");
string path = null;
Texture2D txm = desc.Target;
if (txm == null)
{
txm = new Texture2D(1, 1, TextureFormat.ARGB32, true);
path = AssetDatabase.GetAssetPath(desc.GetInstanceID());
Debug.Log("New Texture = " + path);
}
else
{
path = AssetDatabase.GetAssetPath(txm.GetInstanceID());
txm = GetReadableTexture(path, false);
Debug.Log("Recycle Texture = " + path);
}
path = string.IsNullOrEmpty(path) ? "Assets/" + desc.name + ".png" : path.Replace(".prefab", ".png");
Debug.Log("Path = " + path);
if (!System.IO.File.Exists(path))
{
Debug.LogError("File does not exist = " + path);
}
if (txm != null)
{
List <Texture2D> src = new List <Texture2D>();
foreach (AtlasDesc.Item it in desc.List)
{
if (it.Image != null)
{
//Debug.Log("Shape = "+it.AtlasShape);
Texture2D t = GetReadableTexture(it.Image, false);
if (t != null)
{
//Debug.Log("Succes!");
src.Add(t);
}
else
{
Debug.LogError(string.Format("Atlas Shape '{0}' is not readable?", it.AtlasShape));
}
}
else
{
Debug.LogError(string.Format("Atlas Shape '{0}' has no image?", it.AtlasShape));
}
}
Debug.Log("Packing...");
Rect [] result = txm.PackTextures(src.ToArray(), desc.Padding);
Debug.Log("Writing file = " + path);
byte [] data = txm.EncodeToPNG();
System.IO.File.WriteAllBytes(path, data);
data = null;
AssetDatabase.Refresh();
txm = GetAtlasTexture(path, false);
if (txm == null)
{
Debug.Log("Unable to import texture?");
}
desc.Target = txm;
AssetDatabase.SaveAssets();
if (desc.Atlas != null)
{
List <CardShape> shapes = new List <CardShape>();
for (int i = 0; i < result.Length; ++i)
{
CardShape s = new CardShape();
string id = desc.List[i].AtlasShape;
s.Id = string.IsNullOrEmpty(id) ? string.Format("Element{0}", i) : id;
s.Image = txm; //desc.List[i].Image;
Rect r = result[i];
float bx = desc.List[i].BorderPixels / txm.width;
float by = desc.List[i].BorderPixels / txm.height;
s.Min = new Vector2(r.xMin + bx, r.yMin + by);
s.Max = new Vector2(r.xMax - bx, r.yMax - by);
shapes.Add(s);
}
desc.Atlas.ShapeList = shapes.ToArray();
}
}
}
public void SetMoveableCardBinding(CardName cardName, CardShape cardShape, int cardValue, DeckName sourceDeck, string path)
{
_moveableCard = new CardViewModel()
{
CardName = cardName, CardShape = cardShape, CardValue = cardValue, CardPath = path, CurrentDeck = sourceDeck
};
if (_closedDecks.ContainsKey(sourceDeck))
{
_closedDecks[sourceDeck].RemoveAll(c => c.CardName == cardName && c.CardShape == cardShape);
var cardBehind = _closedDecks[sourceDeck].LastOrDefault() ?? _transparentCard;
switch (sourceDeck)
{
case DeckName.OpenDeckCard:
OpenDeckCard = cardBehind;
break;
case DeckName.DiamondsDeckCard:
DiamondsDeckCard = cardBehind;
break;
case DeckName.HeartsDeckCard:
HeartsDeckCard = cardBehind;
break;
case DeckName.SpadesDeckCard:
SpadesDeckCard = cardBehind;
break;
case DeckName.ClubsDeckCard:
ClubsDeckCard = cardBehind;
break;
}
}
else
{
_openDecks[sourceDeck].RemoveAll(c => c.CardName == cardName && c.CardShape == cardShape);
if (_openDecks[sourceDeck].LastOrDefault() != null)
{
_openDecks[sourceDeck].Last().SubContainer = null;
}
switch (sourceDeck)
{
case DeckName.FirstDeck:
FirstDeckCards = new List <ContainerViewModel>(_openDecks[sourceDeck]);
break;
case DeckName.SecondDeck:
SecondDeckCards = new List <ContainerViewModel>(_openDecks[sourceDeck]);
break;
case DeckName.ThirdDeck:
ThirdDeckCards = new List <ContainerViewModel>(_openDecks[sourceDeck]);
break;
case DeckName.FourthDeck:
FourthDeckCards = new List <ContainerViewModel>(_openDecks[sourceDeck]);
break;
case DeckName.FifthDeck:
FifthDeckCards = new List <ContainerViewModel>(_openDecks[sourceDeck]);
break;
case DeckName.SixthDeck:
SixthDeckCards = new List <ContainerViewModel>(_openDecks[sourceDeck]);
break;
case DeckName.SeventhDeck:
SeventhDeckCards = new List <ContainerViewModel>(_openDecks[sourceDeck]);
break;
}
}
}
public PenaltyCard(string name, Color color, CardShape shape)
{
Name = name;
Color = color;
Shape = shape;
}
public Card GetCard(CardColor color, CardFill fill, CardShape shape)
{
return(GetCard(color.ToString(), fill.ToString(), shape.ToString()));
}
public PenaltyCard(string name, Color color, CardShape shape)
{
Name = name;
Color = color;
Shape = shape;
}
void VertexUV(SubMesh data, CardShape shape, Vector3 pos, Vector2 uv)
{
data.AddVertex(pos, uv, Color.white);
}
public void Rebuild()
{
if (!IsValid())
{
Debug.LogError("The card definition is not valid.");
return;
}
Stock.Validate();
Dictionary <Texture2D, SubMesh> table = new Dictionary <Texture2D, SubMesh>();
CardMesh card = new CardMesh();
CardShape paper = Definition.Atlas.FindById(Definition.Stock.Paper);
if (paper == null)
{
Debug.LogError("Paper does not exist in atlas = " + Definition.Atlas.name + "::" + Definition.Stock.Paper);
return;
}
SubMesh data = GetMesh(card, table, paper);
float x = Stock.Size.x / 2;
float y = Stock.Size.y / 2;
float cx = x - Stock.Border.x;
float cy = y - Stock.Border.y;
Vector3 v0 = new Vector2(-cx, +cy); // middle
Vector3 v1 = new Vector2(+cx, +cy);
Vector3 v2 = new Vector2(+cx, -cy);
Vector3 v3 = new Vector2(-cx, -cy);
Vector3 v4 = new Vector2(-cx, +y); // top edge
Vector3 v5 = new Vector2(+cx, +y);
Vector3 v6 = new Vector2(+x, +cy); // right edge
Vector3 v7 = new Vector2(+x, -cy);
Vector3 v8 = new Vector2(+cx, -y); // bot edge
Vector3 v9 = new Vector2(-cx, -y);
Vector3 vA = new Vector2(-x, -cy); // left edge
Vector3 vB = new Vector2(-x, +cy);
// 4 5
// B 0 1 6
// C D
// A 3 2 7
// 9 8
Vector3 vC = new Vector2(-cx, 0); // mid
Vector3 vD = new Vector2(+cx, 0);
if (Stock.Smooth > 0)
{
// middle
Square4(data, paper, v0, v1, v2, v3, Color.white, false, false);
// top
Square4(data, paper, v4, v5, v1, v0, Color.white, false, false);
// right
Square4(data, paper, v1, v6, v7, v2, Color.white, false, false);
// bottom
Square4(data, paper, v3, v2, v8, v9, Color.white, false, false);
// left
Square4(data, paper, vB, v0, v3, vA, Color.white, false, false);
BuildCorner3(data, paper, v0, vB, v4);
BuildCorner3(data, paper, v1, v5, v6);
BuildCorner3(data, paper, v2, v7, v8);
BuildCorner3(data, paper, v3, v9, vA);
}
else // simple rectangle
{
Vector3 p1 = new Vector3(-x, +y, 0);
Vector3 p2 = new Vector3(+x, +y, 0);
Vector3 p3 = new Vector3(+x, -y, 0);
Vector3 p4 = new Vector3(-x, -y, 0);
Square4(data, paper, p1, p2, p3, p4, Color.white, false, false);
}
Vector2 textSize = new Vector2(0.175f, 0.175f);
Vector2 symSize = new Vector2(0.25f, 0.25f);
float symW = symSize.x * 0.5f;
float symH = symSize.y * 0.5f;
float rimX = Mathf.Max(textSize.x, symW);
float rimY = Mathf.Max(textSize.y, symH);
CardShape symbol = Atlas.FindById(Definition.Symbol);
if (symbol == null && !string.IsNullOrEmpty(Definition.Symbol))
{
Debug.LogError(string.Format("Symbol shape '{0}' is not defined in atlas.", Definition.Symbol));
}
CardShape fullImage = Definition.FullImage ? Atlas.FindById(Definition.Image) : null;
CardShape halfImage = !Definition.FullImage ? Atlas.FindById(Definition.Image) : null;
if (fullImage != null)
{
SubMesh core = GetMesh(card, table, fullImage);
Square4(core, fullImage, v0, v1, v2, v3, Color.white, false, false);
}
else if (halfImage != null)
{
SubMesh core = GetMesh(card, table, halfImage);
Vector3 lift = new Vector3(0, 0, -0.01f);
Square4(core, halfImage, v0 + lift, v1 + lift, vD + lift, vC + lift, Color.white, false, false);
Square4(core, halfImage, vC + lift, vD + lift, v2 + lift, v3 + lift, Color.white, true, true);
}
else if (Definition.Pattern != 0 && symbol != null)
{
if (Definition.Pattern >= 1 && Definition.Pattern < patternBits.Length)
{
SubMesh core = GetMesh(card, table, symbol);
Vector2 ssize = symSize;
int bits = patternBits[Definition.Pattern];
float x0 = -x + Stock.Border.x;
float x1 = +x - Stock.Border.x;
float y0 = +y - Stock.Border.y;
float y1 = -y + Stock.Border.y;
for (int b = 0; b < 17; b++)
{
if ((bits & (1 << b)) != 0)
{
float px = Mathf.Lerp(x0, x1, patternPos[b].x);
float py = Mathf.Lerp(y0, y1, patternPos[b].y);
float scale = (Definition.Pattern == 1) ? 2.5f:1;
Square(core, symbol, new Vector3(px, py, -0.01f), scale * ssize, Color.white);
}
}
}
else
{
Debug.LogError(string.Format("Pattern value '{0}' is not valid.", Definition.Pattern));
}
}
CardShape text = Atlas.FindById(Definition.Text);
if (text == null && !string.IsNullOrEmpty(Definition.Text))
{
Debug.LogError(string.Format("Text shape '{0}' is not defined in atlas.", Definition.Text));
}
if (text != null)
{
SubMesh sub = GetMesh(card, table, text);
float x0 = -x + (Stock.Border.x + rimX) * 0.5f;
float x1 = +x - (Stock.Border.x + rimX) * 0.5f;
float y0 = +y - Stock.Border.y;
float y1 = -y + Stock.Border.y;
Color color = GetSymbolColor(Definition.Symbol);
Square(sub, text, new Vector3(x0, y0, -0.01f), textSize, color);
Square(sub, text, new Vector3(x1, y1, -0.01f), textSize, color);
}
if (symbol != null)
{
SubMesh sub = GetMesh(card, table, symbol);
Vector2 ssize = symSize * 0.5f;
float gapY = ssize.y / 3;
float x0 = -x + (Stock.Border.x + rimX) * 0.5f;
float x1 = +x - (Stock.Border.x + rimX) * 0.5f;
float y0 = +y - Stock.Border.y - textSize.y - gapY - ssize.y;
float y1 = -y + Stock.Border.y + textSize.y + gapY + ssize.y;
Color color = GetSymbolColor(Definition.Symbol);
Square(sub, symbol, new Vector3(x0, y0, -0.01f), ssize, color);
Square(sub, symbol, new Vector3(x1, y1, -0.01f), ssize, color);
}
if (Stock.TwoSided)
{
CardShape back = Atlas.FindById(Stock.Back);
if (back != null)
{
SubMesh core = GetMesh(card, table, back);
// middle
Square4(core, back, v1, v0, vC, vD, Color.white, false, false);
Square4(core, back, vD, vC, v3, v2, Color.white, true, true);
// top
Square4(core, paper, v5, v4, v0, v1, Color.white, false, false);
// back-left
Square5(core, paper, v2, v7, v6, v1, vD, Color.white, false);
// bottom
Square4(core, paper, v2, v3, v9, v8, Color.white, false, false);
// back-right
Square5(core, paper, v0, vB, vA, v3, vC, Color.white, false);
BuildCorner3(core, paper, v1, v6, v5);
BuildCorner3(core, paper, v2, v8, v7);
BuildCorner3(core, paper, v3, vA, v9);
BuildCorner3(core, paper, v0, v4, vB);
}
}
Mesh mesh = SetupMesh();
mesh.vertices = card.GetCombinedVertices().ToArray();
mesh.triangles = data.IndexList.ToArray();
mesh.uv = card.GetCombinedTexCoords().ToArray();
mesh.colors = card.GetCombinedColors().ToArray();
if (card.MeshList.Count > 1)
{
mesh.subMeshCount = card.MeshList.Count;
int vbase = 0;
for (int i = 1; i < card.MeshList.Count; ++i)
{
SubMesh sub = card.MeshList[i];
int [] tris = sub.IndexList.ToArray();
vbase += card.MeshList[i - 1].VertexList.Count;
for (int t = 0; t < tris.Length; ++t)
{
tris[t] += vbase;
}
mesh.SetTriangles(tris, i);
}
}
mesh.RecalculateBounds();
;
mesh.RecalculateNormals();
this.GetComponent <Renderer>().sharedMaterials = card.Materials.ToArray();
}
