CardEntity 的摘要说明
Exemple #1
0
    public static CardEntity GetCardByCardId(int cardId, int userId)
    {
        DbCommand comm = GenericDataAccess.CreateCommand();
        comm.CommandText = "GetCardByCardId_v4";
        DbParameter param = comm.CreateParameter();
        param.ParameterName = "@CardID";
        param.Value = cardId;
        param.DbType = DbType.Int32;
        comm.Parameters.Add(param);

        param = comm.CreateParameter();
        param.ParameterName = "@UserID";
        param.Value = userId;
        param.DbType = DbType.Int32;
        comm.Parameters.Add(param);

        CardEntity card = new CardEntity();
        DataTable dt = GenericDataAccess.ExecuteCommand(comm);
        if (dt.Rows.Count > 0)
        {
            card.CardID = Int32.Parse(dt.Rows[0]["CardID"].ToString());
            card.CardName = dt.Rows[0]["CardName"].ToString();
            card.CardMoney = Double.Parse(dt.Rows[0]["CardMoney"].ToString());
            card.CardLive = Int32.Parse(dt.Rows[0]["CardLive"].ToString());
            card.Synchronize = Int32.Parse(dt.Rows[0]["Synchronize"].ToString());
        }

        return card;
    }
Exemple #2
0
 public void AddCard(CardEntity card)
 {
     cards.Add(card);
     RefreshPositions();
     // Do this after refreshing positions or the lerpattractor will get confused about scale:
     card.transform.parent = cardFan.transform;
 }
Exemple #3
0
    void Start () {
        card = GameManager.Instance.GetEntity(data.cardId) as CardEntity;
        if(data.x >= 0)
        {
            UnitSlot slot = GameManager.Instance.gameBoard.GetSlot(data.x, data.y);
        }
        flyTimer = flyDelay;
	}
    void Start () {
        card = (CardEntity) GameManager.Instance.GetEntity(data.cardId);
        card.Alpha = 0;
        if(card.EntityView.owner == GameManager.Instance.MyPlayer.playerName)
        {
            GameManager.Instance.playerHand.RemoveCard(card);
        }
        else
        {
            GameManager.Instance.opponentHand.RemoveCard(card);
        }
	}
Exemple #5
0
    //同步钱包//
    public static bool SyncCardInsert(CardEntity card)
    {
        DbCommand comm = GenericDataAccess.CreateCommand();
        comm.CommandText = "SyncCardInsert_v4";
        DbParameter param = comm.CreateParameter();
        param.ParameterName = "@CardID";
        param.Value = card.CardID;
        param.DbType = DbType.Int32;
        comm.Parameters.Add(param);

        param = comm.CreateParameter();
        param.ParameterName = "@CardName";
        param.Value = card.CardName;
        param.DbType = DbType.String;
        param.Size = 20;
        comm.Parameters.Add(param);

        param = comm.CreateParameter();
        param.ParameterName = "@CardMoney";
        param.Value = card.CardMoney;
        param.DbType = DbType.Double;
        comm.Parameters.Add(param);

        param = comm.CreateParameter();
        param.ParameterName = "@UserID";
        param.Value = card.UserID;
        param.DbType = DbType.Int32;
        comm.Parameters.Add(param);

        param = comm.CreateParameter();
        param.ParameterName = "@CardLive";
        param.Value = card.CardLive;
        param.DbType = DbType.Int32;
        comm.Parameters.Add(param);

        param = comm.CreateParameter();
        param.ParameterName = "@Synchronize";
        param.Value = card.Synchronize;
        param.DbType = DbType.Int32;
        comm.Parameters.Add(param);

        int result = -1;
        try
        {
            result = GenericDataAccess.ExecuteNonQuery(comm);
        }
        catch
        {
        }

        return (result != -1);
    }
Exemple #6
0
        public async Task <bool> Update(CardEntity card)
        {
            var _card = await dataContext.Cards.FirstOrDefaultAsync(x => x.Link == card.Link);

            if (_card == null || _card.UserEntity.Name != card.UserEntity.Name)
            {
                return(false);
            }

            _card.Name       = card.Name;
            _card.Annotation = card.Annotation;
            _card.Links      = card.Links;

            dataContext.Cards.Update(_card);
            await dataContext.SaveChangesAsync();

            return(true);
        }
    void Start()
    {
        elapsed = 0;
        card = GameManager.Instance.GetEntity(data.cardView.id) as CardEntity;
        GameManager.Instance.opponentHand.RemoveCard(card);
        if(card == null)
        {
            Debug.LogError("Card not found");
            enabled = false;
        }
        card.EntityView = data.cardView;
        card.lerpTransform.SetTransform(GameManager.Instance.gameBoard.cardReveal, 0.5f);

        if (data.cardView.column >= 0)
        {
            slot = GameManager.Instance.gameBoard.GetSlot(data.cardView.column, data.cardView.row);
        }
    }
Exemple #8
0
 /// <summary>
 /// Play a card on a slot, automatically deciding to summon a unit
 /// or play a power on a target.
 /// </summary>
 /// <param name="card"></param>
 /// <param name="slot"></param>
 /// <returns></returns>
 public bool PlayCard(CardEntity card, UnitSlot slot)
 {
     if (card.EntityView.IsUnit)
     {
         return(SummonUnit(card, slot));
     }
     else
     {
         if (card.EntityView.RequiresTarget)
         {
             return(PlayPower(card, slot));
         }
         else
         {
             return(PlayPower(card, null));
         }
     }
 }
Exemple #9
0
        public CardEntity FormatComments(CardEntity card)
        {
            var result = new List <CommentEntity>();

            if (card != null)
            {
                foreach (var comment in card.Comments.OrderByDescending(c => c.Id))
                {
                    if (!comment.IsReply)
                    {
                        result.Add(comment);
                    }
                }
                card.Comments = result;
                return(card);
            }
            return(card = null);
        }
        private void OnCardFocused(CardEntity obj)
        {
            lock (this.objectLock)
            {
                if (obj != null)
                {
                    AICardEntity cardFocused = this.objectToObjectAIs[obj] as AICardEntity;

                    this.cardFocused = cardFocused;
                    //this.cardToolTip.DisplayToolTip(obj.Card, cardFocused);
                }
                else
                {
                    this.cardFocused = null;
                    //this.cardToolTip.HideToolTip();
                }
            }
        }
        private void OnCardUnpicked(CardEntity obj, BoardPlayerLayer.PileFocused pilePicked)
        {
            lock (this.objectLock)
            {
                AICardEntity cardUnpicked = this.objectToObjectAIs[obj] as AICardEntity;

                switch (pilePicked)
                {
                case BoardPlayerLayer.PileFocused.HAND:
                    this.cardsHand.Add(cardUnpicked);
                    break;

                case BoardPlayerLayer.PileFocused.CEMETERY:
                    this.cardsCemetery.Add(cardUnpicked);
                    break;
                }
            }
        }
        public bool PickCard(CardEntity cardToPick)
        {
            bool isCardHand     = this.CardsHand.Contains(cardToPick);
            bool isCardCemetery = this.CardsCemetery.Contains(cardToPick);

            if (isCardHand || isCardCemetery)
            {
                this.pilePicked = isCardHand ? PileFocused.HAND : PileFocused.CEMETERY;

                this.NotifyCardPicked(cardToPick, this.pilePicked);

                this.RemoveEntityFromLayer(cardToPick);

                this.CardEntityFocused = null;

                return(true);
            }
            return(false);
        }
        public async Task <bool> UpdateCardAsync(CardModel cardModel)
        {
            var entity = await cardRepository.FindByIdAsync(cardModel.Id);

            if (entity == null)
            {
                return(false);
            }

            var updatedEntity = new CardEntity(
                entity.Id,
                entity.DeckId,
                cardModel.Question,
                cardModel.Answer
                );
            var result = await cardRepository.UpdateAsync(updatedEntity);

            return(result != null);
        }
Exemple #14
0
        public Point GetCenterPos(CardEntity entity, bool top)
        {
            var xOffset = entity.ActualWidth / 2;
            var yOffset = entity.ActualHeight / 2;

            if (top)
            {
                yOffset -= 12;
            }
            else
            {
                yOffset += 12;
                yOffset *= -1;
            }
            var x = GetPosition(entity).X + xOffset;
            var y = GetPosition(entity).Y + yOffset;

            return(new Point(x, y));
        }
Exemple #15
0
    //private void Awake()
    //{
    //    FadeManager.FadeIn();

    //}



    private void Start()
    {
        pauseButtonObj.SetActive(false);

        for (int i = 0; i < 4; i++)
        {
            dishPosition[i] = dishTransform[i].localPosition;
        }

        movePosition[0] = dishPosition[1];
        movePosition[1] = dishPosition[3];

        //背景の料理のicon
        for (int i = 0; i < 20; i++)
        {
            //CardEntity cardEntity = Resources.Load<CardEntity>("CardEntityList/Dishes/Card" + i);
            CardEntity cardEntity = CardData.instance.dishCardEntity[i];

            if (i < 5)
            {
                int index = i % 5;
                dishTransform[0].GetChild(index).GetComponent <Image>().sprite = cardEntity.icon;
            }
            else if (i < 10)
            {
                int index = i % 5;
                dishTransform[1].GetChild(index).GetComponent <Image>().sprite = cardEntity.icon;
            }
            else if (i < 15)
            {
                int index = i % 5;
                dishTransform[2].GetChild(index).GetComponent <Image>().sprite = cardEntity.icon;
            }
            else
            {
                int index = i % 5;
                dishTransform[3].GetChild(index).GetComponent <Image>().sprite = cardEntity.icon;
            }
        }


        addDefaultPosition = addScoreText.transform.localPosition;
    }
Exemple #16
0
    protected void Page_Load(object sender, EventArgs e)
    {
        int    cardId    = Int32.Parse(Request.Form["cardid"].ToString());
        string cardName  = Request.Form["cardname"].ToString();
        double cardMoney = Double.Parse(Request.Form["cardmoney"].ToString());
        int    cardLive  = Int32.Parse(Request.Form["cardlive"].ToString());
        int    userId    = Int32.Parse(Request.Form["userid"].ToString());

        CardEntity card = new CardEntity();

        card.CardID      = cardId;
        card.CardName    = cardName;
        card.CardMoney   = cardMoney;
        card.UserID      = userId;
        card.CardLive    = cardLive;
        card.Synchronize = 0;

        bool success = SyncHelper.SyncCheckCardIsExists(cardId, userId);

        if (success)
        {
            success = SyncHelper.SyncCardUpdate(card);
        }
        else
        {
            success = SyncHelper.SyncCardInsert(card);
        }

        string result = "{";

        if (success)
        {
            result += "\"result\":\"ok\"";
        }
        else
        {
            result += "\"result\":\"error\"";
        }
        result += "}";

        Response.Write(result);
        Response.End();
    }
    //添加类别操作
    protected void Button1_Click(object sender, EventArgs e)
    {
        string cardName = this.CardNameEmpIns.Text.Trim();

        if (cardName == "")
        {
            Utility.Alert(this, "名称未填写!");
            return;
        }
        string cardMoney = this.CardMoneyEmpIns.Text.Trim();

        if (cardMoney != "")
        {
            if (!ValidHelper.CheckDouble(cardMoney))
            {
                Utility.Alert(this, "余额填写错误!");
                return;
            }
        }
        else
        {
            cardMoney = "0";
        }

        CardEntity card = new CardEntity();

        card.CardName    = cardName;
        card.CardMoney   = Double.Parse(cardMoney);
        card.UserID      = userId;
        card.CardLive    = 1;
        card.Synchronize = 1;

        bool success = CardAccess.InsertCard(card);

        if (success)
        {
            Utility.Alert(this, "添加成功。", "UserCardAdmin.aspx");
        }
        else
        {
            Utility.Alert(this, "添加失败!");
        }
    }
Exemple #18
0
        public async Task <bool> CardExistAsync(int cardId)
        {
            try
            {
                var v = await _weightWatchersContext.Card.ToListAsync();

                CardEntity card = await _weightWatchersContext.Card
                                  .FirstOrDefaultAsync(c => c.Id == cardId);

                if (card != null)
                {
                    return(true);
                }
                return(false);
            }
            catch (Exception e)
            {
                throw new Exception();
            }
        }
Exemple #19
0
 public override void NotifyObjectBeforePropertyChanged(AEntity obj, string propertyName)
 {
     switch (propertyName)
     {
     case "IsAwakened":
         CardEntity cardEntity = obj as CardEntity;
         if (cardEntity.Card.IsAwakened)
         {
             if (cardEntity.AreCardBehaviorsActive)
             {
                 this.RegisterNotifBehavior(new CardAwakenedNotifBehavior(cardEntity));
             }
         }
         else
         {
             this.UnregisterNotifBehavior(cardEntity);
         }
         break;
     }
 }
Exemple #20
0
 private void CheckMoveToBoard(CardEntity card)
 {
     if (HandUI.Instance.cardInControllerHand.Contains(card))
     {
         if (BoardUI.Instance.putDownCardArea.bounds.Contains(card.motion.cardTran.position))
         {
             //putcard down to board
             if (card.info.manaCost <= Game.Instance.controller.activity.actionPoints)
             {
                 if (card.info.putOn == Card.PutOn.emptySlot)
                 {
                     card.MoveToSlot();
                 }
                 else
                 {
                     CheckTopOfControllerMogi(card, BoardUI.Instance.MogiInBoard(true));
                 }
             }
         }
     }
 }
        public void AddCardToCemetery(Card.Card cardToAdd, Vector2f startPosition)
        {
            CardEntity cardEntity = new CardEntity(this, cardToAdd, true);

            this.AddEntityToLayer(cardEntity);

            if (this.BoardToLayerPositionConverter != null)
            {
                CardBoardLevel testLevelNode = this.ownerLevelNode as CardBoardLevel;

                startPosition = this.BoardToLayerPositionConverter.BoardToLayerPosition(testLevelNode.BoardGameLayer, startPosition);
            }

            cardEntity.Position = startPosition;

            this.CardsCemetery.Add(cardEntity);

            this.CardDestroyed?.Invoke(cardEntity);

            this.UpdateCardsCimeteryPosition();
        }
        public void ToEntity_WithValidCard_ShouldBeExecuteCorrectly()
        {
            // Arrange
            var card = _fixture.Create <Card>();

            var expected = new CardEntity
            {
                CardId    = card.Id,
                GameId    = card.GameId,
                FaceValue = card.FaceValue,
                NextValue = card.NextValue
            };

            // Act
            var entityResult = card.ToEntity();

            // Assert
            entityResult
            .Should()
            .BeEquivalentTo(expected);
        }
Exemple #23
0
    protected void Page_Load(object sender, EventArgs e)
    {
        int cardId = Int32.Parse(Request.Form["cardid"].ToString());
        string cardName = Request.Form["cardname"].ToString();
        double cardMoney = Double.Parse(Request.Form["cardmoney"].ToString());
        int cardLive = Int32.Parse(Request.Form["cardlive"].ToString());
        int userId = Int32.Parse(Request.Form["userid"].ToString());

        CardEntity card = new CardEntity();
        card.CardID = cardId;
        card.CardName = cardName;
        card.CardMoney = cardMoney;
        card.UserID = userId;
        card.CardLive = cardLive;
        card.Synchronize = 0;

        bool success = SyncHelper.SyncCheckCardIsExists(cardId, userId);
        if (success)
        {
            success = SyncHelper.SyncCardUpdate(card);
        }
        else
        {
            success = SyncHelper.SyncCardInsert(card);
        }

        string result = "{";
        if (success)
        {
            result += "\"result\":\"ok\"";
        }
        else
        {
            result += "\"result\":\"error\"";
        }
        result += "}";

        Response.Write(result);
        Response.End();
    }
Exemple #24
0
    //添加类别操作
    protected void Button1_Click(object sender, EventArgs e)
    {
        string cardName = this.CardNameEmpIns.Text.Trim();
        if (cardName == "")
        {
            Utility.Alert(this, "名称未填写!");
            return;
        }
        string cardMoney = this.CardMoneyEmpIns.Text.Trim();
        if (cardMoney != "")
        {
            if (!ValidHelper.CheckDouble(cardMoney))
            {
                Utility.Alert(this, "余额填写错误!");
                return;
            }
        }
        else
        {
            cardMoney = "0";
        }

        CardEntity card = new CardEntity();
        card.CardName = cardName;
        card.CardMoney = Double.Parse(cardMoney);
        card.UserID = userId;
        card.CardLive = 1;
        card.Synchronize = 1;

        bool success = CardAccess.InsertCard(card);
        if (success)
        {
            Utility.Alert(this, "添加成功。", "UserCardAdmin.aspx");
        }
        else
        {
            Utility.Alert(this, "添加失败!");
        }
    }
 // Use this for initialization
 void Start () {
     card = GameManager.Instance.GetEntity(data.causeId) as CardEntity;
     if (data.playerName == GameManager.Instance.MyPlayer.playerName)
     {
         isPlayer = true;
     }
     else
     {
         isPlayer = false;
         if(data.resource == "ENERGY_RESOURCE")
         {
             UIManager.Instance.enemyEnergy.text = data.amount + " / " + GameManager.Instance.OpponentPlayer.GetMaxResource("ENERGY_RESOURCE");
         }
         else
         {
             UIManager.Instance.enemyMinerals.text = data.amount + " / " + GameManager.Instance.OpponentPlayer.GetMaxResource("MINERAL_RESOURCE");
         }
         
         Remove();
     }
     flyTimer = flyDelay;
 }
Exemple #26
0
    private bool lookingForTarget;//draw mouse

    public void OnSelectCard(CardEntity card)
    {
        if (card.curStatus == CardEntity.status.inSlot)
        {
            if (card.info.type == Card.Type.mogi)
            {
                List <MogiEntity> opponentMogis = BoardUI.Instance.MogiInBoard(false);

                if (!((MogiEntity)card).hadAttack)
                {
                    for (int i = 0; i < opponentMogis.Count; i++)
                    {
                        ((CardMogiDisplay)opponentMogis[i].display).Targeted();
                    }

                    lookingForTarget = true;

                    AttackArrow.Instance.Display(card.motion.cardTran);
                }
            }
        }
    }
Exemple #27
0
    public void RemoveCard(CardEntity card)
    {
        List <CardEntity> cardInHand = null;

        if (card.isController)
        {
            cardInHand = cardInControllerHand;
        }
        else
        {
            cardInHand = cardInOpponentHand;
        }

        cardInHand.Remove(card);

        //chaneg pos of when had remove
        for (int i = 0; i < cardInHand.Count; i++)
        {
            CardEntity cardRemain = cardInHand[i];
            cardInHand[i].motion.MoveToPosition(GetCardPosition(cardRemain), 1 + i * 2, false, 4);
        }
    }
        public async Task <bool> UpdateCardKnowledgeAsync(Guid cardId, bool isCorrect)
        {
            var card = await cardRepository.FindByIdAsync(cardId);

            if (card == null)
            {
                return(false);
            }

            var updatedCard = new CardEntity(
                cardId,
                card.DeckId,
                card.Question,
                card.Answer,
                card.Repetitions + 1,
                card.CorrectAnswers + (isCorrect ? 1 : 0),
                DateTime.Now
                );
            var updatedEntity = await cardRepository.UpdateAsync(updatedCard);

            return(updatedEntity != null);
        }
Exemple #29
0
        public async Task <bool> RegisterAsync(SubscriberModel subscriberModel)
        {
            SubscriberEntity subscriberEntity = _mapper.Map <SubscriberEntity>(subscriberModel);

            subscriberEntity.Id = Guid.NewGuid();
            CardEntity cardEntity = new CardEntity
            {
                OpenDate     = DateTime.Now,
                BMI          = 0,
                Height       = subscriberModel.Height,
                UpdateDate   = DateTime.Now,
                SubscriberId = subscriberEntity.Id
            };

            await _weightWatchersContext.Card.AddAsync(cardEntity);

            await _weightWatchersContext.Subscriber.AddAsync(subscriberEntity);

            await _weightWatchersContext.SaveChangesAsync();

            return(true);
        }
        protected override void InternalInitializeLayer(World world, ALevelNode levelNode)
        {
            int i = 0;

            this.CardsDeck.Clear();
            this.CardsHand.Clear();
            this.CardsCemetery.Clear();

            this.isCemeteryShowed = false;
            this.isHandShowed     = true;
            this.pileFocused      = PileFocused.HAND;
            this.pilePicked       = PileFocused.NONE;

            this.IsActiveTurn = false;

            this.SupportedPlayer = (levelNode as CardBoardLevel).GetPlayerFromIndex(world, out int currentPlayerIndex);
            this.IndexPlayer     = currentPlayerIndex;

            List <Card.Card> deckCards = this.SupportedPlayer.ConstructDeck(world.CardLibrary);

            foreach (Card.Card card in deckCards)
            {
                CardEntity cardEntity = new CardEntity(this, card, false);

                cardEntity.Position = this.DeckPosition;

                cardEntity.IsActive = i < TOP_DECK;

                this.CardsDeck.Add(cardEntity);
                this.AddEntityToLayer(cardEntity);

                i++;
            }

            this.nbCardsToDraw = 0;

            this.cardFocused = null;
        }
    // Use this for initialization
    void Start()
    {
        card = GameManager.Instance.GetEntity(data.causeId) as CardEntity;
        if (data.playerName == GameManager.Instance.MyPlayer.playerName)
        {
            isPlayer = true;
        }
        else
        {
            isPlayer = false;
            if (data.resource == "ENERGY_RESOURCE")
            {
                UIManager.Instance.enemyEnergy.text = data.amount + " / " + GameManager.Instance.OpponentPlayer.GetMaxResource("ENERGY_RESOURCE");
            }
            else
            {
                UIManager.Instance.enemyMinerals.text = data.amount + " / " + GameManager.Instance.OpponentPlayer.GetMaxResource("MINERAL_RESOURCE");
            }

            Remove();
        }
        flyTimer = flyDelay;
    }
        private void AddCardFocusedFillLink()
        {
            CardEntity cardEntity = this.object2DToObjects[this.CardFocused] as CardEntity;

            if (cardEntity.Card.IsAwakened)
            {
                this.linksFocused.Clear();
                if (cardEntity.Card.Constellation != null)
                {
                    IConstellation constellation = cardEntity.Card.Constellation;

                    foreach (List <StarLinkEntity> listStarLinks in constellation.LinkToStarLinkEntity.Values)
                    {
                        this.linksFocused.AddRange(listStarLinks.Select(pElem => this.objectToObject2Ds[pElem] as StarLinkEntity2D));
                    }
                }

                foreach (StarLinkEntity2D starLinkEntity2D in this.linksFocused)
                {
                    starLinkEntity2D.IsFocused = true;
                }
            }
        }
    //类别删除操作
    protected void CardList_RowDeleting(object sender, GridViewDeleteEventArgs e)
    {
        int cardId = Int32.Parse(CardList.DataKeys[e.RowIndex].Value.ToString());

        if (cardId == 0)
        {
            Utility.Alert(this, "不能删除我的钱包!");
            return;
        }

        CardEntity card = CardAccess.GetCardByCardId(cardId, userId);

        card.CardLive    = 0;
        card.Synchronize = 1;

        bool success = CardAccess.CheckItemListByCardId(userId, cardId);

        if (!success)
        {
            success = CardAccess.UpdateCard(card);
            if (success)
            {
                Utility.Alert(this, "删除成功。");

                CardList.EditIndex = -1;
                BindGrid();
            }
            else
            {
                Utility.Alert(this, "删除失败!");
            }
        }
        else
        {
            Utility.Alert(this, "不能删除已使用的钱包!");
        }
    }
Exemple #34
0
    public void InsertCard(CardEntity card)
    {
        List <CardEntity> cardInHand = null;

        if (card.isController)
        {
            cardInHand = cardInControllerHand;
        }
        else
        {
            cardInHand = cardInOpponentHand;
        }
        cardInHand.Add(card);

        if (cardInHand.Count > 0)
        {
            //chaneg pos of aready card
            for (int i = 0; i < cardInHand.Count; i++)
            {
                CardEntity oldCard = cardInHand[i];
                cardInHand[i].motion.MoveToPosition(GetCardPosition(oldCard), 1 + i * 2, false, 4);
            }
        }
    }
Exemple #35
0
        private void Initialize(CardEntity entity)
        {
            this.PlayerColor = entity.Card.CurrentOwner.PlayerColor;

            this.IsSocketed = entity.ParentStar != null;
            this.RatioColor = 1;
            this.cardName   = entity.Card.Name;
            this.isFliped   = entity.IsFliped;
            this.IsFocused  = false;
            this.IsSelected = entity.IsSelected;

            this.cooldownFocus = 0;

            //if (this.isFliped)
            //{
            //    this.cardIndex = this.Card2DFactory.GetIndexFromCardName(this.cardName);
            //}
            //else
            //{
            //    this.cardIndex = 1;
            //}

            this.InitializeFaceState();
        }
        public override bool OnControlActivated(Controls.ControlEventType eventType, string details, bool mustForwardEvent)
        {
            switch (this.LevelTurnPhase)
            {
            case TurnPhase.MAIN:
                mustForwardEvent = base.OnControlActivated(eventType, details, mustForwardEvent);

                if (eventType == ControlEventType.MOUSE_RIGHT_CLICK && details == "pressed" ||
                    eventType == ControlEventType.MOUSE_LEFT_CLICK && details == "click")
                {
                    if (this.CardPicked != null &&
                        this.CardPicked.IsSocketed)
                    {
                        Vector2i   mousePosition = this.MousePosition;
                        CardEntity cardEntity    = this.object2DToObjects[this.CardPicked] as CardEntity;

                        this.SendEventToWorld(Model.Event.EventType.MOVE_CARD_OVERBOARD, cardEntity, mousePosition.X + ":" + mousePosition.Y);
                    }
                }
                break;
            }

            return(mustForwardEvent);
        }
Exemple #37
0
    public SlotUI PutOnTopMogi(CardEntity moveCard, MogiEntity mogiCard)
    {
        SlotUI[] slots = null;

        if (moveCard.isController)
        {
            slots = controllerSlotUIs;
        }
        else
        {
            slots = opponentSlotUIs;
        }

        for (int i = 0; i < slots.Length; i++)
        {
            if (slots[i].cardEntity == mogiCard)
            {
                slots[i].PutOnTopOfMogi(moveCard, mogiCard);
                return(slots[i]);
            }
        }

        return(null);
    }
Exemple #38
0
    public bool InsertToSlot(CardEntity card)
    {
        SlotUI[] slots = null;

        if (card.isController)
        {
            slots = controllerSlotUIs;
        }
        else
        {
            slots = opponentSlotUIs;
        }

        for (int i = 0; i < slots.Length; i++)
        {
            if (slots[i].cardEntity == null)
            {
                slots[i].InsertToSlot(card);
                return(true);
            }
        }

        return(false);
    }
Exemple #39
0
    public CardModel(bool isDish, int cardID, int cost, int condition)
    {
        CardEntity cardEntity = null;

        if (isDish)
        {
            //cardEntity = Resources.Load<CardEntity>("CardEntityList/Dishes/Card" + cardID);
            cardEntity = CardData.instance.dishCardEntity[cardID];

            this.ingredientCardID = cardEntity.ingredientCardID;
        }
        else
        {
            //cardEntity = Resources.Load<CardEntity>("CardEntityList/Ingredients/Card" + cardID);
            cardEntity = CardData.instance.ingCardEntity[cardID];

            this.cost      = cost;
            this.condition = condition;
            partnerID      = cardEntity.partnerID;
            specialMixID   = cardEntity.specialMixID;
        }


        this.cardID = cardID;

        name = cardEntity.name;

        cal = cardEntity.cal;

        this.kind = cardEntity.kind;

        icon     = cardEntity.icon;
        glowIcon = cardEntity.glowIcon;

        isSelected = false;
    }
 void Start()
 {
     card = GameManager.Instance.GetEntity(command.CardEntityId).GetComponent<CardEntity>();
     transform.position = card.transform.position;
     card.lerpTransform.SetTransform(cardEnlarged, enlargeTime);
 }
		public Point GetCenterPos(CardEntity entity, bool top)
		{
			var xOffset = entity.ActualWidth / 2;
			var yOffset = entity.ActualHeight / 2;
			if(top)
				yOffset -= 12;
			else
			{
				yOffset += 12;
				yOffset *= -1;
			}
			var x = GetPosition(entity).X + xOffset;
			var y = GetPosition(entity).Y + yOffset;
			return new Point(x, y);
		}
Exemple #42
0
    //类别更新操作
    protected void CardList_RowUpdating(object sender, GridViewUpdateEventArgs e)
    {
        int cardId = Int32.Parse(CardList.DataKeys[e.RowIndex].Value.ToString());
        TextBox cardNameBox = (TextBox)CardList.Rows[e.RowIndex].FindControl("CardNameBox");
        string cardName = cardNameBox.Text.Trim();
        if (cardName == "")
        {
            Utility.Alert(this, "名称未填写!");
            return;
        }
        TextBox cardMoneyBox = (TextBox)CardList.Rows[e.RowIndex].FindControl("CardMoneyBox");
        string cardMoney = cardMoneyBox.Text.Trim();
        if (!ValidHelper.CheckDouble(cardMoney))
        {
            Utility.Alert(this, "余额填写错误!");
            return;
        }

        bool success = false;
        if (cardId == 0)
        {
            success = UserAccess.UpdateUserMoneyNew(userId, Double.Parse(cardMoney));
        }
        else
        {
            CardEntity card = new CardEntity();
            card.CardID = cardId;
            card.CardName = cardName;
            card.CardMoney = Double.Parse(cardMoney);
            card.UserID = userId;
            card.CardLive = 1;
            card.Synchronize = 1;

            success = CardAccess.UpdateCard(card);
        }

        if (success)
        {
            Utility.Alert(this, "更新成功。");

            CardList.EditIndex = -1;
            BindGrid();
        }
        else
        {
            Utility.Alert(this, "更新失败!");
        }
    }
Exemple #43
0
 public void RemoveCard(CardEntity card)
 {
     cards.Remove(card);
     RefreshPositions();
 }