private void OnCardUnpicked(CardEntity obj, BoardPlayerLayer.PileFocused pilePicked)
{
CardEntity2D cardUnpicked = this.GetEntity2DFromEntity(obj) as CardEntity2D;
cardUnpicked.PlaySound("cardDrawn");
switch (pilePicked)
{
case BoardPlayerLayer.PileFocused.HAND:
this.cardsHand.Add(cardUnpicked);
break;
case BoardPlayerLayer.PileFocused.CEMETERY:
this.cardsCemetery.Add(cardUnpicked);
break;
}
cardUnpicked.SetCooldownFocus(COOLDOWN_FOCUS);
switch (pilePicked)
{
case BoardPlayerLayer.PileFocused.HAND:
this.UpdateCardHandPriority();
break;
case BoardPlayerLayer.PileFocused.CEMETERY:
this.UpdateCardCimeteryPriority();
break;
}
}
//private void OnCardResurrected(CardEntity obj)
//{
// this.cardsCemetery.Remove(this.GetEntity2DFromEntity(obj) as CardEntity2D);
// this.UpdateCardCimeteryPriority();
//}
private void OnCardDestroyed(CardEntity obj)
{
CardEntity2D cardDestroyed = this.GetEntity2DFromEntity(obj) as CardEntity2D;
this.cardsCemetery.Add(cardDestroyed);
this.UpdateCardCimeteryPriority();
}
private void OnCardCreated(Model.Card.CardEntity obj)
{
CardEntity2D cardEntity = this.GetEntity2DFromEntity(obj) as CardEntity2D;
this.cardsHand.Add(cardEntity);
this.UpdateCardHandPriority();
}
private void OnCardRemoved(Model.Card.CardEntity obj)
{
CardEntity2D cardEntity2DToRemove = this.GetEntity2DFromEntity(obj) as CardEntity2D;
this.cardsHand.Remove(cardEntity2DToRemove);
this.UpdateCardHandPriority();
cardEntity2DToRemove.PlayRemoveAnimation();
}
private void OnCardUnpicked(Model.Card.CardEntity obj)
{
CardEntity2D cardPicked = this.GetEntity2DFromEntity(obj) as CardEntity2D;
this.cardsHand.Add(cardPicked);
cardPicked.SetCooldownFocus(COOLDOWN_FOCUS);
this.UpdateCardHandPriority();
}
public override void InitializeLayer(IObject2DFactory factory)
{
base.InitializeLayer(factory);
this.LevelTurnPhase = TurnPhase.VOID;
BoardBannerLayer boardBannerLayer = this.parentLayer as BoardBannerLayer;
this.headerEntity2D = new HeaderEntity2D(this, boardBannerLayer.Player, boardBannerLayer.Opponent);
this.scoreDomainLabel2D = new ScoreDomainLabel2D(this, boardBannerLayer.Player, boardBannerLayer.Opponent);
this.turnBanner2D.ResetTurn(boardBannerLayer.MaxTurnCount);
this.cardsToPlaceBanner2D.ResetTurn();
this.domainToolTip.HideToolTip();
this.cardFocused = null;
this.domainLayerFocused = null;
this.cardFocusedLayers.Clear();
this.domainsLayers.Clear();
this.scoreLayers.Clear();
if (this.world2D.TryGetTarget(out World2D world2D))
{
foreach (ALayer2D layer in world2D.LayersList)
{
ICardFocusedLayer cardFocusedLayer = layer as ICardFocusedLayer;
if (cardFocusedLayer != null)
{
this.cardFocusedLayers.Add(cardFocusedLayer);
}
IDomainsLayer domainLayer = layer as IDomainsLayer;
if (domainLayer != null)
{
this.domainsLayers.Add(domainLayer);
domainLayer.StartDomainEvaluated += OnStartDomainsEvaluated;
domainLayer.DomainEvaluated += OnDomainEvaluated;
domainLayer.EndDomainEvaluated += OnEndDomainsEvaluated;
domainLayer.DomainFocusedChanged += OnDomainFocusedChanged;
domainLayer.NbCardsToPlaceChanged += OnNbCardsToPlaceChanged;
}
IScoreLayer scoreLayer = layer as IScoreLayer;
if (scoreLayer != null)
{
this.scoreLayers.Add(scoreLayer.PlayerName, scoreLayer);
}
}
}
}
private void OnCardDrawn(CardEntity obj)
{
this.cardDrawn = this.GetEntity2DFromEntity(obj) as CardEntity2D;
this.cardDrawn.PlaySound("cardDrawn");
this.cardsDeck.Remove(this.cardDrawn);
this.cardsHand.Add(this.cardDrawn);
this.cardDrawn.SetCooldownFocus(COOLDOWN_FOCUS);
this.UpdateCardHandPriority();
}
protected override void OnEntityRemoved(AEntity obj)
{
CardEntity2D cardEntity2DToRemove = this.objectToObject2Ds[obj] as CardEntity2D;
if (cardEntity2DToRemove != null)
{
this.pendingRemovingCardEntities.Add(cardEntity2DToRemove);
}
else
{
base.OnEntityRemoved(obj);
}
}
private void OnCardFocused(Model.Card.CardEntity obj)
{
if (obj != null)
{
CardEntity2D cardFocused = this.GetEntity2DFromEntity(obj) as CardEntity2D;
this.CardFocused = cardFocused;
//this.cardToolTip.DisplayToolTip(obj.Card, cardFocused);
}
else
{
this.CardFocused = null;
//this.cardToolTip.HideToolTip();
}
}
public override void FlushEntities()
{
base.FlushEntities();
this.cardsDeck.Clear();
this.cardsCemetery.Clear();
this.cardsHand.Clear();
this.maxPriority = 0;
this.nbCardsToDraw = 0;
this.LevelTurnPhase = TurnPhase.VOID;
this.cardDrawn = null;
}
public void DisplayToolTip(Card card, CardEntity2D cardFocused)
{
this.CardFocused = cardFocused;
this.SpriteColor = new Color(0, 0, 0, 0);
this.PlayAnimation(0);
this.IsActive = true;
this.UpdateTextOfParagraph(0, card.NameIdLoc);
this.UpdateTextOfParagraph(1, card.PoemIdLoc);
this.UpdateTextOfParagraph(2, card.EffectIdLoc);
this.LaunchTextOfParagraphScrolling(1, 100);
this.LaunchTextOfParagraphScrolling(2, 100);
}
public override void InitializeLayer(IObject2DFactory factory)
{
this.cardsHand.Clear();
base.InitializeLayer(factory);
this.cardFocused = null;
this.cardAwakened = null;
this.pendingRemovingCardEntities.Clear();
this.LevelTurnPhase = TurnPhase.VOID;
this.IsRunningBehavior = false;
}
private void OnCardPicked(CardEntity obj, BoardPlayerLayer.PileFocused pilePicked)
{
CardEntity2D cardPicked = this.GetEntity2DFromEntity(obj) as CardEntity2D;
switch (pilePicked)
{
case BoardPlayerLayer.PileFocused.HAND:
this.cardsHand.Remove(cardPicked);
this.UpdateCardHandPriority();
break;
case BoardPlayerLayer.PileFocused.CEMETERY:
this.cardsCemetery.Remove(cardPicked);
this.UpdateCardCimeteryPriority();
break;
}
}
private void UpdateCardsToDraw(Time deltaTime)
{
if (this.cardDrawn != null &&
this.currentCooldownDraw <= 0)
{
this.cardDrawn = null;
}
else
{
this.currentCooldownDraw -= deltaTime.AsSeconds();
}
if (this.nbCardsToDraw > 0 &&
this.cardDrawn == null)
{
this.currentCooldownDraw = COOLDOWN_DRAW;
this.SendEventToWorld(Model.Event.EventType.DRAW_CARD, null, string.Empty);
}
}
public override void InitializeLayer(IObject2DFactory factory)
{
this.cardsDeck.Clear();
this.cardsCemetery.Clear();
this.cardsHand.Clear();
this.maxPriority = 0;
this.nbCardsToDraw = 0;
this.currentCooldownDraw = 0;
this.LevelTurnPhase = TurnPhase.VOID;
this.cardDrawn = null;
this.cardFocused = null;
this.sourceCardEntities = null;
//this.cardPicked = null;
this.pileFocused = (this.parentLayer as BoardPlayerLayer).CardPileFocused;
base.InitializeLayer(factory);
BoardPlayerLayer parentBoardPlayerLayer = (this.parentLayer as BoardPlayerLayer);
this.scoreLabel.DisplayScore(parentBoardPlayerLayer.IndexPlayer, parentBoardPlayerLayer.SupportedPlayer);
this.scoreLabel.Score = 0;
foreach (AEntity2D entity in this.objectToObject2Ds.Values)
{
if (entity is CardEntity2D)
{
CardEntity2D cardEntity2D = entity as CardEntity2D;
cardEntity2D.Priority = this.maxPriority++;
this.cardsDeck.Add(cardEntity2D);
}
}
}
public override void InitializeLayer(IObject2DFactory factory)
{
this.maxAwakenedPriority = 0;
this.cardsOnBoard.Clear();
this.domainsOwnedByPlayers.Clear();
this.linksFocused.Clear();
this.sourceCardEntities = null;
this.sourceStarEntities = null;
this.targetCardEntities = null;
this.targetStarEntities = null;
base.InitializeLayer(factory);
this.LevelTurnPhase = TurnPhase.VOID;
this.cardPicked = null;
this.cardFocused = null;
this.domainFocused = null;
}
private void UpdateFocusedEntity(Time deltaTime)
{
ICardFocusedLayer firstCardLayerFocused = this.cardFocusedLayers.FirstOrDefault(pElem => pElem.CardFocused != null);
ALayer2D layer2D = firstCardLayerFocused as ALayer2D;
if (firstCardLayerFocused != null)
{
CardEntity2D cardFocused = firstCardLayerFocused.CardFocused;
if (this.cardFocused != cardFocused)
{
CardEntity cardEntity = layer2D.GetEntityFromEntity2D(cardFocused) as CardEntity;
this.cardToolTip.DisplayToolTip(cardEntity.Card, cardFocused);
this.cardFocused = cardFocused;
}
if (this.cardToolTip.IsActive)
{
Vector2f cardFocusedPosition = this.cardFocused.Position;
Vector2f cardPositionInWindow = layer2D.GetPositionInWindow(cardFocusedPosition);
if (cardPositionInWindow.Y > this.defaultViewSize.Y / 2)
{
cardFocusedPosition.Y -= this.cardFocused.Canevas.Height / 2;
cardFocusedPosition = this.GetPositionInScene(layer2D.GetPositionInWindow(cardFocusedPosition));
cardFocusedPosition.X -= this.cardToolTip.Canevas.Width / 2;
cardFocusedPosition.Y -= this.cardToolTip.Canevas.Height;
}
else
{
cardFocusedPosition.Y += this.cardFocused.Canevas.Height / 2;
cardFocusedPosition = this.GetPositionInScene(layer2D.GetPositionInWindow(cardFocusedPosition));
cardFocusedPosition.X -= this.cardToolTip.Canevas.Width / 2;
}
this.cardToolTip.Position = cardFocusedPosition;
}
}
else
{
this.cardToolTip.HideToolTip();
this.cardFocused = null;
}
if (this.domainToolTip.IsActive)
{
Vector2f mousePositionInWindow = this.domainLayerFocused.GetPositionInWindow(new Vector2f(this.domainLayerFocused.MousePosition.X, this.domainLayerFocused.MousePosition.Y));
Vector2f domainTooltipPosition = this.GetPositionInScene(mousePositionInWindow);
if (mousePositionInWindow.Y > this.defaultViewSize.Y / 2)
{
domainTooltipPosition.Y -= this.domainToolTip.Canevas.Height;
}
//domainTooltipPosition.X -= this.domainToolTip.Canevas.Width / 2;
this.domainToolTip.Position = domainTooltipPosition;
this.domainToolTip.UpdateGraphics(deltaTime);
}
}
protected override void OnEntityPropertyChanged(AEntity obj, string propertyName)
{
base.OnEntityPropertyChanged(obj, propertyName);
switch (propertyName)
{
case "CardSocketed":
StarEntity starEntity = obj as StarEntity;
StarEntity2D starEntity2D = this.objectToObject2Ds[obj] as StarEntity2D;
starEntity2D.SetCardSocketed(starEntity.CardSocketed);
break;
case "IsSocketed":
(this.objectToObject2Ds[obj] as CardEntity2D).IsSocketed = ((obj as CardEntity).ParentStar != null);
break;
case "IsFliped":
(this.objectToObject2Ds[obj] as CardEntity2D).IsFliped = (obj as CardEntity).IsFliped;
break;
case "IsSelected":
(this.objectToObject2Ds[obj] as CardEntity2D).IsSelected = (obj as CardEntity).IsSelected;
break;
case "IsAwakened":
CardEntity2D cardAwakened = this.objectToObject2Ds[obj] as CardEntity2D;
cardAwakened.IsAwakened = (obj as CardEntity).Card.IsAwakened;
cardAwakened.Priority = 2000 + this.maxAwakenedPriority++;
break;
case "IsActive":
this.objectToObject2Ds[obj].IsActive = (obj as AEntity).IsActive;
break;
case "CurrentOwner":
CardEntity cardConcerned = obj as CardEntity;
(this.objectToObject2Ds[cardConcerned] as CardEntity2D).PlayerColor = cardConcerned.Card.CurrentOwner.PlayerColor;
(this.objectToObject2Ds[cardConcerned.ParentStar] as StarEntity2D).SetCardSocketed(cardConcerned);
break;
case "Value":
CardEntity2D card2DChanged = this.objectToObject2Ds[obj] as CardEntity2D;
CardEntity cardChanged = obj as CardEntity;
card2DChanged.CardValue = cardChanged.Card.Value;
card2DChanged.CardValueModifier = cardChanged.Card.ValueModifier;
break;
case "DomainOwner":
CJStarDomain2D domain2DChanged = this.objectToObject2Ds[obj] as CJStarDomain2D;
CJStarDomain domainChanged = (obj as CJStarDomain);
if (domainChanged.DomainOwner != null)
{
domain2DChanged.TargetedColor = domainChanged.DomainOwner.PlayerColor;
}
else
{
domain2DChanged.TargetedColor = Color.Black;
}
break;
}
}
protected override AEntity2D AddEntity(AEntity obj)
{
CardEntity2D entity2D = base.AddEntity(obj) as CardEntity2D;
return(entity2D);
}
