public void AddCard(CardTable data)
{
if (ControlledDeckData.CardCount < 30)
{
UserCardData cardData = ControlledDeckData.DeckCards.Find((ucd) => ucd.cardIndex == data._Index);
DeckElement element;
if (cardData == null)
{
element = DeckElement.CreateDeckElement(Content.transform);
cardData = new UserCardData(data._Index, 1);
ControlledDeckData.DeckCards.Add(cardData);
DisplayDeckElementList.Add(element);
element.SetCardData(cardData);
SortingElement();
}
else
{
cardData.cardCount++;
element = DisplayDeckElementList.Find((de) => de.CardData == data);
element.SetCardData(cardData);
}
ControlledDeckData.CardCount++;
DeckCardCountText.text = ControlledDeckData.CardCount + "/30";
//add anim
}
}
public CardReplacer(Th06Converter parent, bool hideUntriedCards)
{
this.evaluator = new MatchEvaluator(match =>
{
var number = int.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture);
var type = match.Groups[2].Value.ToUpperInvariant();
if (CardTable.ContainsKey(number))
{
if (hideUntriedCards)
{
CardAttack attack;
if (!parent.allScoreData.CardAttacks.TryGetValue(number, out attack) ||
!attack.HasTried())
{
return((type == "N") ? "??????????" : "?????");
}
}
return((type == "N")
? CardTable[number].Name
: string.Join(
", ", CardTable[number].Levels.Select(lv => lv.ToString()).ToArray()));
}
else
{
return(match.ToString());
}
});
}
public CardReplacer(Th10Converter parent, bool hideUntriedCards)
{
this.evaluator = new MatchEvaluator(match =>
{
var number = int.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture);
var type = match.Groups[2].Value.ToUpperInvariant();
if (CardTable.ContainsKey(number))
{
if (type == "N")
{
if (hideUntriedCards)
{
var cards = parent.allScoreData.ClearData[CharaWithTotal.Total].Cards;
SpellCard card;
if (!cards.TryGetValue(number, out card) || !card.HasTried())
{
return("??????????");
}
}
return(CardTable[number].Name);
}
else
{
return(CardTable[number].Level.ToString());
}
}
else
{
return(match.ToString());
}
});
}
public static void SetRangeInterface(CardTable cardData)
{
Instance.RangeType = cardData._RangeType;
Instance.CardSpriteName = cardData._CardRangeSprite;
Instance.NeedUpdate = true;
Instance.IsVisible = false;
}
protected override void OnInventoryDirty()
{
base.OnInventoryDirty();
CardTable cardTable = GetCardTable();
if (cardTable != null)
{
cardTable.PlayerStorageChanged();
}
}
public static CardModel ToCardModel(this CardTable row)
{
if (row == null)
{
return(null);
}
var model = row.ConvertTo <CardModel>();
return(model);
}
//[Route("CardTable/{id}")]
public IHttpActionResult GetCardTable(long id)
{
CardTable cardTable = db.CardTables.Find(id);
if (cardTable == null)
{
return(NotFound());
}
return(Ok(cardTable));
}
bool SearchTextClippingList(CardTable card)
{
if (SearchText.text.Length == 0)
{
return(true);
}
else
{
return(card._krName.IndexOf(SearchText.text, StringComparison.CurrentCultureIgnoreCase) >= 0);
}
}
bool TapSectionClippingList(CardTable card)
{
if (CurrentTapOption == CardTapType.E_Owned)
{
return(UserData.Instance.OwnedCardList.Find((usd) => usd.cardIndex == card._Index) != null);
}
else
{
return(true);
}
}
public CardInfo GetCardbyNumber(string CardNo)
{
ObjectResult <CardTable> card = GetCardInfobyNumber(CardNo);
CardTable ocard = (CardTable)card.FirstOrDefault();
if (ocard == null)
{
return(null);
}
return(MappingModel(ocard));
}
static void Main()
{
CardTable mainTable = new CardTable();
List <IPlayer> initialPlayerList = new List <IPlayer>()
{
new FacelessPlayer(new FacelessFigure("FacelessPlayer 1", 4), mainTable),
new FacelessPlayer(new FacelessFigure("FacelessPlayer 2", 4), mainTable)
};
mainTable.PlayerList = initialPlayerList;
//mainTable.InitialCardsDealing();
mainTable.DealingSpecificCards(new List <List <ICard> >()
{
//new List<ICard>() {
// mainTable.CentralCardDeck.DrawSpecificCard(Func.Kill),
// mainTable.CentralCardDeck.DrawSpecificCard(Func.Duel),
// mainTable.CentralCardDeck.DrawSpecificCard(Func.PocketPicking),
// mainTable.CentralCardDeck.DrawSpecificCard(Func.Kill)
//},
//new List<ICard>() {
// mainTable.CentralCardDeck.DrawSpecificCard(Func.Duel),
// mainTable.CentralCardDeck.DrawSpecificCard(Func.Dodge),
// mainTable.CentralCardDeck.DrawSpecificCard(Func.Prison),
// mainTable.CentralCardDeck.DrawSpecificCard(Func.Dodge),
//}
new List <ICard>()
{
mainTable.CentralCardDeck.DrawSpecificCard(Func.Kill),
mainTable.CentralCardDeck.DrawSpecificCard(Func.Duel),
mainTable.CentralCardDeck.DrawSpecificCard(Func.Kill)
},
new List <ICard>()
{
mainTable.CentralCardDeck.DrawSpecificCard(Func.ParryAll),
mainTable.CentralCardDeck.DrawSpecificCard(Func.Kill),
mainTable.CentralCardDeck.DrawSpecificCard(Func.Kill),
}
});
mainTable.PrintAllPlayersCards();
mainTable.PlayerList[0].PlayerToKill = mainTable.PlayerList[1];
mainTable.PlayerList[0].PlayerToProtect = mainTable.PlayerList[0];
mainTable.PlayerList[1].PlayerToKill = mainTable.PlayerList[0];
mainTable.PlayerList[1].PlayerToProtect = mainTable.PlayerList[1];
mainTable.StartGame();
}
private void FrSys_Load_1(object sender, EventArgs e)
{
//加载卡列表CardTable
FieldInfo[] pArray = typeof(MT).GetFields();
foreach (FieldInfo p in pArray)
{
if (p.FieldType.Name == "CARD")
{
if (((CARD)p.GetValue(typeof(MT))).id == 5)
{
CardTable.AddCard(((CARD)p.GetValue(typeof(MT))));
}
}
if (p.FieldType.Name == "GPIO")
{
if (((GPIO)p.GetValue(typeof(MT))).card == MT.CARD_DMC3800_5)
{
if (((GPIO)p.GetValue(typeof(MT))).dir == GPIO.IO_DIR.OUT)//分类输入输出
{
ioTable.AddIO(((GPIO)p.GetValue(typeof(MT))));
}
if (((GPIO)p.GetValue(typeof(MT))).dir == GPIO.IO_DIR.IN)
{
ioTableIN.AddIO(((GPIO)p.GetValue(typeof(MT))));
}
}
}
if (p.FieldType.Name == "AXIS")
{
if (((AXIS)p.GetValue(typeof(MT))).card == MT.CARD_DMC3800_5)
{
axisTable.AddAxis(((AXIS)p.GetValue(typeof(MT))));
axisConfig.AddAxis(((AXIS)p.GetValue(typeof(MT))));
}
}
if (p.FieldType.Name == "Cylinder")
{
if (((Cylinder)p.GetValue(typeof(MT))).io_out.card == MT.CARD_DMC3800_5)
{
cylinderTable.AddCylinder(((Cylinder)p.GetValue(typeof(MT))));
}
}
}
ioTable.ShowCfg(2);//选择全部显示
ioTableIN.ShowCfg(2);
//轴列表
tabConSlect_SelectedIndexChanged(ctb_ax_sel, null);
}
public void LoadInitTable()
{
LoadTable <MiscTable>(ResManager.MISC_TABLE, (value) => {
ResManager.Instance.miscTable = value;
ResManager.Instance.miscTable.Init();
});
LoadTable <AudioTable>(ResManager.AUDIO_TABLE, (value) => { ResManager.Instance.audioTable = value; });
LoadTable <LocalizationTable>(ResManager.LOCALIZATION_TABLE, (value) => { ResManager.Instance.localizationTable = value; });
LoadTable <SceneTable>(ResManager.SCENE_TABLE, (value) => { ResManager.Instance.sceneTable = value; });
LoadTable <LevelTable>(ResManager.LEVEL_TABLE, (value) => { ResManager.Instance.levelTable = value; });
LoadTable <DialogueTable>(DIALOGUE_TABLE, (value) => { dialogueTable = value; });
LoadTable <CardTable>(CARD_TABLE, (value) => { cardTable = value; });
LoadTable <UnitTable>(UNIT_TABLE, (value) => { unitTable = value; });
}
public Card(CardTable data)
{
Data = data;
Cost = data._Cost;
CardName = data._krName;
CardLoreFormat = data._Lore;
CardStatus = data._Parameter.ToList();
IsVariableStatus = data._IsVariable.ToList();
ParameterCount = data._ParameterCount;
CardActionName = data._FSM;
TargetType = data._TargetType;
FrontSprite = ResourceManager.GetResource <Sprite>(data._ImagePath);
BackSprite = ResourceManager.GetResource <Sprite>("Sprites/Card/card_sample_back");
}
bool CostSectionClippingList(CardTable card)
{
if (CurrentCostOption == CardCostType.E_All)
{
return(true);
}
else if (CurrentCostOption == CardCostType.E_7Plus)
{
return(card._Cost >= 7);
}
else
{
return(card._Cost == (int)CurrentCostOption - 1);
}
}
public CardGameController(CardTable owner)
{
Owner = owner;
playerData = new CardPlayerData[MaxPlayersAtTable()];
winnerInfo = Pool.Get <ProtoBuf.CardTable.WinnerBreakdown>();
winnerInfo.winners = Pool.GetList <ProtoBuf.CardTable.WinnerBreakdown.Winner>();
winnerInfo.winningScore = 0;
localPlayerCards = Pool.Get <ProtoBuf.CardTable.CardList>();
localPlayerCards.cards = Pool.GetList <int>();
if (IsServer)
{
for (int i = 0; i < playerData.Length; i++)
{
playerData[i] = new CardPlayerData(ScrapItemID, owner.GetPlayerStorage, i, IsServer);
}
}
}
private IEnumerator OnClickCo()
{
// Front이미지 변경
//int selectCardNumber = Random.Range(0, 22);
int selectCardNumber = Random.Range(0, 2);
var cardInfo = CardTable.GetAt(selectCardNumber);
UIManager.selectCardInfo = cardInfo;
Sprite sprite = Resources.Load <Sprite>("TarotCard/" + selectCardNumber);
frontImage.sprite = sprite;
// 선택 애니메이션 실행
animation.Play("Pick");
yield return(new WaitForSeconds(1));
LoadingUI.instance.Init();
}
private void timerUpdate_Tick_1(object sender, EventArgs e)
{
int t;
timerUpdate.Enabled = false;
switch (tabConSlect.SelectedIndex)
{
case 0:
t = Environment.TickCount;
CardTable.UpdateShow();
t = Environment.TickCount - t;
// lb_card_update_ms.Text = string.Format("{0}ms", t);
break;
case 1:
t = Environment.TickCount;
axisTable.UpdateShow();
t = Environment.TickCount - t;
// lb_ax_update_ms.Text = string.Format("{0}ms", t);
break;
case 2:
if (ioTable.Visible)
{
ioTable.UpdateShow();
}
if (ioTableIN.Visible)
{
ioTableIN.UpdateShow();
}
if (cylinderTable.Visible)
{
cylinderTable.UpdateShow();
}
// lb_io_update_ms.Text = string.Format("{0}ms", ioTable.UpdateCt);
break;
}
//CardTable.UpdateShow();
timerUpdate.Interval = 500;
timerUpdate.Enabled = true;
}
public CareerReplacer(Th10Converter parent)
{
this.evaluator = new MatchEvaluator(match =>
{
var number = int.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture);
var chara = CharaWithTotalParser.Parse(match.Groups[2].Value);
var type = int.Parse(match.Groups[3].Value, CultureInfo.InvariantCulture);
Func <SpellCard, int> getCount;
if (type == 1)
{
getCount = (card => card.ClearCount);
}
else
{
getCount = (card => card.TrialCount);
}
var cards = parent.allScoreData.ClearData[chara].Cards;
if (number == 0)
{
return(Utils.ToNumberString(cards.Values.Sum(getCount)));
}
else if (CardTable.ContainsKey(number))
{
SpellCard card;
if (cards.TryGetValue(number, out card))
{
return(Utils.ToNumberString(getCount(card)));
}
else
{
return("0");
}
}
else
{
return(match.ToString());
}
});
}
public CareerReplacer(Th06Converter parent)
{
this.evaluator = new MatchEvaluator(match =>
{
var number = int.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture);
var type = int.Parse(match.Groups[2].Value, CultureInfo.InvariantCulture);
Func <CardAttack, int> getCount;
if (type == 1)
{
getCount = (attack => attack.ClearCount);
}
else
{
getCount = (attack => attack.TrialCount);
}
if (number == 0)
{
return(Utils.ToNumberString(parent.allScoreData.CardAttacks.Values.Sum(getCount)));
}
else if (CardTable.ContainsKey(number))
{
CardAttack attack;
if (parent.allScoreData.CardAttacks.TryGetValue(number, out attack))
{
return(Utils.ToNumberString(getCount(attack)));
}
else
{
return("0");
}
}
else
{
return(match.ToString());
}
});
}
public static CardTable Load(string[] parts)
{
int i = 0;
CardTable p = new CardTable();
p._Index = int.Parse(parts[i++]);
p._Name = parts[i++];
p._krName = parts[i++];
p._TargetType = (CardTargetType)System.Enum.Parse(typeof(CardTargetType), parts[i++]);
p._Lore = parts[i++];
p._ImagePath = parts[i++];
p._Cost = int.Parse(parts[i++]);
p._FSM = parts[i++];
p._ParameterCount = int.Parse(parts[i++]);
p._Parameter[0] = float.Parse(parts[i++]);
p._Parameter[1] = float.Parse(parts[i++]);
p._IsVariable[0] = bool.Parse(parts[i++]);
p._IsVariable[1] = bool.Parse(parts[i++]);
p._CardRangeSprite = parts[i++];
p._RangeType = (CardRangeType)System.Enum.Parse(typeof(CardRangeType), parts[i++]);
return(p);
}
public HttpResponseMessage useractivate(string username)
{
try
{
var ad = (from a in db.Admins
where a.UserName == username
select a).FirstOrDefault();
if (ad.ActivationStatus == true)
{
throw new Exception("UserActivated Already");
}
else
{
ad.ActivationStatus = true;
CardTable ct = new CardTable();
ct.CardType = (from consumer in db.ConsumerTables
where consumer.UserName == username
select consumer.CardType).FirstOrDefault();
ct.Name = username;
ct.RemainingCredit = (from cardtype in db.CardTypeTables
where cardtype.CardType == ct.CardType
select cardtype.TotalCredit).FirstOrDefault();
ct.TotalCredit = Convert.ToInt32((from cardtype in db.CardTypeTables
where cardtype.CardType == ct.CardType
select cardtype.TotalCredit).FirstOrDefault());
ct.ValidTill = db.validtill().FirstOrDefault().ToString();
db.CardTables.Add(ct);
db.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK, "UserActivated"));
}
}
catch (Exception)
{
return(Request.CreateResponse(HttpStatusCode.OK, "Activation Failed"));
}
}
public static PlayerCallTransitionAction GetInstance(CardTable dataTable, TargetData target)
{
return(new PlayerCallTransitionAction(dataTable, target));
}
public PlayerCallTransitionAction(CardTable dataTable, TargetData target) : base(dataTable, target)
{
}
public static PlayerGroundPowerAttackAction GetInstance(CardTable dataTable, TargetData target)
{
return(new PlayerGroundPowerAttackAction(dataTable, target));
}
public PlayerGroundPowerAttackAction(CardTable dataTable, TargetData target) : base(dataTable, target)
{
}
public CardInfo MappingModel(CardTable card)
{
CardInfo oCard = (card != null) ? CardInfo.Create(card.NameOnCard, card.CardNumber, card.ExpiryDate) : null;
return(oCard);
}
public static void ChangeCardAction(Character owner, string actionName, CardTable data, TargetData target)
{
owner.CurrentAction = (CharacterAction)Type.GetType(actionName).GetMethod("GetInstance", BindingFlags.Public | BindingFlags.Static).Invoke(null, new object[] { data, target });
}
public static PlayerDrawCardAction GetInstance(CardTable dataTable, TargetData target)
{
return(new PlayerDrawCardAction(dataTable, target));
}
public PlayerDrawCardAction(CardTable dataTable, TargetData target) : base(dataTable, target)
{
}
