public void DisplayToolTip(CJStarDomain domain, Player player, Player opponent)
        {
            this.SpriteColor = new Color(0, 0, 0, 0);
            this.PlayAnimation(0);

            this.IsActive = true;

            if (domain.PlayerToPoints.TryGetValue(player, out int pointsPlayer))
            {
                this.textParagraph2Ds[1].UpdateParameterText(0, pointsPlayer.ToString());
            }
            else
            {
                this.textParagraph2Ds[1].UpdateParameterText(0, "0");
            }

            if (domain.PlayerToPoints.TryGetValue(opponent, out int pointsOpponent))
            {
                this.textParagraph2Ds[1].UpdateParameterText(1, pointsOpponent.ToString());
            }
            else
            {
                this.textParagraph2Ds[1].UpdateParameterText(1, "0");
            }

            this.textParagraph2Ds[1].UpdateParameterColor(0, player.PlayerColor);
            this.textParagraph2Ds[1].UpdateParameterColor(1, opponent.PlayerColor);

            this.LaunchTextOfParagraphScrolling(0, 100);
            this.LaunchTextOfParagraphScrolling(1, 100);
        }
        public AICJStarDomain(AAILayer parentLayer, IAIObjectFactory factory, AEntity entity)
            : base(parentLayer, factory, entity)
        {
            CJStarDomain starDomain = entity as CJStarDomain;

            this.StarEntities = new HashSet <AIStarEntity>();

            this.DomainOwnerName = starDomain.DomainOwner != null ?  starDomain.DomainOwner.PlayerName : null;
        }
Exemple #3
0
        public void OnMouseFocused(ALayer2D parentLayer, ControlEventType eventType)
        {
            CJStarDomain domainEntity = parentLayer.GetEntityFromEntity2D(this) as CJStarDomain;

            if (domainEntity != null)
            {
                parentLayer.SendEventToWorld(Model.Event.EventType.FOCUS_DOMAIN_BOARD, domainEntity, null);
            }
        }
        public override IObject2D CreateObject2D(World2D world2D, ALayer2D layer2D, IObject obj)
        {
            if (obj is CJStarDomain)
            {
                CJStarDomain entity = obj as CJStarDomain;

                return(new CJStarDomain2D(layer2D, this, entity));
            }

            return(null);
        }
Exemple #5
0
        public override IAIObject CreateObjectAI(AIWorld worldAI, AAILayer layerAI, IObject obj)
        {
            if (obj is CJStarDomain)
            {
                CJStarDomain entity = obj as CJStarDomain;

                return(new AICJStarDomain(layerAI, this, entity));
            }

            return(null);
        }
 private void OnDomainFocused(CJStarDomain obj)
 {
     if (obj != null)
     {
         this.DomainFocused = this.objectToObject2Ds[obj] as CJStarDomain2D;
     }
     else
     {
         this.DomainFocused = null;
     }
 }
        public void UpdateReference()
        {
            if (this.parentLayer.TryGetTarget(out AAILayer parentLayer))
            {
                CJStarDomain starDomain = parentLayer.GetEntityFromAIEntity(this) as CJStarDomain;

                this.StarEntities.Clear();
                foreach (StarEntity starEntity in starDomain.Domain)
                {
                    this.StarEntities.Add(parentLayer.GetAIEntityFromEntity(starEntity) as AIStarEntity);
                }
            }
        }
Exemple #8
0
        protected virtual void UpdateScaling(CJStarDomain entity)
        {
            Vector2f topLeft     = new Vector2f(0, 0);
            Vector2f bottomRight = new Vector2f(0, 0);

            bool firstPoint = true;

            foreach (StarEntity starEntity in entity.Domain)
            {
                if (firstPoint || topLeft.X > starEntity.Position.X)
                {
                    topLeft.X = starEntity.Position.X;
                }

                if (firstPoint || topLeft.Y > starEntity.Position.Y)
                {
                    topLeft.Y = starEntity.Position.Y;
                }

                if (firstPoint || bottomRight.X < starEntity.Position.X)
                {
                    bottomRight.X = starEntity.Position.X;
                }

                if (firstPoint || bottomRight.Y < starEntity.Position.Y)
                {
                    bottomRight.Y = starEntity.Position.Y;
                }

                firstPoint = false;
            }

            float width  = bottomRight.X - topLeft.X + MARGIN_DOMAIN * 3;
            float height = bottomRight.Y - topLeft.Y + MARGIN_DOMAIN * 3;

            //topLeft -= new Vector2f(MARGIN_DOMAIN, MARGIN_DOMAIN);

            this.ObjectSprite.TextureRect = new IntRect(0, 0, (int)width, (int)height);
            this.ObjectSprite.Origin      = new Vector2f(width / 2, height / 2);

            this.ObjectSprite.Position = (bottomRight + topLeft) / 2;

            //this.WidthRatio = ((float)width) / this.ObjectSprite.Texture.Size.X;
            //this.HeightRatio = ((float)height) / this.ObjectSprite.Texture.Size.Y;



            this.DomainPoints = this.PopulateNewDomainPoints3(entity); //entity.Domain.Select(pElem => pElem.Position).ToList();

            this.render.Shader.SetUniform("margin", ((float)MARGIN_DOMAIN) / this.ObjectSprite.Texture.Size.X);
        }
        private void OnDomainFocusedChanged(IDomainsLayer obj)
        {
            this.domainLayerFocused = obj as ALayer2D;

            if (obj.DomainFocused != null)
            {
                CJStarDomain     domainFocused     = (obj as ALayer2D).GetEntityFromEntity2D(obj.DomainFocused) as CJStarDomain;
                BoardBannerLayer parentBannerLayer = this.parentLayer as BoardBannerLayer;

                this.domainToolTip.DisplayToolTip(domainFocused, parentBannerLayer.Player, parentBannerLayer.Opponent);
            }
            else
            {
                this.domainToolTip.HideToolTip();
            }
        }
Exemple #10
0
        public CJStarDomain2D(ALayer2D layer2D, IObject2DFactory factory, CJStarDomain entity) :
            base(layer2D, factory, entity)
        {
            // TO REMOVE
            //this.Test();

            //this.widthRatio = 0;
            //this.heightRatio = 0;

            this.targetedColor = Color.Black;

            Shader shader = new Shader(null, null, @"Assets\Graphics\Shaders\StarDomain.frag");

            Texture distortionMap = factory.GetTextureById("distorsionTexture");

            this.ObjectSprite.Texture          = factory.GetTextureById("distorsionTexture");
            this.ObjectSprite.Texture.Repeated = true;

            distortionMap.Repeated = true;
            distortionMap.Smooth   = true;
            shader.SetUniform("currentTexture", new Shader.CurrentTextureType());

            render        = new RenderStates(BlendMode.Alpha);
            render.Shader = shader;

            this.isFocused = true;
            this.IsFocused = false;

            this.Priority = entity.Priority;

            this.domainStars = entity.Domain.Select(pElem => layer2D.GetEntity2DFromEntity(pElem) as StarEntity2D).ToList();
            this.isFilled    = entity.IsFilled;
            shader.SetUniform("isFilled", this.isFilled);

            SequenceAnimation sequence = new SequenceAnimation(Time.FromSeconds(6), AnimationType.ONETIME);
            IAnimation        anim     = new ZoomAnimation(1f, 2f, Time.FromSeconds(2), AnimationType.ONETIME, InterpolationMethod.SQUARE_ACC);

            sequence.AddAnimation(0, anim);

            anim = new ZoomAnimation(2f, 1f, Time.FromSeconds(3), AnimationType.ONETIME, InterpolationMethod.SQUARE_ACC);
            sequence.AddAnimation(2, anim);
            this.animationsList.Add(sequence);

            this.UpdateScaling(entity);

            this.StartNotActiveState();
        }
        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;
            }
        }
Exemple #12
0
        protected bool CheckFocusDomainBoardEvent(World world, BoardPlayerLayer boardPlayerLayer, out CJStarDomain domainEntity, out string detailsFocused)
        {
            domainEntity   = null;
            detailsFocused = null;
            bool encounterGameEvent = false;

            if (this.pendingGameEvents.TryGetValue(EventType.FOCUS_DOMAIN_BOARD, out List <GameEvent> gameEventsList))
            {
                foreach (GameEvent gameEvent in gameEventsList)
                {
                    if (boardPlayerLayer == null || gameEvent.Layer == boardPlayerLayer)
                    {
                        if (domainEntity == null ||
                            gameEvent.Entity != null)
                        {
                            domainEntity = gameEvent.Entity as CJStarDomain;

                            detailsFocused = gameEvent.Details;

                            encounterGameEvent = true;
                        }
                    }
                }
            }

            return(encounterGameEvent);
        }
Exemple #13
0
        private List <Vector2f> PopulateNewDomainPoints3(CJStarDomain entity)
        {
            List <Vector2f> pointsToReturn = new List <Vector2f>();

            for (int i = 0; i < entity.Domain.Count; i++)
            {
                StarEntity currentStarEntity = entity.Domain[i];
                StarEntity nextStarEntity    = entity.Domain[(i + 1) % entity.Domain.Count];

                pointsToReturn.Add(currentStarEntity.Position);

                if (entity.DomainLinks.TryGetValue(currentStarEntity, out StarLinkEntity currentLink) && currentLink is CurvedStarLinkEntity)
                {
                    int sign = currentLink.StarFrom == currentStarEntity ? 1 : -1;

                    float radiusLink = (currentLink as CurvedStarLinkEntity).Radius * sign;

                    Vector2f currentToNextNorm = nextStarEntity.Position - currentStarEntity.Position;
                    float    lenCurrentToNext  = currentToNextNorm.Len();
                    currentToNextNorm = currentToNextNorm / lenCurrentToNext;

                    float angleToRotate = (float)Math.Acos(lenCurrentToNext / (2 * radiusLink));

                    Vector2f currentToCenter = currentToNextNorm.Rotate(angleToRotate) * radiusLink;
                    Vector2f centerPoint     = currentStarEntity.Position + currentToCenter;

                    Vector2f newPoint = centerPoint + (-currentToCenter).Rotate(Math.Sign(radiusLink) * sign * (Math.PI / 2 - angleToRotate));

                    pointsToReturn.Add(newPoint);
                }
                else
                {
                    Vector2f firstPoint;
                    if (i == 0)
                    {
                        firstPoint = entity.Domain[entity.Domain.Count - 1].Position;
                    }
                    else
                    {
                        firstPoint = entity.Domain[i - 1].Position;
                    }
                    Vector2f secondPoint = entity.Domain[i].Position;
                    Vector2f thirdPoint  = entity.Domain[(i + 1) % entity.Domain.Count].Position;
                    Vector2f fourthPoint = entity.Domain[(i + 2) % entity.Domain.Count].Position;

                    Vector2f normVector1 = secondPoint - firstPoint;
                    normVector1 = normVector1 / normVector1.Len();

                    Vector2f normVector2 = thirdPoint - secondPoint;
                    normVector2 = normVector2 / normVector2.Len();

                    Vector2f normVector3 = fourthPoint - thirdPoint;
                    normVector3 = normVector3 / normVector3.Len();

                    float distX1 = normVector1.X != 0 ? (secondPoint.X - firstPoint.X) / normVector1.X : (secondPoint.Y - firstPoint.Y) / normVector1.Y;
                    float distX2 = normVector2.X != 0 ? distX1 + (thirdPoint.X - secondPoint.X) / normVector2.X : distX1 + (thirdPoint.Y - secondPoint.Y) / normVector2.Y;
                    float distX3 = normVector3.X != 0 ? distX2 + (fourthPoint.X - thirdPoint.X) / normVector3.X : distX2 + (fourthPoint.Y - thirdPoint.Y) / normVector3.Y;

                    Vector2f firstPointX  = new Vector2f(0, firstPoint.X);
                    Vector2f secondPointX = new Vector2f(distX1, secondPoint.X);
                    Vector2f thirdPointX  = new Vector2f(distX2, thirdPoint.X);
                    Vector2f fourthPointX = new Vector2f(distX3, fourthPoint.X);

                    float x         = (distX2 + distX1) / 2;
                    float newPointX = this.CubicInterpolate(x, firstPointX, secondPointX, thirdPointX, fourthPointX);

                    Vector2f firstPointY  = new Vector2f(0, firstPoint.Y);
                    Vector2f secondPointY = new Vector2f(distX1, secondPoint.Y);
                    Vector2f thirdPointY  = new Vector2f(distX2, thirdPoint.Y);
                    Vector2f fourthPointY = new Vector2f(distX3, fourthPoint.Y);

                    float newPointY = this.CubicInterpolate(x, firstPointY, secondPointY, thirdPointY, fourthPointY);

                    pointsToReturn.Add(new Vector2f(newPointX, newPointY));
                }
            }

            return(pointsToReturn);
        }
Exemple #14
0
 public SecureDomainAction(CJStarDomain domainToSecure, Player.Player domainOwner)
 {
     this.DomainToSecure = domainToSecure;
     this.DomainOwner    = domainOwner;
 }
        protected override void OnEntityPropertyChanged(AEntity obj, string propertyName)
        {
            base.OnEntityPropertyChanged(obj, propertyName);

            AAIEntity entityAI;

            lock (this.objectLock)
            {
                switch (propertyName)
                {
                case "CardSocketed":
                    StarEntity   starEntity   = obj as StarEntity;
                    AIStarEntity starEntityAI = this.objectToObjectAIs[obj] as AIStarEntity;

                    lock (starEntityAI.objectLock)
                    {
                        if (starEntity.CardSocketed != null)
                        {
                            starEntityAI.CardEntitySocketed = this.objectToObjectAIs[starEntity.CardSocketed] as AICardEntity;
                        }
                        else
                        {
                            starEntityAI.CardEntitySocketed = null;
                        }
                    }
                    break;

                case "IsSocketed":
                    if (this.objectToObjectAIs.TryGetValue(obj, out entityAI))
                    {
                        lock (entityAI.objectLock)
                        {
                            (entityAI as AICardEntity).IsSocketed = (obj as CardEntity).ParentStar != null;
                        }
                    }
                    break;

                case "IsFliped":
                    if (this.objectToObjectAIs.TryGetValue(obj, out entityAI))
                    {
                        lock (entityAI.objectLock)
                        {
                            (entityAI as AICardEntity).IsFliped = (obj as CardEntity).IsFliped;
                        }
                    }
                    break;

                case "IsSelected":
                    if (this.objectToObjectAIs.TryGetValue(obj, out entityAI))
                    {
                        lock (entityAI.objectLock)
                        {
                            (entityAI as AICardEntity).IsSelected = (obj as CardEntity).IsSelected;
                        }
                    }
                    break;

                case "IsAwakened":
                    if (this.objectToObjectAIs.TryGetValue(obj, out entityAI))
                    {
                        lock (entityAI.objectLock)
                        {
                            (entityAI as AICardEntity).IsAwakened = (obj as CardEntity).Card.IsAwakened;
                        }
                    }
                    break;

                case "CurrentOwner":
                    if (this.objectToObjectAIs.TryGetValue(obj, out entityAI))
                    {
                        lock (entityAI.objectLock)
                        {
                            (entityAI as AICardEntity).CardOwnerName = (obj as CardEntity).Card.CurrentOwner.PlayerName;
                        }
                    }
                    break;

                case "Value":
                    if (this.objectToObjectAIs.TryGetValue(obj, out entityAI))
                    {
                        lock (entityAI.objectLock)
                        {
                            (entityAI as AICardEntity).Value = (obj as CardEntity).Card.Value;
                        }
                    }
                    break;

                case "DomainOwner":
                    CJStarDomain starDomain = obj as CJStarDomain;
                    if (this.objectToObjectAIs.TryGetValue(obj, out entityAI))
                    {
                        lock (entityAI.objectLock)
                        {
                            (entityAI as AICJStarDomain).DomainOwnerName = starDomain.DomainOwner != null ? starDomain.DomainOwner.PlayerName : null;
                        }
                    }
                    break;
                }
            }
        }